@strkfarm/sdk 1.0.35 → 1.0.37

package/dist/index.browser.mjs

@@ -12954,13 +12954,30 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
    *   - finalPools: Array of pool information after rebalance
    * @throws Error if rebalance is not possible while maintaining constraints
    */
-  async getRebalancedPositions() {
-    const { data: pools } = await this.getPools();
-    const totalAssets = (await this.getTVL()).amount;
+  async getRebalancedPositions(_pools) {
+    logger.verbose(`VesuRebalance: getRebalancedPositions`);
+    if (!_pools) {
+      const { data: _pools2 } = await this.getPools();
+      _pools = _pools2;
+    }
+    const feeDeductions = await this.getFee(_pools);
+    logger.verbose(`VesuRebalance: feeDeductions: ${JSON.stringify(feeDeductions)}`);
+    const pools = _pools.map((p) => {
+      const fee = feeDeductions.find((f) => p.v_token.eq(f.vToken))?.fee || Web3Number.fromWei("0", this.decimals());
+      logger.verbose(`FeeAdjustment: ${p.pool_id} => ${fee.toString()}, amt: ${p.amount.toString()}`);
+      return {
+        ...p,
+        amount: p.amount.minus(fee)
+      };
+    });
+    let totalAssets = (await this.getTVL()).amount;
     if (totalAssets.eq(0)) return {
       changes: [],
       finalPools: []
     };
+    feeDeductions.forEach((f) => {
+      totalAssets = totalAssets.minus(f.fee);
+    });
     const sumPools = pools.reduce((acc, curr) => acc.plus(curr.amount.toString()), Web3Number.fromWei("0", this.decimals()));
     logger.verbose(`Sum of pools: ${sumPools.toString()}`);
     logger.verbose(`Total assets: ${totalAssets.toString()}`);
@@ -12998,8 +13015,8 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
     const sumChanges = changes.reduce((sum, c) => sum.plus(c.changeAmt.toString()), Web3Number.fromWei("0", this.decimals()));
     const sumFinal = changes.reduce((sum, c) => sum.plus(c.finalAmt.toString()), Web3Number.fromWei("0", this.decimals()));
     const hasChanges = changes.some((c) => !c.changeAmt.eq(0));
-    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
     logger.verbose(`Sum of changes: ${sumChanges.toString()}`);
+    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
     logger.verbose(`Sum of final: ${sumFinal.toString()}`);
     logger.verbose(`Total assets: ${totalAssets.toString()}`);
     if (!sumFinal.eq(totalAssets.toString())) throw new Error("Sum of final amounts must equal total assets");
@@ -13103,6 +13120,49 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
       ])
     ];
   }
