use promise.all to accelerate orders retrieval and add dataMaxPrice & appMaxPrice & workerpoolMaxPrice as parameters

SeddikBellamine · SeddikBellamine · commit b5f3d16a29b8 · 2025-04-14T02:44:45.000+02:00
diff --git a/packages/sdk/src/lib/dataProtectorCore/processProtectedData.ts b/packages/sdk/src/lib/dataProtectorCore/processProtectedData.ts
@@ -1,6 +1,7 @@
-import { ethers } from 'ethers';
 import {
-  DEFAULT_MAX_PRICE,
+  MAX_DESIRED_APP_ORDER_PRICE,
+  MAX_DESIRED_DATA_ORDER_PRICE,
+  MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
   SCONE_TAG,
   WORKERPOOL_ADDRESS,
 } from '../../config/config.js';
@@ -11,7 +12,7 @@ import {
 } from '../../utils/errors.js';
 import {
   checkUserVoucher,
-  findWorkerpoolOrders,
+  filterWorkerpoolOrders,
 } from '../../utils/processProtectedData.models.js';
 import { pushRequesterSecret } from '../../utils/pushRequesterSecret.js';
 import {
@@ -45,7 +46,9 @@ export const processProtectedData = async ({
   protectedData,
   app,
   userWhitelist,
-  maxPrice = DEFAULT_MAX_PRICE,
+  dataMaxPrice = MAX_DESIRED_DATA_ORDER_PRICE,
+  appMaxPrice = MAX_DESIRED_APP_ORDER_PRICE,
+  workerpoolMaxPrice = MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
   path,
   args,
   inputFiles,
@@ -67,9 +70,15 @@ export const processProtectedData = async ({
   const vUserWhitelist = addressSchema()
     .label('userWhitelist')
     .validateSync(userWhitelist);
-  const vMaxPrice = positiveNumberSchema()
-    .label('maxPrice')
-    .validateSync(maxPrice);
+  const vDataMaxPrice = positiveNumberSchema()
+    .label('dataMaxPrice')
+    .validateSync(dataMaxPrice);
+  const vAppMaxPrice = positiveNumberSchema()
+    .label('appMaxPrice')
+    .validateSync(appMaxPrice);
+  const vWorkerpoolMaxPrice = positiveNumberSchema()
+    .label('workerpoolMaxPrice')
+    .validateSync(workerpoolMaxPrice);
   const vPath = stringSchema().label('path').validateSync(path);
   const vInputFiles = urlArraySchema()
     .label('inputFiles')
@@ -136,76 +145,111 @@ export const processProtectedData = async ({
     }
 
     vOnStatusUpdate({
-      title: 'FETCH_PROTECTED_DATA_ORDERBOOK',
+      title: 'FETCH_ORDERS',
       isDone: false,
     });
-    const datasetOrderbook = await iexec.orderbook.fetchDatasetOrderbook(
-      vProtectedData,
-      {
-        app: vApp,
-        workerpool: vWorkerpool,
-        requester,
-      }
-    );
-    const datasetorder = datasetOrderbook.orders[0]?.order; //The first order is the cheapest one
-    if (!datasetorder) {
-      throw new Error(`No dataset orders found`);
-    }
-    vOnStatusUpdate({
-      title: 'FETCH_PROTECTED_DATA_ORDERBOOK',
-      isDone: true,
-    });
+    const [
+      datasetorderForApp,
+      datasetorderForWhitelist,
+      apporder,
+      workerpoolorder,
+    ] = await Promise.all([
+      // Fetch dataset order
+      iexec.orderbook
+        .fetchDatasetOrderbook(vProtectedData, {
+          app: vApp,
+          requester: requester,
+        })
+        .then((datasetOrderbook) => {
+          const desiredPriceDataOrderbook = datasetOrderbook.orders.filter(
+            (order) => order.order.datasetprice <= vDataMaxPrice
+          );
+          return desiredPriceDataOrderbook[0]?.order; // may be undefined
+        }),
+      // Fetch dataset order for whitelist
+      iexec.orderbook
+        .fetchDatasetOrderbook(vProtectedData, {
+          app: vUserWhitelist,
+          requester: requester,
+        })
+        .then((datasetOrderbook) => {
+          const desiredPriceDataOrderbook = datasetOrderbook.orders.filter(
+            (order) => order.order.datasetprice <= vDataMaxPrice
+          );
+          return desiredPriceDataOrderbook[0]?.order; // may be undefined
+        }),
+      // Fetch app order
+      iexec.orderbook
+        .fetchAppOrderbook(vApp, {
+          minTag: ['tee', 'scone'],
+          maxTag: ['tee', 'scone'],
+          workerpool: vWorkerpool,
+        })
+        .then((appOrderbook) => {
+          const desiredPriceAppOrderbook = appOrderbook.orders.filter(
+            (order) => order.order.appprice <= vAppMaxPrice
+          );
+          const desiredPriceAppOrder = desiredPriceAppOrderbook[0]?.order;
+          if (!desiredPriceAppOrder) {
+            throw new Error('No App order found for the desired price');
+          }
+          return desiredPriceAppOrder;
+        }),
+      // Fetch workerpool order for App or AppWhitelist
+      Promise.all([
+        // for app
+        iexec.orderbook.fetchWorkerpoolOrderbook({
+          workerpool: vWorkerpool,
+          app: vApp,
+          dataset: vProtectedData,
+          requester: requester, // public orders + user specific orders
+          isRequesterStrict: useVoucher, // If voucher, we only want user specific orders
+          minTag: ['tee', 'scone'],
+          maxTag: ['tee', 'scone'],
+          category: 0,
+        }),
+        // for app whitelist
+        iexec.orderbook.fetchWorkerpoolOrderbook({
+          workerpool: vWorkerpool,
+          app: vUserWhitelist,
+          dataset: vProtectedData,
+          requester: requester, // public orders + user specific orders
+          isRequesterStrict: useVoucher, // If voucher, we only want user specific orders
+          minTag: ['tee', 'scone'],
+          maxTag: ['tee', 'scone'],
+          category: 0,
+        }),
+      ]).then(
+        ([workerpoolOrderbookForApp, workerpoolOrderbookForAppWhitelist]) => {
+          const desiredPriceWorkerpoolOrder = filterWorkerpoolOrders({
+            workerpoolOrders: [
+              ...workerpoolOrderbookForApp.orders,
+              ...workerpoolOrderbookForAppWhitelist.orders,
+            ],
+            workerpoolMaxPrice: vWorkerpoolMaxPrice,
+            useVoucher: vUseVoucher,
+            userVoucher,
+          });
+          if (!desiredPriceWorkerpoolOrder) {
+            throw new Error('No Workerpool order found for the desired price');
+          }
+          return desiredPriceWorkerpoolOrder;
+        }
+      ),
+    ]);
 
-    vOnStatusUpdate({
-      title: 'FETCH_APP_ORDERBOOK',
-      isDone: false,
-    });
-    const appOrderbook = await iexec.orderbook.fetchAppOrderbook(vApp, {
-      dataset: protectedData,
-      requester,
-      minTag: SCONE_TAG,
-      maxTag: SCONE_TAG,
-      workerpool: vWorkerpool,
-    });
-    const apporder = appOrderbook.orders[0]?.order; //The first order is the cheapest one
-    if (!apporder) {
-      throw new Error(`No app orders found`);
+    if (!workerpoolorder) {
+      throw new Error('No Workerpool order found for the desired price');
     }
-    vOnStatusUpdate({
-      title: 'FETCH_APP_ORDERBOOK',
-      isDone: true,
-    });
 
-    vOnStatusUpdate({
-      title: 'FETCH_WORKERPOOL_ORDERBOOK',
-      isDone: false,
-    });
-    const workerpoolOrderbook = await iexec.orderbook.fetchWorkerpoolOrderbook({
-      workerpool: vWorkerpool === ethers.ZeroAddress ? 'any' : vWorkerpool, // if address zero was chosen use any workerpool
-      app: vApp,
-      dataset: vProtectedData,
-      requester: requester,
-      isRequesterStrict:
-        vVoucherOwner && vVoucherOwner.toLowerCase() !== requester.toLowerCase()
-          ? false
-          : useVoucher,
-      minTag: SCONE_TAG,
-      maxTag: SCONE_TAG,
-      category: 0,
-    });
-    const workerpoolOrder = findWorkerpoolOrders({
-      workerpoolOrders: [...workerpoolOrderbook.orders],
-      useVoucher: vUseVoucher,
-      userVoucher,
-    });
-    if (!workerpoolOrder) {
-      throw new Error('No Workerpool order found.');
+    const datasetorder = datasetorderForApp || datasetorderForWhitelist;
+    if (!datasetorder) {
+      throw new Error('No Dataset order found for the desired price');
     }
     vOnStatusUpdate({
-      title: 'FETCH_WORKERPOOL_ORDERBOOK',
+      title: 'FETCH_ORDERS',
       isDone: true,
     });
-
     vOnStatusUpdate({
       title: 'PUSH_REQUESTER_SECRET',
       isDone: false,
@@ -222,13 +266,13 @@ export const processProtectedData = async ({
     });
     const requestorderToSign = await iexec.order.createRequestorder({
       app: vApp,
-      category: workerpoolOrder.category,
+      category: workerpoolorder.category,
       dataset: vProtectedData,
       appmaxprice: apporder.appprice,
       datasetmaxprice: datasetorder.datasetprice,
-      workerpoolmaxprice: workerpoolOrder.workerpoolprice,
+      workerpoolmaxprice: workerpoolorder.workerpoolprice,
       tag: SCONE_TAG,
-      workerpool: workerpoolOrder.workerpool,
+      workerpool: workerpoolorder.workerpool,
       params: {
         iexec_input_files: vInputFiles,
         iexec_secrets: secretsId,
@@ -239,7 +283,7 @@ export const processProtectedData = async ({
 
     const orders = {
       requestorder,
-      workerpoolorder: workerpoolOrder,
+      workerpoolorder: workerpoolorder,
       apporder: apporder,
       datasetorder: datasetorder,
     };
@@ -248,20 +292,6 @@ export const processProtectedData = async ({
       ...(vVoucherOwner ? { voucherAddress: userVoucher?.address } : {}),
     };
 
-    const estimatedMatchOrderPrice = await iexec.order.estimateMatchOrders(
-      orders,
-      matchOptions
-    );
-    if (
-      estimatedMatchOrderPrice.total
-        .sub(estimatedMatchOrderPrice.sponsored)
-        .ltn(vMaxPrice)
-    ) {
-      throw new Error(
-        `No orders found within the specified price limit ${vMaxPrice} nRLC.`
-      );
-    }
-
     const { dealid, txHash } = await iexec.order.matchOrders(
       orders,
       matchOptions
diff --git a/packages/sdk/src/lib/types/coreTypes.ts b/packages/sdk/src/lib/types/coreTypes.ts
@@ -276,6 +276,7 @@ export type TransferResponse = {
 
 // ---------------------ProcessProtectedData Types------------------------------------
 export type ProcessProtectedDataStatuses =
+  | 'FETCH_ORDERS'
   | 'FETCH_PROTECTED_DATA_ORDERBOOK'
   | 'FETCH_APP_ORDERBOOK'
   | 'FETCH_WORKERPOOL_ORDERBOOK'
@@ -302,11 +303,22 @@ export type ProcessProtectedDataParams = {
   userWhitelist?: Address;
 
   /**
-   * The maximum price per task for processing the protected data.
-   * It is the sum of the application price, dataset price and workerpool price per task.
+   * The maximum price of dataset per task for processing the protected data.
   @default = 0
   */
-  maxPrice?: number;
+  dataMaxPrice?: number;
+
+  /**
+   * The maximum price of application per task for processing the protected data.
+  @default = 0
+  */
+  appMaxPrice?: number;
+
+  /**
+   * The maximum price of workerpool per task for processing the protected data.
+  @default = 0
+  */
+  workerpoolMaxPrice?: number;
 
   /**
    * The file name of the desired file in the returned ZIP file.
diff --git a/packages/sdk/src/utils/processProtectedData.models.ts b/packages/sdk/src/utils/processProtectedData.models.ts
@@ -24,12 +24,14 @@ export function checkUserVoucher({
   }
 }
 
-export function findWorkerpoolOrders({
+export function filterWorkerpoolOrders({
   workerpoolOrders,
+  workerpoolMaxPrice,
   useVoucher,
   userVoucher,
 }: {
   workerpoolOrders: PublishedWorkerpoolorder[];
+  workerpoolMaxPrice: number;
   useVoucher: boolean;
   userVoucher?: VoucherInfo;
 }) {
@@ -38,6 +40,8 @@ export function findWorkerpoolOrders({
   }
 
   let eligibleWorkerpoolOrders = workerpoolOrders;
+  let maxVoucherSponsoredAmount = 0; // may be safer to use bigint
+
   if (useVoucher) {
     if (!userVoucher) {
       throw new Error(
@@ -53,11 +57,20 @@ export function findWorkerpoolOrders({
         'Found some workerpool orders but none can be sponsored by your voucher.'
       );
     }
+    maxVoucherSponsoredAmount = bnToNumber(userVoucher.balance);
   }
 
   const [cheapestOrder] = eligibleWorkerpoolOrders.sort(
     (order1, order2) =>
       order1.order.workerpoolprice - order2.order.workerpoolprice
   );
+
+  if (
+    !cheapestOrder ||
+    cheapestOrder.order.workerpoolprice >
+      workerpoolMaxPrice + maxVoucherSponsoredAmount
+  ) {
+    return null;
+  }
   return cheapestOrder.order;
 }
