@paraswap/dex-lib 2.35.3-quick-perps-proxy.3 → 2.35.4

package/src/dex/quick-perps/quick-perps.ts

@@ -117,55 +117,45 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
     limitPools?: string[],
   ): Promise<null | ExchangePrices<QuickPerpsData>> {
     if (side === SwapSide.BUY || !this.pool) return null;
-    try {
-      const srcAddress = this.dexHelper.config
-        .wrapETH(srcToken)
-        .address.toLowerCase();
-      const destAddress = this.dexHelper.config
-        .wrapETH(destToken)
-        .address.toLowerCase();
-      if (
-        srcAddress === destAddress ||
-        !(
-          this.supportedTokensMap[srcAddress] &&
-          this.supportedTokensMap[destAddress]
-        )
+    const srcAddress = this.dexHelper.config
+      .wrapETH(srcToken)
+      .address.toLowerCase();
+    const destAddress = this.dexHelper.config
+      .wrapETH(destToken)
+      .address.toLowerCase();
+    if (
+      srcAddress === destAddress ||
+      !(
+        this.supportedTokensMap[srcAddress] &&
+        this.supportedTokensMap[destAddress]
       )
-        return null;
-      const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
-      const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
-      const pools = [srcPoolIdentifier, destPoolIdentifier];
-      if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
+    )
+      return null;
+    const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
+    const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
+    const pools = [srcPoolIdentifier, destPoolIdentifier];
+    if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
 
-      const unitVolume = getBigIntPow(srcToken.decimals);
-      const prices = await this.pool.getAmountOut(
-        srcAddress,
-        destAddress,
-        [unitVolume, ...amounts],
-        blockNumber,
-      );
+    const unitVolume = getBigIntPow(srcToken.decimals);
+    const prices = await this.pool.getAmountOut(
+      srcAddress,
+      destAddress,
+      [unitVolume, ...amounts],
+      blockNumber,
+    );
 
-      if (!prices) return null;
+    if (!prices) return null;
 
-      return [
-        {
-          prices: prices.slice(1),
-          unit: prices[0],
-          gasCost: QuickPerpsGasCost,
-          exchange: this.dexKey,
-          data: {},
-          poolAddresses: [this.params.vault],
-        },
-      ];
-    } catch (e) {
-      this.logger.error(
-        `Error_getPrices ${srcToken.symbol || srcToken.address}, ${
-          destToken.symbol || destToken.address
-        }, ${side}: `,
-        e,
-      );
-      return null;
-    }
+    return [
+      {
+        prices: prices.slice(1),
+        unit: prices[0],
+        gasCost: QuickPerpsGasCost,
+        exchange: this.dexKey,
+        data: {},
+        poolAddresses: [this.params.vault],
+      },
+    ];
   }
 
   // Returns estimated gas cost of calldata for this DEX in multiSwap

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

@@ -106,6 +106,19 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/lynnshaoyu/uniswap-v3-avax',
     },
+    [Network.BASE]: {
+      factory: '0x33128a8fC17869897dcE68Ed026d694621f6FDfD',
+      quoter: '0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a',
+      router: '0xaeE2b8d4A154e36f479dAeCe3FB3e6c3c03d396E',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x7160f736c52e1e78e92FD4eE4D73e21A7Cf4F950',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/48211/uniswap-v3-base/version/latest',
+    },
   },
   SushiSwapV3: {
     [Network.MAINNET]: {
@@ -283,4 +296,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 5 }],
     [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 6 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 1 }],
+  },
 };

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

@@ -403,6 +403,101 @@ describe('UniswapV3 E2E', () => {
       );
     });
 