+  /**
+   * Calculates the fees deducted in different vTokens based on the current and previous state.
+   * @param previousTotalSupply - The total supply of the strategy token before the transaction
+   * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
+   */
+  async getFee(allowedPools) {
+    const assets = Web3Number.fromWei((await this.contract.total_assets()).toString(), this.asset().decimals);
+    const totalSupply = Web3Number.fromWei((await this.contract.total_supply()).toString(), this.asset().decimals);
+    const prevIndex = Web3Number.fromWei((await this.contract.get_previous_index()).toString(), 18);
+    const currIndex = new Web3Number(1, 18).multipliedBy(assets).dividedBy(totalSupply);
+    logger.verbose(`Previous index: ${prevIndex.toString()}`);
+    logger.verbose(`Assets: ${assets.toString()}`);
+    logger.verbose(`Total supply: ${totalSupply.toString()}`);
+    logger.verbose(`Current index: ${currIndex.toNumber()}`);
+    if (currIndex.lt(prevIndex)) {
+      logger.verbose(`getFee::Current index is less than previous index, no fees to be deducted`);
+      return [];
+    }
+    const indexDiff = currIndex.minus(prevIndex);
+    logger.verbose(`Index diff: ${indexDiff.toString()}`);
+    const numerator = totalSupply.multipliedBy(indexDiff).multipliedBy(this.metadata.additionalInfo.feeBps);
+    const denominator = 1e4;
+    let fee = numerator.dividedBy(denominator);
+    logger.verbose(`Fee: ${fee.toString()}`);
+    if (fee.lte(0)) {
+      return [];
+    }
+    const fees = [];
+    let remainingFee = fee.plus(Web3Number.fromWei("100", this.asset().decimals));
+    for (const pool of allowedPools) {
+      const vToken = pool.v_token;
+      const balance = pool.amount;
+      if (remainingFee.lte(balance)) {
+        fees.push({ vToken, fee: remainingFee });
+        break;
+      } else {
+        fees.push({ vToken, fee: Web3Number.fromWei(balance.toString(), 18) });
+        remainingFee = remainingFee.minus(Web3Number.fromWei(balance.toString(), 18));
+      }
+    }
+    logger.verbose(`Fees: ${JSON.stringify(fees)}`);
+    return fees;
+  }
 };
 var _description = "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.";
 var _protocol = { name: "Vesu", logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png" };

package/dist/index.d.ts

@@ -580,7 +580,7 @@ declare class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAm
      *   - finalPools: Array of pool information after rebalance
      * @throws Error if rebalance is not possible while maintaining constraints
      */
-    getRebalancedPositions(): Promise<{
+    getRebalancedPositions(_pools?: PoolInfoFull[]): Promise<{
         changes: never[];
         finalPools: never[];
         isAnyPoolOverMaxWeight?: undefined;
@@ -597,6 +597,15 @@ declare class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAm
     getRebalanceCall(pools: Awaited<ReturnType<typeof this.getRebalancedPositions>>['changes'], isOverWeightAdjustment: boolean): Promise<starknet.Call | null>;
     getInvestmentFlows(pools: PoolInfoFull[]): Promise<IInvestmentFlow[]>;
     harvest(acc: Account): Promise<starknet.Call[]>;
+    /**
+     * Calculates the fees deducted in different vTokens based on the current and previous state.
+     * @param previousTotalSupply - The total supply of the strategy token before the transaction
+     * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
+     */
+    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
+        vToken: ContractAddr;
+        fee: Web3Number;
+    }>>;
 }
 /**
  * Represents the Vesu Rebalance Strategies.

package/dist/index.js

@@ -13043,13 +13043,30 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
    *   - finalPools: Array of pool information after rebalance
    * @throws Error if rebalance is not possible while maintaining constraints
    */
-  async getRebalancedPositions() {
-    const { data: pools } = await this.getPools();
-    const totalAssets = (await this.getTVL()).amount;
+  async getRebalancedPositions(_pools) {
+    logger.verbose(`VesuRebalance: getRebalancedPositions`);
+    if (!_pools) {
+      const { data: _pools2 } = await this.getPools();
+      _pools = _pools2;
+    }
+    const feeDeductions = await this.getFee(_pools);
+    logger.verbose(`VesuRebalance: feeDeductions: ${JSON.stringify(feeDeductions)}`);
+    const pools = _pools.map((p) => {
+      const fee = feeDeductions.find((f) => p.v_token.eq(f.vToken))?.fee || Web3Number.fromWei("0", this.decimals());
+      logger.verbose(`FeeAdjustment: ${p.pool_id} => ${fee.toString()}, amt: ${p.amount.toString()}`);
+      return {
+        ...p,
+        amount: p.amount.minus(fee)
+      };
+    });
+    let totalAssets = (await this.getTVL()).amount;
     if (totalAssets.eq(0)) return {
       changes: [],
       finalPools: []
     };
+    feeDeductions.forEach((f) => {
+      totalAssets = totalAssets.minus(f.fee);
+    });
     const sumPools = pools.reduce((acc, curr) => acc.plus(curr.amount.toString()), Web3Number.fromWei("0", this.decimals()));
     logger.verbose(`Sum of pools: ${sumPools.toString()}`);
     logger.verbose(`Total assets: ${totalAssets.toString()}`);
@@ -13087,8 +13104,8 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
     const sumChanges = changes.reduce((sum, c) => sum.plus(c.changeAmt.toString()), Web3Number.fromWei("0", this.decimals()));
     const sumFinal = changes.reduce((sum, c) => sum.plus(c.finalAmt.toString()), Web3Number.fromWei("0", this.decimals()));
     const hasChanges = changes.some((c) => !c.changeAmt.eq(0));
-    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
     logger.verbose(`Sum of changes: ${sumChanges.toString()}`);
+    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
     logger.verbose(`Sum of final: ${sumFinal.toString()}`);
     logger.verbose(`Total assets: ${totalAssets.toString()}`);
     if (!sumFinal.eq(totalAssets.toString())) throw new Error("Sum of final amounts must equal total assets");
@@ -13192,6 +13209,49 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
       ])
     ];
   }
