@paraswap/dex-lib 3.8.0 → 3.8.1

package/src/dex/zerox/index.ts

@@ -1,328 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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);
-  });
-});