+    describe('UniswapV3 Base', () => {
+      const network = Network.BASE;
+      const tokens = Tokens[network];
+      const holders = Holders[network];
+      const provider = new StaticJsonRpcProvider(
+        generateConfig(network).privateHttpProvider,
+        network,
+      );
+
+      const tokenASymbol: string = 'PRIME';
+      const tokenBSymbol: string = 'WETH';
+      const nativeTokenSymbol = NativeTokenSymbols[network];
+
+      const tokenAAmount: string = '1000000000000000000';
+      const tokenBAmount: string = '1000000000000000000';
+      const nativeTokenAmount = '1000000000000000000';
+
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            // ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            // ContractMethod.megaSwap,
+          ],
+        ],
+        [
+          SwapSide.BUY,
+          [
+            // ContractMethod.simpleBuy,
+            // ContractMethod.buy
+          ],
+        ],
+      ]);
+
+      sideToContractMethods.forEach((contractMethods, side) =>
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${network} ${side} ${contractMethod} ${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${network} ${side} ${contractMethod} ${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        }),
+      );
+    });
+
     describe('UniswapV3 Avalanche', () => {
       const network = Network.AVALANCHE;
       const tokens = Tokens[network];

package/src/dex/weth/config.ts

@@ -25,6 +25,9 @@ export const WethConfig: DexConfigMap<DexParams> = {
     [Network.ZKEVM]: {
       poolGasCost: WethGasCost,
     },
+    [Network.BASE]: {
+      poolGasCost: WethGasCost,
+    },
   },
   Wbnb: {
     [Network.BSC]: {

package/src/lib/api3-feed.ts

@@ -51,14 +51,6 @@ export class Api3FeedSubscriber<State> extends PartialEventSubscriber<
     };
   }
 
-  static getDapiNameHashMultiCallInput(proxy: Address): MultiCallInput {
-    return {
-      target: proxy,
-      callData:
-        Api3FeedSubscriber.proxyInterface.encodeFunctionData('dapiNameHash'),
-    };
-  }
-
   static getDataFeedId(proxy: Address): MultiCallInput {
     return {
       target: proxy,
@@ -67,33 +59,6 @@ export class Api3FeedSubscriber<State> extends PartialEventSubscriber<
     };
   }
 
-  static getFeedIdFromDapiNameHash(
-    api3Server: Address,
-    dapiNameHash: string,
-  ): MultiCallInput {
-    return {
-      target: api3Server,
-      callData: Api3FeedSubscriber.api3ServerV1Iface.encodeFunctionData(
-        'dapiNameHashToDataFeedId',
-        [dapiNameHash],
-      ),
-    };
-  }
-
-  static decodeFeedIdFromDapiNameHash(multicallOutput: MultiCallOutput) {
-    return Api3FeedSubscriber.api3ServerV1Iface.decodeFunctionResult(
-      'dapiNameHashToDataFeedId',
-      multicallOutput,
-    )[0];
-  }
-
-  static decodeDapiNameHash(multicallOutput: MultiCallOutput) {
-    return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
-      'dapiNameHash',
-      multicallOutput,
-    )[0];
-  }
-
   static decodeDataFeedId(multicallOutput: MultiCallOutput) {
     return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
       'dataFeedId',

package/tests/constants-e2e.ts

@@ -883,6 +883,17 @@ export const Tokens: {
       decimals: 6,
     },
   },
+  [Network.BASE]: {
+    PRIME: {
+      address: '0xfA980cEd6895AC314E7dE34Ef1bFAE90a5AdD21b',
+      decimals: 18,
+    },
+    WETH: {
+      address: '0x4200000000000000000000000000000000000006',
+      decimals: 18,
+    },
+    ETH: { address: ETHER_ADDRESS, decimals: 18 },
+  },
 };
 
 export const Holders: {
@@ -1102,6 +1113,11 @@ export const Holders: {
     WBTC: '0x99b31498b0a1dae01fc3433e3cb60f095340935c',
     USDC: '0x99b31498b0a1dae01fc3433e3cb60f095340935c',
   },
+  [Network.BASE]: {
+    WETH: '0x4bb6b2efe7036020ba6f02a05602546c9f25bf28',
+    PRIME: '0x956bcc6b56c99db382d9d97a30ba5f1402144b3e',
+    ETH: '0xdd9176ea3e7559d6b68b537ef555d3e89403f742',
+  },
 };
 
 export const SmartTokens = Object.keys(Tokens).reduce((acc, _network) => {
@@ -1126,4 +1142,5 @@ export const NativeTokenSymbols: { [network: number]: string } = {
   [Network.FANTOM]: 'FTM',
   [Network.ARBITRUM]: 'ETH',
   [Network.OPTIMISM]: 'ETH',
+  [Network.BASE]: 'ETH',
 };

package/build/abi/quickPerps/fast-price-events.json

@@ -1,70 +0,0 @@
-[
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "token",
-                "type": "address"
-            },
-            {
-                "indexed": false,
-                "internalType": "uint256",
-                "name": "price",
-                "type": "uint256"
-            },
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "priceFeed",
-                "type": "address"
-            }
-        ],
-        "name": "PriceUpdate",
-        "type": "event"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_token", "type": "address" },
-            { "internalType": "uint256", "name": "_price", "type": "uint256" }
-        ],
-        "name": "emitPriceEvent",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "gov",
-        "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "name": "isPriceFeed",
-        "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_gov", "type": "address" }
-        ],
-        "name": "setGov",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_priceFeed", "type": "address" },
-            { "internalType": "bool", "name": "_isPriceFeed", "type": "bool" }
-        ],
-        "name": "setIsPriceFeed",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    }
-]