+  /**
+   * Calculates the fees deducted in different vTokens based on the current and previous state.
+   * @param previousTotalSupply - The total supply of the strategy token before the transaction
+   * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
+   */
+  async getFee(allowedPools) {
+    const assets = Web3Number.fromWei((await this.contract.total_assets()).toString(), this.asset().decimals);
+    const totalSupply = Web3Number.fromWei((await this.contract.total_supply()).toString(), this.asset().decimals);
+    const prevIndex = Web3Number.fromWei((await this.contract.get_previous_index()).toString(), 18);
+    const currIndex = new Web3Number(1, 18).multipliedBy(assets).dividedBy(totalSupply);
+    logger.verbose(`Previous index: ${prevIndex.toString()}`);
+    logger.verbose(`Assets: ${assets.toString()}`);
+    logger.verbose(`Total supply: ${totalSupply.toString()}`);
+    logger.verbose(`Current index: ${currIndex.toNumber()}`);
+    if (currIndex.lt(prevIndex)) {
+      logger.verbose(`getFee::Current index is less than previous index, no fees to be deducted`);
+      return [];
+    }
+    const indexDiff = currIndex.minus(prevIndex);
+    logger.verbose(`Index diff: ${indexDiff.toString()}`);
+    const numerator = totalSupply.multipliedBy(indexDiff).multipliedBy(this.metadata.additionalInfo.feeBps);
+    const denominator = 1e4;
+    let fee = numerator.dividedBy(denominator);
+    logger.verbose(`Fee: ${fee.toString()}`);
+    if (fee.lte(0)) {
+      return [];
+    }
+    const fees = [];
+    let remainingFee = fee.plus(Web3Number.fromWei("100", this.asset().decimals));
+    for (const pool of allowedPools) {
+      const vToken = pool.v_token;
+      const balance = pool.amount;
+      if (remainingFee.lte(balance)) {
+        fees.push({ vToken, fee: remainingFee });
+        break;
+      } else {
+        fees.push({ vToken, fee: Web3Number.fromWei(balance.toString(), 18) });
+        remainingFee = remainingFee.minus(Web3Number.fromWei(balance.toString(), 18));
+      }
+    }
+    logger.verbose(`Fees: ${JSON.stringify(fees)}`);
+    return fees;
+  }
 };
 var _description = "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.";
 var _protocol = { name: "Vesu", logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png" };

package/dist/index.mjs

@@ -12974,13 +12974,30 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
    *   - finalPools: Array of pool information after rebalance
    * @throws Error if rebalance is not possible while maintaining constraints
    */
-  async getRebalancedPositions() {
-    const { data: pools } = await this.getPools();
-    const totalAssets = (await this.getTVL()).amount;
+  async getRebalancedPositions(_pools) {
+    logger.verbose(`VesuRebalance: getRebalancedPositions`);
+    if (!_pools) {
+      const { data: _pools2 } = await this.getPools();
+      _pools = _pools2;
+    }
+    const feeDeductions = await this.getFee(_pools);
+    logger.verbose(`VesuRebalance: feeDeductions: ${JSON.stringify(feeDeductions)}`);
+    const pools = _pools.map((p) => {
+      const fee = feeDeductions.find((f) => p.v_token.eq(f.vToken))?.fee || Web3Number.fromWei("0", this.decimals());
+      logger.verbose(`FeeAdjustment: ${p.pool_id} => ${fee.toString()}, amt: ${p.amount.toString()}`);
+      return {
+        ...p,
+        amount: p.amount.minus(fee)
+      };
+    });
+    let totalAssets = (await this.getTVL()).amount;
     if (totalAssets.eq(0)) return {
       changes: [],
       finalPools: []
     };
+    feeDeductions.forEach((f) => {
+      totalAssets = totalAssets.minus(f.fee);
+    });
     const sumPools = pools.reduce((acc, curr) => acc.plus(curr.amount.toString()), Web3Number.fromWei("0", this.decimals()));
     logger.verbose(`Sum of pools: ${sumPools.toString()}`);
     logger.verbose(`Total assets: ${totalAssets.toString()}`);
@@ -13018,8 +13035,8 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
     const sumChanges = changes.reduce((sum, c) => sum.plus(c.changeAmt.toString()), Web3Number.fromWei("0", this.decimals()));
     const sumFinal = changes.reduce((sum, c) => sum.plus(c.finalAmt.toString()), Web3Number.fromWei("0", this.decimals()));
     const hasChanges = changes.some((c) => !c.changeAmt.eq(0));
-    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
     logger.verbose(`Sum of changes: ${sumChanges.toString()}`);
+    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
     logger.verbose(`Sum of final: ${sumFinal.toString()}`);
     logger.verbose(`Total assets: ${totalAssets.toString()}`);
     if (!sumFinal.eq(totalAssets.toString())) throw new Error("Sum of final amounts must equal total assets");
@@ -13123,6 +13140,49 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
       ])
     ];
   }
