@paraswap/dex-lib 3.7.9-dex-deprecation.0 → 3.8.0

package/src/dex/zerox/index.ts

@@ -0,0 +1,328 @@
+import { AbiEncoder } from '@0x/utils';
+import { Interface } from '@ethersproject/abi';
+
+import IParaswapAbi from '../../abi/IParaswap.json';
+import ZRX_V2_ABI from '../../abi/zrx.v2.json';
+import ZRX_V3_ABI from '../../abi/zrx.v3.json';
+import ZRX_V4_ABI from '../../abi/zrx.v4.json';
+
+import { SwapSide } from '../../constants';
+import { SimpleExchange } from '../simple-exchange';
+import { ZeroXOrder } from './order';
+
+import type { IDexTxBuilder } from '../idex';
+import type {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+  TxInfo,
+} from '../../types';
+import {
+  ZeroXFunctions,
+  type ZeroXData,
+  type ZeroXParam,
+  type ZeroXSignedOrderV2,
+  type ZeroXSignedOrderV4,
+} from './types';
+import { IDexHelper } from '../../dex-helper';
+import { ZRX_EXCHANGE, ZRX_EXCHANGE_ERC20PROXY } from './config';
+
+const ZRX_ABI: any = {
+  2: ZRX_V2_ABI,
+  3: ZRX_V3_ABI,
+  4: ZRX_V4_ABI,
+};
+
+export class ZeroX
+  extends SimpleExchange
+  implements IDexTxBuilder<ZeroXData, ZeroXParam>
+{
+  static dexKeys = ['zerox'];
+  routerInterface: Interface;
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'zerox');
+    this.routerInterface = new Interface(IParaswapAbi);
+  }
+
+  private getExchange(data: ZeroXData) {
+    return ZRX_EXCHANGE[this.network][data.version];
+  }
+
+  protected buildSimpleSwapData(data: ZeroXData, srcAmount: NumberAsString) {
+    const zrxABI = ZRX_ABI[data.version];
+    const signature = data.order.signature;
+    const order = ZeroXOrder.formatOrders(data.order, data.version);
+
+    const methodAbi = zrxABI.find(
+      (m: any) =>
+        m.name ===
+        (data.version === 4 ? 'fillRfqOrder' : 'marketSellOrdersNoThrow'),
+    );
+
+    const abiEncoder = new AbiEncoder.Method(methodAbi);
+    // TODO: fillLimitOrder only accepts one order, find something that can accept multiple orders
+    return abiEncoder.encode(
+      data.version === 4
+        ? [order, signature, srcAmount]
+        : [[order], srcAmount, [signature]],
+    );
+  }
+
+  protected buildPayload(data: ZeroXData) {
+    const payload =
+      data.version === 4
+        ? this.abiCoder.encodeParameter(
+            {
+              ParentStruct: {
+                order: {
+                  makerToken: 'address',
+                  takerToken: 'address',
+                  makerAmount: 'uint128',
+                  takerAmount: 'uint128',
+                  maker: 'address',
+                  taker: 'address',
+                  txOrigin: 'address',
+                  pool: 'bytes32',
+                  expiry: 'uint64',
+                  salt: 'uint256',
+                },
+                signature: {
+                  signatureType: 'uint8',
+                  v: 'uint8',
+                  r: 'bytes32',
+                  s: 'bytes32',
+                },
+              },
+            },
+            {
+              order: ZeroXOrder.formatOrders(data.order, 4),
+              signature: data.order.signature,
+            },
+          )
+        : this.abiCoder.encodeParameter(
+            {
+              ParentStruct: {
+                'orders[]': {
+                  makerAddress: 'address', // Address that created the order.
+                  takerAddress: 'address', // Address that is allowed to fill the order. If set to 0, any address is allowed to fill the order.
+                  feeRecipientAddress: 'address', // Address that will receive fees when order is filled.
+                  senderAddress: 'address', // Address that is allowed to call Exchange contract methods that affect this order. If set to 0, any address is allowed to call these methods.
+                  makerAssetAmount: 'uint256', // Amount of makerAsset being offered by maker. Must be greater than 0.
+                  takerAssetAmount: 'uint256', // Amount of takerAsset being bid on by maker. Must be greater than 0.
+                  makerFee: 'uint256', // Fee paid to feeRecipient by maker when order is filled.
+                  takerFee: 'uint256', // Fee paid to feeRecipient by taker when order is filled.
+                  expirationTimeSeconds: 'uint256', // Timestamp in seconds at which order expires.
+                  salt: 'uint256', // Arbitrary number to facilitate uniqueness of the order's hash.
+                  makerAssetData: 'bytes', // Encoded data that can be decoded by a specified proxy contract when transferring makerAsset. The leading bytes4 references the id of the asset proxy.
+                  takerAssetData: 'bytes',
+                },
+                signatures: 'bytes[]',
+              },
+            },
+            {
+              orders: [ZeroXOrder.formatOrders(data.order, 2)],
+              signatures: [data.order.signature],
+            },
+          );
+    return payload;
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    toAmount: NumberAsString, // required for buy case
+    data: ZeroXData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: this.getExchange(data),
+      payload: this.buildPayload(data),
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    src: Address,
+    dest: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: ZeroXData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    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);
+    const networkFees = '0';
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      src,
+      srcAmount,
+      dest,
+      destAmount,
+      swapData,
+      this.getExchange(data),
+      ZRX_EXCHANGE_ERC20PROXY[this.network][data.version],
+      networkFees,
+    );
+  }
+
+  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),
+      returnAmountPos: undefined,
+    };
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: ZeroXData,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod: string,
+  ): TxInfo<ZeroXParam> {
+    const usePermit = permit !== '0x';
+    const encoder = (...params: ZeroXParam) => {
+      switch (data.version) {
+        case 2:
+          return this.routerInterface.encodeFunctionData(
+            usePermit
+              ? ZeroXFunctions.swapOnZeroXv2WithPermit
+              : ZeroXFunctions.swapOnZeroXv2,
+            params,
+          );
+        case 4:
+          return this.routerInterface.encodeFunctionData(
+            usePermit
+              ? ZeroXFunctions.swapOnZeroXv4WithPermit
+              : ZeroXFunctions.swapOnZeroXv4,
+            params,
+          );
+        default:
+          throw new Error(`ZeroX version ${data.version} is not supported!`);
+      }
+    };
+    return {
+      params: usePermit
+        ? [
+            srcToken,
+            destToken,
+            srcAmount,
+            destAmount,
+            this.getExchange(data),
+            this.buildPayload(data),
+            permit,
+          ]
+        : [
+            srcToken,
+            destToken,
+            srcAmount,
+            destAmount,
+            this.getExchange(data),
+            this.buildPayload(data),
+          ],
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [ZeroXFunctions.swapOnZeroXv2, ZeroXFunctions.swapOnZeroXv4];
+  }
+}

