@dhedge/v2-sdk 1.10.7 → 1.10.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.10.7",
+  "version": "1.10.8",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",
@@ -34,7 +34,7 @@
     "@size-limit/preset-small-lib": "^5.0.1",
     "@types/jest": "^28.1.7",
     "@types/lodash": "^4.14.178",
-    "hardhat": "2.19.3",
+    "hardhat": "2.22.18",
     "husky": "^7.0.1",
     "jest": "^28.1.3",
     "size-limit": "^5.0.1",

package/src/abi/INonfungiblePositionManager.json

@@ -822,34 +822,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "from",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "tokenId",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "_data",
-          "type": "bytes"
-        }
-      ],
-      "name": "safeTransferFrom",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {

package/src/abi/IPancakeMasterChefV3.json

@@ -0,0 +1,115 @@
+[
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "tokenId",
+				"type": "uint256"
+			},
+			{
+				"internalType": "address",
+				"name": "to",
+				"type": "address"
+			}
+		],
+		"name": "harvest",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "reward",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "_tokenId",
+				"type": "uint256"
+			},
+			{
+				"internalType": "address",
+				"name": "_to",
+				"type": "address"
+			}
+		],
+		"name": "withdraw",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "reward",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+		  {
+			"internalType": "bytes[]",
+			"name": "data",
+			"type": "bytes[]"
+		  }
+		],
+		"name": "multicall",
+		"outputs": [
+		  {
+			"internalType": "bytes[]",
+			"name": "results",
+			"type": "bytes[]"
+		  }
+		],
+		"stateMutability": "payable",
+		"type": "function"
+	  },
+	  {
+		"inputs": [
+		  {
+			"components": [
+			  {
+				"internalType": "uint256",
+				"name": "tokenId",
+				"type": "uint256"
+			  },
+			  {
+				"internalType": "address",
+				"name": "recipient",
+				"type": "address"
+			  },
+			  {
+				"internalType": "uint128",
+				"name": "amount0Max",
+				"type": "uint128"
+			  },
+			  {
+				"internalType": "uint128",
+				"name": "amount1Max",
+				"type": "uint128"
+			  }
+			],
+			"internalType": "struct INonfungiblePositionManager.CollectParams",
+			"name": "params",
+			"type": "tuple"
+		  }
+		],
+		"name": "collect",
+		"outputs": [
+		  {
+			"internalType": "uint256",
+			"name": "amount0",
+			"type": "uint256"
+		  },
+		  {
+			"internalType": "uint256",
+			"name": "amount1",
+			"type": "uint256"
+		  }
+		],
+		"stateMutability": "payable",
+		"type": "function"
+	  }
+]

package/src/config.ts

@@ -87,7 +87,9 @@ export const stakingAddress: AddressDappNetworkMap = {
   [Network.ARBITRUM]: {
     [Dapp.COMPOUNDV3]: "0x88730d254a2f7e6ac8388c3198afd694ba9f7fae"
   },
-  [Network.BASE]: {}
+  [Network.BASE]: {
+    [Dapp.PANCAKECL]: "0xC6A2Db661D5a5690172d8eB0a7DEA2d3008665A3"
+  }
 };
 
 export const aaveAddressProvider: AddressDappNetworkMap = {
@@ -120,7 +122,8 @@ export const nonfungiblePositionManagerAddress: AddressDappNetworkMap = {
   },
   [Network.BASE]: {
     [Dapp.UNISWAPV3]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
-    [Dapp.AERODROMECL]: "0x827922686190790b37229fd06084350e74485b72"
+    [Dapp.AERODROMECL]: "0x827922686190790b37229fd06084350e74485b72",
+    [Dapp.PANCAKECL]: "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364"
   }
 };
 

package/src/entities/pool.ts