+  /**
+   * Calculates the fees deducted in different vTokens based on the current and previous state.
+   * @param previousTotalSupply - The total supply of the strategy token before the transaction
+   * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
+   */
+  async getFee(allowedPools) {
+    const assets = Web3Number.fromWei((await this.contract.total_assets()).toString(), this.asset().decimals);
+    const totalSupply = Web3Number.fromWei((await this.contract.total_supply()).toString(), this.asset().decimals);
+    const prevIndex = Web3Number.fromWei((await this.contract.get_previous_index()).toString(), 18);
+    const currIndex = new Web3Number(1, 18).multipliedBy(assets).dividedBy(totalSupply);
+    logger.verbose(`Previous index: ${prevIndex.toString()}`);
+    logger.verbose(`Assets: ${assets.toString()}`);
+    logger.verbose(`Total supply: ${totalSupply.toString()}`);
+    logger.verbose(`Current index: ${currIndex.toNumber()}`);
+    if (currIndex.lt(prevIndex)) {
+      logger.verbose(`getFee::Current index is less than previous index, no fees to be deducted`);
+      return [];
+    }
+    const indexDiff = currIndex.minus(prevIndex);
+    logger.verbose(`Index diff: ${indexDiff.toString()}`);
+    const numerator = totalSupply.multipliedBy(indexDiff).multipliedBy(this.metadata.additionalInfo.feeBps);
+    const denominator = 1e4;
+    let fee = numerator.dividedBy(denominator);
+    logger.verbose(`Fee: ${fee.toString()}`);
+    if (fee.lte(0)) {
+      return [];
+    }
+    const fees = [];
+    let remainingFee = fee.plus(Web3Number.fromWei("100", this.asset().decimals));
+    for (const pool of allowedPools) {
+      const vToken = pool.v_token;
+      const balance = pool.amount;
+      if (remainingFee.lte(balance)) {
+        fees.push({ vToken, fee: remainingFee });
+        break;
+      } else {
+        fees.push({ vToken, fee: Web3Number.fromWei(balance.toString(), 18) });
+        remainingFee = remainingFee.minus(Web3Number.fromWei(balance.toString(), 18));
+      }
+    }
+    logger.verbose(`Fees: ${JSON.stringify(fees)}`);
+    return fees;
+  }
 };
 var _description = "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.";
 var _protocol = { name: "Vesu", logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",
@@ -65,7 +65,6 @@
     "inquirer": "^10.1.2",
     "node-telegram-bot-api": "^0.66.0",
     "proxy-from-env": "^1.1.0",
-    "puppeteer": "^24.4.0",
     "redis": "^4.7.0",
     "stacktrace-js": "^2.0.2",
     "starknet": "^6.11.0",

package/src/strategies/vesu-rebalance.tsx

@@ -393,13 +393,34 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
      *   - finalPools: Array of pool information after rebalance
      * @throws Error if rebalance is not possible while maintaining constraints
      */
-    async getRebalancedPositions() {
-        const { data: pools } = await this.getPools();
-        const totalAssets = (await this.getTVL()).amount;
+    async getRebalancedPositions(_pools?: PoolInfoFull[]) {
+        logger.verbose(`VesuRebalance: getRebalancedPositions`);
+        if (!_pools) {
+            const { data: _pools2 } = await this.getPools();
+            _pools = _pools2;
+        }
+        const feeDeductions = await this.getFee(_pools);
+        logger.verbose(`VesuRebalance: feeDeductions: ${JSON.stringify(feeDeductions)}`);
+
+        // remove fee from pools
+        const pools = _pools.map((p) => {
+            const fee = feeDeductions.find((f) => p.v_token.eq(f.vToken))?.fee || Web3Number.fromWei("0", this.decimals());
+            logger.verbose(`FeeAdjustment: ${p.pool_id} => ${fee.toString()}, amt: ${p.amount.toString()}`);
+            return {
+                ...p,
+                amount: p.amount.minus(fee),
+            }
+        });
+        let totalAssets = (await this.getTVL()).amount;
         if (totalAssets.eq(0)) return {
             changes: [],
             finalPools: [],
         }
+        // deduct fee from total assets
+        feeDeductions.forEach((f) => {
+            totalAssets = totalAssets.minus(f.fee);
+        });
+
 
         // assert sum of pools.amount <= totalAssets
         const sumPools = pools.reduce((acc, curr) => acc.plus(curr.amount.toString()), Web3Number.fromWei("0", this.decimals()));
@@ -449,8 +470,8 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
         const sumFinal = changes.reduce((sum, c) => sum.plus(c.finalAmt.toString()), Web3Number.fromWei("0", this.decimals()));
         const hasChanges = changes.some(c => !c.changeAmt.eq(0));
 
-        if (!sumChanges.eq(0)) throw new Error('Sum of changes must be zero');
         logger.verbose(`Sum of changes: ${sumChanges.toString()}`);
+        if (!sumChanges.eq(0)) throw new Error('Sum of changes must be zero');
         logger.verbose(`Sum of final: ${sumFinal.toString()}`);
         logger.verbose(`Total assets: ${totalAssets.toString()}`);
         if (!sumFinal.eq(totalAssets.toString())) throw new Error('Sum of final amounts must equal total assets');
@@ -565,6 +586,59 @@ export class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmo
             ])
         ]
     }