package/src/dex/zerox/order.ts

@@ -0,0 +1,62 @@
+import {
+  ZeroXSignedOrder,
+  ZeroXSignedOrderV2,
+  ZeroXSignedOrderV4,
+} from './types';
+
+export class ZeroXOrder {
+  static formatOrderV4(order: ZeroXSignedOrderV4, version: number) {
+    return {
+      makerToken: order.makerToken,
+      takerToken: order.takerToken,
+      makerAmount: order.makerAmount,
+      takerAmount: order.takerAmount,
+      maker: order.maker,
+      taker: order.taker,
+      txOrigin: order.txOrigin,
+      pool: order.pool,
+      expiry: order.expiry,
+      salt: order.salt,
+    };
+  }
+
+  static formatOrderV23(order: ZeroXSignedOrderV2, version: number) {
+    const feeAssetData =
+      version === 3
+        ? {
+            makerFeeAssetData: order.makerFeeAssetData,
+            takerFeeAssetData: order.takerFeeAssetData,
+          }
+        : {};
+
+    return {
+      makerAddress: order.makerAddress,
+      takerAddress: order.takerAddress,
+      feeRecipientAddress: order.feeRecipientAddress,
+      senderAddress: order.senderAddress,
+      makerAssetAmount: order.makerAssetAmount,
+      takerAssetAmount: order.takerAssetAmount,
+      makerFee: order.makerFee,
+      takerFee: order.takerFee,
+      expirationTimeSeconds: order.expirationTimeSeconds,
+      salt: order.salt,
+      makerAssetData: order.makerAssetData,
+      takerAssetData: order.takerAssetData,
+      ...feeAssetData,
+    };
+  }
+
+  static formatOrders(order: ZeroXSignedOrder, version: number = 2) {
+    if (isV4Order(order, version)) {
+      return ZeroXOrder.formatOrderV4(order, version);
+    }
+    return ZeroXOrder.formatOrderV23(order, version);
+  }
+}
+
+function isV4Order(
+  order: ZeroXSignedOrder,
+  version: number = 2,
+): order is ZeroXSignedOrderV4 {
+  return version === 4;
+}