@@ -46,8 +46,8 @@ import {
 } from "../services/toros/easySwapper";
 import { getAaveV3ClaimTxData } from "../services/aave/incentives";
 import {
+  getClOwner,
   getVelodromeAddLiquidityTxData,
-  getVelodromeClOwner,
   getVelodromeRemoveLiquidityTxData
 } from "../services/velodrome/liquidity";
 import {
@@ -81,6 +81,11 @@ import {
   getCompoundV3WithdrawTxData
 } from "../services/compound/lending";
 import { getCompoundV3ClaimTxData } from "../services/compound/rewards";
+import {
+  getPancakeHarvestClaimTxData,
+  getPancakeStakeTxData,
+  getPancakeUnStakeTxData
+} from "../services/pancake/staking";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -582,12 +587,19 @@ export class Pool {
       case Dapp.AERODROMECL:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
+      case Dapp.PANCAKECL:
+        stakeTxData = getPancakeStakeTxData(this, amount.toString(), gauge);
+        break;
       default:
         throw new Error("dapp not supported");
     }
+    const txTo =
+      dapp !== Dapp.PANCAKECL
+        ? gauge
+        : nonfungiblePositionManagerAddress[this.network][dapp];
     const tx = await getPoolTxOrGasEstimate(
       this,
-      [gauge, stakeTxData, options],
+      [txTo, stakeTxData, options],
       estimateGas
     );
     return tx;
@@ -638,10 +650,18 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
+    let unstakeTxData;
     const rewardsGauge = new ethers.utils.Interface(IBalancerRewardsGauge.abi);
-    const unstakeTxData = rewardsGauge.encodeFunctionData("withdraw(uint256)", [
-      amount
-    ]);
+    if (
+      gauge.toLowerCase() ===
+      stakingAddress[this.network][Dapp.PANCAKECL]?.toLowerCase()
+    ) {
+      unstakeTxData = getPancakeUnStakeTxData(this, amount.toString());
+    } else {
+      unstakeTxData = rewardsGauge.encodeFunctionData("withdraw(uint256)", [
+        amount
+      ]);
+    }
     const tx = await getPoolTxOrGasEstimate(
       this,
       [gauge, unstakeTxData, options],
@@ -1083,7 +1103,12 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityUniswapV3(
-    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
+    dapp:
+      | Dapp.UNISWAPV3
+      | Dapp.VELODROMECL
+      | Dapp.AERODROMECL
+      | Dapp.RAMSESCL
+      | Dapp.PANCAKECL,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -1156,7 +1181,8 @@ export class Pool {
         break;
       case Dapp.VELODROMECL:
       case Dapp.AERODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
+      case Dapp.PANCAKECL:
+        const tokenIdOwner = await getClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         } else {
@@ -1171,8 +1197,14 @@ export class Pool {
       default:
         throw new Error("dapp not supported");
     }
-    if (!isStaked) {
-      txData = await getDecreaseLiquidityTxData(this, dapp, tokenId, amount);
+    if (!isStaked || dapp === Dapp.PANCAKECL) {
+      txData = await getDecreaseLiquidityTxData(
+        this,
+        dapp,
+        tokenId,
+        amount,
+        isStaked
+      );
     } else {
       throw new Error(
         "unsupported decreaseStakedLiquidity: unstake first to decrease lp"
@@ -1214,7 +1246,8 @@ export class Pool {
         break;
       case Dapp.VELODROMECL:
       case Dapp.AERODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
+      case Dapp.PANCAKECL:
+        const tokenIdOwner = await getClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         } else {
@@ -1229,7 +1262,8 @@ export class Pool {
       default:
         throw new Error("dapp not supported");
     }
-    if (!isStaked) {
+    //PancakeCL supports increase liquidity to staked position
+    if (!isStaked || dapp === Dapp.PANCAKECL) {
       txData = await getIncreaseLiquidityTxData(
         this,
         dapp,
@@ -1296,7 +1330,8 @@ export class Pool {
         break;
       case Dapp.VELODROMECL:
       case Dapp.AERODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
+      case Dapp.PANCAKECL:
+        const tokenIdOwner = await getClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           contractAddress =
             nonfungiblePositionManagerAddress[this.network][dapp];
@@ -1305,9 +1340,13 @@ export class Pool {
             [[tokenId, this.address, MaxUint128, MaxUint128]]
           );
         } else {
-          //staked in gauge
+          //staked in gauge or pancake masterchef
           contractAddress = tokenIdOwner;
-          txData = getVelodromeCLClaimTxData(tokenId);
+          if (dapp === Dapp.PANCAKECL) {
+            txData = getPancakeHarvestClaimTxData(this, tokenId);
+          } else {
+            txData = getVelodromeCLClaimTxData(tokenId);
+          }
         }
         break;
       default:

package/src/services/pancake/staking.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ethers } from "ethers";
+import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
+import IPanncakeMasterChef from "../../abi/IPancakeMasterChefV3.json";
+import { Pool } from "../../entities";
+import { Transaction } from "../../types";
+import { MaxUint128 } from "../../config";
+const iNonfungiblePositionManager = new ethers.utils.Interface(
+  INonfungiblePositionManager.abi
+);
+const iMasterChef = new ethers.utils.Interface(IPanncakeMasterChef);
+
+export function getPancakeStakeTxData(
+  pool: Pool,
+  tokenId: string,
+  stakingAddress: string
+): string {
+  return iNonfungiblePositionManager.encodeFunctionData("safeTransferFrom", [
+    pool.address,
+    stakingAddress,
+    tokenId
+  ]);
+}
+
+export function getPancakeUnStakeTxData(pool: Pool, tokenId: string): string {
+  return iMasterChef.encodeFunctionData("withdraw", [tokenId, pool.address]);
+}
+
+export function getPancakeHarvestClaimTxData(
+  pool: Pool,
+  tokenId: string
+): string {
+  const harvestTxData = iMasterChef.encodeFunctionData(Transaction.HARVEST, [
+    tokenId,
+    pool.address
+  ]);
+  const collectTxData = iMasterChef.encodeFunctionData(Transaction.COLLECT, [
+    [tokenId, pool.address, MaxUint128, MaxUint128]
+  ]);
+
+  const multicallParams = [harvestTxData, collectTxData];
+
+  return iMasterChef.encodeFunctionData(Transaction.MULTI_CALL, [
+    multicallParams
+  ]);
+}

package/src/services/uniswap/V3Liquidity.ts

@@ -21,6 +21,7 @@ import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.j
 import IVeldodromePositionManager from "../../abi/IVelodromeNonfungiblePositionManager.json";
 import IRamsesPositionManager from "../../abi/IRamsesNonfungiblePositionManager.json";
 import IArrakisV1RouterStaking from "../../abi/IArrakisV1RouterStaking.json";
+import IPancakeMasterChef from "../../abi/IPancakeMasterChefV3.json";
 import { getDeadline } from "../../utils/deadline";
 import BigNumber from "bignumber.js";
 
@@ -71,7 +72,12 @@ export function tryParseTick(
 }
 
 export async function getUniswapV3MintTxData(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
+  dapp:
+    | Dapp.UNISWAPV3
+    | Dapp.VELODROMECL
+    | Dapp.AERODROMECL
+    | Dapp.RAMSESCL
+    | Dapp.PANCAKECL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -170,7 +176,12 @@ export async function getUniswapV3MintTxData(
 }
 
 export async function getUniswapV3Liquidity(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
+  dapp:
+    | Dapp.UNISWAPV3
+    | Dapp.VELODROMECL
+    | Dapp.AERODROMECL
+    | Dapp.RAMSESCL
+    | Dapp,
   tokenId: string,
   pool: Pool
 ): Promise<BigNumber> {
@@ -196,7 +207,8 @@ export async function getIncreaseLiquidityTxData(
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
     dapp === Dapp.AERODROMECL ||
-    dapp === Dapp.RAMSESCL
+    dapp === Dapp.RAMSESCL ||
+    dapp === Dapp.PANCAKECL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
@@ -224,14 +236,16 @@ export async function getDecreaseLiquidityTxData(
   pool: Pool,
   dapp: Dapp,
   tokenId: string,
-  amount = 100
+  amount = 100,
+  isStaked: boolean
 ): Promise<any> {
   let txData;
   if (
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
     dapp === Dapp.AERODROMECL ||
-    dapp === Dapp.RAMSESCL
+    dapp === Dapp.RAMSESCL ||
+    dapp === Dapp.PANCAKECL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))
@@ -248,6 +262,15 @@ export async function getDecreaseLiquidityTxData(
 
     const multicallParams = [decreaseLiquidityTxData, collectTxData];
 
+    if (isStaked && dapp === Dapp.PANCAKECL) {
+      const abi = new ethers.utils.Interface(IPancakeMasterChef);
+      const harvestTxData = abi.encodeFunctionData(Transaction.HARVEST, [
+        tokenId,
+        pool.address
+      ]);
+      multicallParams.unshift(harvestTxData);
+    }
+
     if (amount === 100) {
       const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
       multicallParams.push(burnTxData);

package/src/services/velodrome/liquidity.ts

@@ -49,9 +49,9 @@ export async function getVelodromeRemoveLiquidityTxData(
   ]);
 }
 
-export async function getVelodromeClOwner(
+export async function getClOwner(
   pool: Pool,
-  dapp: Dapp.VELODROMECL | Dapp.AERODROMECL,
+  dapp: Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.PANCAKECL,
   tokenId: string
 ): Promise<string> {
   const iNonfungiblePositionManager = new ethers.Contract(

package/src/test/pancakeCL.test.ts

@@ -0,0 +1,200 @@
+import { Dhedge, Pool, ethers } from "..";
+
+import { nonfungiblePositionManagerAddress, stakingAddress } from "../config";
+import { AssetEnabled, Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setChainlinkTimeout,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+
+const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const PANCAKE_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.PANCAKECL
+  ]!;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const GAUGE = stakingAddress[network][Dapp.PANCAKECL]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const USDT = CONTRACT_ADDRESS[network].USDT;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let positionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] Pancake CL tests`, () => {
+    beforeAll(async () => {
+      await provider.send("evm_mine", []);
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      // setChainlinkTimeout
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+
+      const newAssets: AssetEnabled[] = [
+        { asset: USDC, isDeposit: true },
+        { asset: USDT, isDeposit: true },
+        {
+          asset: PANCAKE_POSITION_MANGER,
+          isDeposit: false
+        }
+      ];
+      await pool.managerLogic.changeAssets(newAssets, []);
+
+      positionManager = new ethers.Contract(
+        PANCAKE_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    describe("Liquidity", () => {
+      it("approves unlimited USDC and USDT on for Aerodrome CL", async () => {
+        await pool.approveSpender(PANCAKE_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(PANCAKE_POSITION_MANGER, USDT, MAX_AMOUNT);
+        const UsdcAllowanceDelta = await allowanceDelta(
+          pool.address,
+          USDC,
+          PANCAKE_POSITION_MANGER,
+          pool.signer
+        );
+        await expect(UsdcAllowanceDelta.gt(0));
+      });
+
+      it("adds USDC and USDT to a CL (mint position)", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.PANCAKECL,
+          USDC,
+          USDT,
+          usdcBalance.div(2),
+          usdtBalance.div(2),
+          null,
+          null,
+          -73,
+          127,
+          100
+        );
+
+        tokenId = (
+          await positionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        expect(tokenId).not.toBe(null);
+      });
+
+      it("increases liquidity in a CL position", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        const positionBefore = await positionManager.positions(tokenId);
+        await pool.increaseLiquidity(
+          Dapp.PANCAKECL,
+          tokenId,
+          usdcBalance.div(2),
+          usdtBalance.div(2)
+        );
+        const positionAfter = await positionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("decreases liquidity from a CL position", async () => {
+        const positionBefore = await positionManager.positions(tokenId);
+        await pool.decreaseLiquidity(Dapp.PANCAKECL, tokenId, 50);
+        const positionAfter = await positionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("collects fess of a CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.PANCAKECL, tokenId);
+        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+      });
+    });
+    describe("Liquidity staking", () => {
+      it("stakes a CL position in gauge", async () => {
+        await pool.approveSpender(PANCAKE_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(PANCAKE_POSITION_MANGER, USDT, MAX_AMOUNT);
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.PANCAKECL,
+          USDC,
+          USDT,
+          usdcBalance.div(2),
+          usdtBalance.div(2),
+          null,
+          null,
+          -73,
+          127,
+          100
+        );
+
+        tokenId = (
+          await positionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        await pool.stakeInGauge(Dapp.PANCAKECL, GAUGE, tokenId);
+        expect(await positionManager.ownerOf(tokenId)).toBe(GAUGE);
+      });
+
+      it("increases liquidity in a staked CL position", async () => {
+        await pool.approveSpender(GAUGE, USDC, MAX_AMOUNT);
+        await pool.approveSpender(GAUGE, USDT, MAX_AMOUNT);
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        const positionBefore = await positionManager.positions(tokenId);
+        await pool.increaseLiquidity(
+          Dapp.PANCAKECL,
+          tokenId,
+          usdcBalance.div(2),
+          usdtBalance.div(2)
+        );
+        const positionAfter = await positionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("collects fess from a staked CL position", async () => {
+        await pool.claimFees(Dapp.PANCAKECL, tokenId);
+      });
+
+      it("decreases liquidity from a CL position", async () => {
+        const positionBefore = await positionManager.positions(tokenId);
+        await pool.decreaseLiquidity(Dapp.PANCAKECL, tokenId, 50);
+        const positionAfter = await positionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("unstakes a CL position from a gauge", async () => {
+        await pool.unstakeFromGauge(GAUGE, tokenId);
+        expect((await positionManager.ownerOf(tokenId)).toLowerCase()).toBe(
+          pool.address.toLowerCase()
+        );
+      });
+
+      it("remove all liquidity from a staked CL position", async () => {
+        await pool.stakeInGauge(Dapp.PANCAKECL, GAUGE, tokenId);
+        await pool.decreaseLiquidity(Dapp.PANCAKECL, tokenId, 100);
+        expect((await positionManager.balanceOf(pool.address)).eq(0));
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testPancakeCL
+});

package/src/types.ts

@@ -28,6 +28,7 @@ export enum Dapp {
   AERODROME = "aerodrome",
   AERODROMECL = "aerodromeCL",
   RAMSESCL = "ramsesCL",
+  PANCAKECL = "pancakeCL",
   COMPOUNDV3 = "compoundV3"
 }