+
+    /**
+     * Calculates the fees deducted in different vTokens based on the current and previous state.
+     * @param previousTotalSupply - The total supply of the strategy token before the transaction
+     * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
+     */
+    async getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>> {
+        const assets = Web3Number.fromWei((await this.contract.total_assets()).toString(), this.asset().decimals);
+        const totalSupply = Web3Number.fromWei((await this.contract.total_supply()).toString(), this.asset().decimals);
+        const prevIndex = Web3Number.fromWei((await this.contract.get_previous_index()).toString(), 18);
+        const currIndex = (new Web3Number(1, 18)).multipliedBy(assets).dividedBy(totalSupply);
+
+        logger.verbose(`Previous index: ${prevIndex.toString()}`);
+        logger.verbose(`Assets: ${assets.toString()}`);
+        logger.verbose(`Total supply: ${totalSupply.toString()}`);
+        logger.verbose(`Current index: ${currIndex.toNumber()}`);
+
+        if (currIndex.lt(prevIndex)) {
+            logger.verbose(`getFee::Current index is less than previous index, no fees to be deducted`);
+            return [];
+        }
+
+        const indexDiff = currIndex.minus(prevIndex);
+        logger.verbose(`Index diff: ${indexDiff.toString()}`);
+        const numerator = totalSupply.multipliedBy(indexDiff).multipliedBy(this.metadata.additionalInfo.feeBps);
+        const denominator = 10000;
+        let fee = numerator.dividedBy(denominator);
+        logger.verbose(`Fee: ${fee.toString()}`);
+
+        if (fee.lte(0)) {
+            return [];
+        }
+
+        const fees: Array<{ vToken: ContractAddr, fee: Web3Number }> = [];
+        let remainingFee = fee.plus(Web3Number.fromWei("100", this.asset().decimals));
+
+        for (const pool of allowedPools) {
+            const vToken = pool.v_token;
+            const balance = pool.amount;
+
+            if (remainingFee.lte(balance)) {
+                fees.push({ vToken, fee: remainingFee });
+                break;
+            } else {
+                fees.push({ vToken, fee: Web3Number.fromWei(balance.toString(), 18) });
+                remainingFee = remainingFee.minus(Web3Number.fromWei(balance.toString(), 18));
+            }
+        }
+
+        logger.verbose(`Fees: ${JSON.stringify(fees)}`);
+
+        return fees;
+    }
 }
 
 const _description = "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well."

package/src/node/headless.node.ts

@@ -1,36 +0,0 @@
-const puppeteer = require('puppeteer');
-
-export async function getAPIUsingHeadlessBrowser(
-    url: string
-) {
-
-  try {
-    // Launch a headless browser
-    const browser = await puppeteer.launch({ headless: true });
-    const page = await browser.newPage();
-
-    // Set a realistic User-Agent to avoid suspicion
-    await page.setUserAgent(
-      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-    );
-
-    // Go to the API endpoint
-    await page.goto(url, {
-      waitUntil: 'networkidle2', // Wait until the page fully loads (including JS challenge)
-    });
-
-    // If the API returns JSON, extract it
-    const jsonData = await page.evaluate(() => {
-      const pre = document.querySelector('pre'); // Adjust based on how the API response is formatted
-      return pre && pre.textContent ? JSON.parse(pre.textContent) : null;
-    });
-
-    // Clean up
-    await browser.close();
-    return jsonData;
-  } catch (error) {
-    console.error('Error:', error);
-    return null;
-  }
-}
-