package/src/dex/zerox/types.ts

@@ -0,0 +1,82 @@
+import { Address } from '@paraswap/sdk';
+import { NumberAsString } from '../../types';
+
+export enum OrderStatus {
+  INVALID, // Default value
+  INVALID_MAKER_ASSET_AMOUNT, // Order does not have a valid maker asset amount
+  INVALID_TAKER_ASSET_AMOUNT, // Order does not have a valid taker asset amount
+  FILLABLE, // Order is fillable
+  EXPIRED, // Order has already expired
+  FULLY_FILLED, // Order is fully filled
+  CANCELLED, // Order has been cancelled
+}
+
+type Value = NumberAsString | number;
+
+export interface ZeroXSignedOrderV2 {
+  senderAddress: string;
+  makerAddress: string;
+  takerAddress: string;
+  makerFee: Value;
+  takerFee: Value;
+  makerAssetAmount: Value;
+  takerAssetAmount: Value;
+  makerAssetData: string;
+  takerAssetData: string;
+  salt: Value;
+  exchangeAddress: string;
+  feeRecipientAddress: string;
+  expirationTimeSeconds: Value;
+  makerFeeAssetData: string;
+  takerFeeAssetData: string;
+  signature: string;
+}
+
+export interface ZeroXSignedOrderV4 {
+  makerToken: string;
+  takerToken: string;
+  makerAmount: Value;
+  takerAmount: Value;
+  maker: string;
+  taker: string;
+  txOrigin: string;
+  pool: string;
+  expiry: Value;
+  salt: Value;
+  signature: any; // TODO: fix type
+}
+
+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/tests/constants-e2e.ts

@@ -1556,7 +1556,7 @@ export const Holders: {
     USDA: '0x2686bC6A56D205010637CE1DF124b20Cb19E4054',
     stUSD: '0x4e83c0a323b68E3Bc7CC8a4E35326Fd0544A291E',
     crvUSD: '0xA920De414eA4Ab66b97dA1bFE9e6EcA7d4219635',
-    GHO: '0x844Dc85EdD8492A56228D293cfEbb823EF3E10EC',
+    GHO: '0x0F11640BF66e2D9352d9c41434A5C6E597c5e4c8',
     wibBTC: '0xFbdCA68601f835b27790D98bbb8eC7f05FDEaA9B',
     MATIC: '0x7073783eee7e9b3e6e4ddac4d7f49dc46044dd9a',
     POL: '0x05A47D9f589a001C15E38D068dCc5DaE6D96a2eb',

package/tests/utils-e2e.ts

@@ -43,6 +43,7 @@ import {
   constructSimpleSDK,
   SimpleFetchSDK,
 } from '@paraswap/sdk';
+import { ParaSwapVersion } from '@paraswap/core';
 import axios from 'axios';
 import { SmartToken, StateOverrides } from './smart-tokens';
 import {
@@ -127,6 +128,7 @@ class APIParaswapSDK implements IParaSwapSDK {
   ) {
     this.dexKeys = Array.isArray(dexKeys) ? dexKeys : [dexKeys];
     this.paraSwap = constructSimpleSDK({
+      version: ParaSwapVersion.V6,
       chainId: network,
       axios,
       apiURL: testingEndpoint,

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