Feature/add use voucher to processprotecteddata (#421)

Author: SeddikBellamine

packages/sdk/package-lock.json

@@ -60,7 +60,7 @@
     "debug": "^4.3.4",
     "ethers": "^6.13.2",
     "graphql-request": "^6.0.0",
-    "iexec": "^8.13.1",
+    "iexec": "^8.14.0",
     "jszip": "^3.7.1",
     "kubo-rpc-client": "^4.1.1",
     "magic-bytes.js": "^1.0.15",

packages/sdk/package.json

@@ -14,6 +14,7 @@ import { pushRequesterSecret } from '../../utils/pushRequesterSecret.js';
 import {
   addressOrEnsSchema,
   addressSchema,
+  booleanSchema,
   positiveNumberSchema,
   secretsSchema,
   stringSchema,
@@ -24,6 +25,7 @@ import {
 import { isERC734 } from '../../utils/whitelist.js';
 import { getResultFromCompletedTask } from './getResultFromCompletedTask.js';
 import {
+  MatchOptions,
   OnStatusUpdateFn,
   ProcessProtectedDataParams,
   ProcessProtectedDataResponse,
@@ -32,6 +34,10 @@ import {
 import { IExecConsumer } from '../types/internalTypes.js';
 import { getWhitelistContract } from './smartContract/getWhitelistContract.js';
 import { isAddressInWhitelist } from './smartContract/whitelistContract.read.js';
+import {
+  checkUserVoucher,
+  filterWorkerpoolOrders,
+} from '../../utils/processProtectedData.models.js';
 
 export type ProcessProtectedData = typeof processProtectedData;
 
@@ -46,6 +52,8 @@ export const processProtectedData = async ({
   inputFiles,
   secrets,
   workerpool,
+  useVoucher = false,
+  voucherAddress,
   onStatusUpdate = () => {},
 }: IExecConsumer &
   ProcessProtectedDataParams): Promise<ProcessProtectedDataResponse> => {
@@ -73,7 +81,12 @@ export const processProtectedData = async ({
     .default(WORKERPOOL_ADDRESS) // Default workerpool if none is specified
     .label('workerpool')
     .validateSync(workerpool);
-
+  const vUseVoucher = booleanSchema()
+    .label('useVoucher')
+    .validateSync(useVoucher);
+  const vVoucherAddress = addressOrEnsSchema()
+    .label('voucherAddress')
+    .validateSync(voucherAddress);
   try {
     const vOnStatusUpdate =
       validateOnStatusUpdateCallback<
@@ -106,6 +119,20 @@ export const processProtectedData = async ({
         requester = vUserWhitelist;
       }
     }
+    let userVoucher;
+    if (vUseVoucher) {
+      try {
+        userVoucher = await iexec.voucher.showUserVoucher(requester);
+        checkUserVoucher({ userVoucher });
+      } catch (err) {
+        if (err?.message?.startsWith('No Voucher found for address')) {
+          throw new Error(
+            'Oops, it seems your wallet is not associated with any voucher. Check on https://builder.iex.ec/'
+          );
+        }
+        throw err;
+      }
+    }
 
     vOnStatusUpdate({
       title: 'FETCH_PROTECTED_DATA_ORDERBOOK',
@@ -148,18 +175,28 @@ export const processProtectedData = async ({
       workerpool: vWorkerpool === ethers.ZeroAddress ? 'any' : vWorkerpool, // if address zero was chosen use any workerpool
       app: vApp,
       dataset: vProtectedData,
+      requester: requester, // public orders + user specific orders
+      isRequesterStrict: useVoucher, // If voucher, we only want user specific orders
       minTag: SCONE_TAG,
       maxTag: SCONE_TAG,
+      category: 0,
     });
     vOnStatusUpdate({
       title: 'FETCH_WORKERPOOL_ORDERBOOK',
       isDone: true,
     });
+    const desiredPriceWorkerpoolOrder = filterWorkerpoolOrders({
+      workerpoolOrders: [...workerpoolOrderbook.orders],
+      useVoucher: vUseVoucher,
+      userVoucher,
+    });
+    if (!desiredPriceWorkerpoolOrder) {
+      throw new Error('No Workerpool order found.');
+    }
 
     const underMaxPriceOrders = fetchOrdersUnderMaxPrice(
       datasetOrderbook,
       appOrderbook,
-      workerpoolOrderbook,
       vMaxPrice
     );
 
@@ -179,24 +216,32 @@ export const processProtectedData = async ({
     });
     const requestorderToSign = await iexec.order.createRequestorder({
       app: vApp,
-      category: underMaxPriceOrders.workerpoolorder.category,
+      category: desiredPriceWorkerpoolOrder.category,
       dataset: vProtectedData,
       appmaxprice: underMaxPriceOrders.apporder.appprice,
       datasetmaxprice: underMaxPriceOrders.datasetorder.datasetprice,
-      workerpoolmaxprice: underMaxPriceOrders.workerpoolorder.workerpoolprice,
+      workerpoolmaxprice: desiredPriceWorkerpoolOrder.workerpoolprice,
       tag: SCONE_TAG,
-      workerpool: underMaxPriceOrders.workerpoolorder.workerpool,
+      workerpool: desiredPriceWorkerpoolOrder.workerpool,
       params: {
         iexec_input_files: vInputFiles,
         iexec_secrets: secretsId,
         iexec_args: vArgs,
       },
     });
     const requestorder = await iexec.order.signRequestorder(requestorderToSign);
-    const { dealid, txHash } = await iexec.order.matchOrders({
-      requestorder,
-      ...underMaxPriceOrders,
-    });
+    const matchOptions: MatchOptions = {
+      useVoucher: vUseVoucher,
+      ...(vVoucherAddress ? { voucherAddress: vVoucherAddress } : {}),
+    };
+    const { dealid, txHash } = await iexec.order.matchOrders(
+      {
+        requestorder,
+        workerpoolorder: desiredPriceWorkerpoolOrder,
+        ...underMaxPriceOrders,
+      },
+      matchOptions
+    );
     const taskId = await iexec.deal.computeTaskId(dealid, 0);
 
     vOnStatusUpdate({

packages/sdk/src/lib/dataProtectorCore/processProtectedData.ts

@@ -117,3 +117,8 @@ export interface SearchableDataSchema
     | SearchableSchemaEntryType
     | SearchableSchemaEntryType[]
   > {}
+
+export type MatchOptions = {
+  useVoucher: boolean;
+  voucherAddress?: string;
+};

packages/sdk/src/lib/types/commonTypes.ts

@@ -334,6 +334,16 @@ export type ProcessProtectedDataParams = {
    */
   workerpool?: AddressOrENS;
 
+  /**
+   * A boolean that indicates whether to use a voucher or no.
+   */
+  useVoucher?: boolean;
+
+  /**
+   * Override the voucher contract to use, must be combined with useVoucher: true the user must be authorized by the voucher's owner to use it.
+   */
+  voucherAddress?: AddressOrENS;
+
   /**
    * Callback function that will get called at each step of the process
    */

packages/sdk/src/lib/types/coreTypes.ts

@@ -2,14 +2,12 @@ import {
   PaginableOrders,
   PublishedApporder,
   PublishedDatasetorder,
-  PublishedWorkerpoolorder,
 } from 'iexec/IExecOrderbookModule';
 import { DEFAULT_MAX_PRICE } from '../config/config.js';
 
 export const fetchOrdersUnderMaxPrice = (
   datasetOrderbook: PaginableOrders<PublishedDatasetorder>,
   appOrderbook: PaginableOrders<PublishedApporder>,
-  workerpoolOrderbook: PaginableOrders<PublishedWorkerpoolorder>,
   vMaxPrice = DEFAULT_MAX_PRICE
 ) => {
   const datasetorder = datasetOrderbook.orders[0]?.order;
@@ -20,21 +18,13 @@ export const fetchOrdersUnderMaxPrice = (
   if (!apporder) {
     throw new Error(`No app orders found`);
   }
-  const workerpoolorder = workerpoolOrderbook.orders[0]?.order;
-  if (!workerpoolorder) {
-    throw new Error(`No workerpool orders found`);
-  }
 
-  const totalPrice =
-    datasetorder.datasetprice +
-    apporder.appprice +
-    workerpoolorder.workerpoolprice;
+  const totalPrice = datasetorder.datasetprice + apporder.appprice;
 
   if (totalPrice <= vMaxPrice) {
     return {
       datasetorder,
       apporder,
-      workerpoolorder,
     };
   }
 

packages/sdk/src/utils/fetchOrdersUnderMaxPrice.ts

@@ -0,0 +1,85 @@
+import { Address, BN } from 'iexec';
+import { PublishedWorkerpoolorder } from 'iexec/IExecOrderbookModule';
+
+type VoucherInfo = {
+  owner: Address;
+  address: Address;
+  type: BN;
+  balance: BN;
+  expirationTimestamp: BN;
+  sponsoredApps: Address[];
+  sponsoredDatasets: Address[];
+  sponsoredWorkerpools: Address[];
+  allowanceAmount: BN;
+  authorizedAccounts: Address[];
+};
+
+function bnToNumber(bn: BN) {
+  return Number(bn.toString());
+}
+
+export function checkUserVoucher({
+  userVoucher,
+}: {
+  userVoucher: VoucherInfo;
+}) {
+  if (bnToNumber(userVoucher.expirationTimestamp) < Date.now() / 1000) {
+    throw new Error(
+      'Oops, it seems your voucher has expired. You might want to ask for a top up. Check on https://builder.iex.ec/'
+    );
+  }
+
+  if (bnToNumber(userVoucher.balance) === 0) {
+    throw new Error(
+      'Oops, it seems your voucher is empty. You might want to ask for a top up. Check on https://builder.iex.ec/'
+    );
+  }
+}
+
+export function filterWorkerpoolOrders({
+  workerpoolOrders,
+  useVoucher,
+  userVoucher,
+}: {
+  workerpoolOrders: PublishedWorkerpoolorder[];
+  useVoucher: boolean;
+  userVoucher?: VoucherInfo;
+}) {
+  if (workerpoolOrders.length === 0) {
+    return null;
+  }
+
+  let eligibleWorkerpoolOrders = [...workerpoolOrders];
+  let maxVoucherSponsoredAmount = 0; // may be safer to use bigint
+
+  if (useVoucher) {
+    if (!userVoucher) {
+      throw new Error(
+        'useVoucher === true but userVoucher is undefined? Hum...'
+      );
+    }
+    // only voucher sponsored workerpoolorders
+    eligibleWorkerpoolOrders = eligibleWorkerpoolOrders.filter(({ order }) =>
+      userVoucher.sponsoredWorkerpools.includes(order.workerpool)
+    );
+    if (eligibleWorkerpoolOrders.length === 0) {
+      throw new Error(
+        '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 > maxVoucherSponsoredAmount
+  ) {
+    return null;
+  }
+  return cheapestOrder.order;
+}

packages/sdk/src/utils/processProtectedData.models.ts

@@ -180,11 +180,37 @@ export const EMPTY_ORDER_BOOK: any = {
 };
 
 export function resolveWithNoOrder() {
-  return jest
-    .fn<() => Promise<{ orders: []; count: 0 }>>()
-    .mockResolvedValue(EMPTY_ORDER_BOOK);
+  return EMPTY_ORDER_BOOK;
 }
 
+export const mockWorkerpoolOrderbook = {
+  orders: [
+    {
+      order: {
+        workerpool: '0x0e7Bc972c99187c191A17f3CaE4A2711a4188c3F',
+        workerpoolprice: 263157894,
+        volume: 1000,
+        tag: '0x0000000000000000000000000000000000000000000000000000000000000003',
+        category: 0,
+        trust: 0,
+        apprestrict: '0x0000000000000000000000000000000000000000',
+        datasetrestrict: '0x0000000000000000000000000000000000000000',
+        requesterrestrict: '0xa1C2e8D384520c5D85Ab288598dC53a06db7dB5d',
+        salt: '0xa6df3aca62cce93b407a5fe2b683e4fc4a5ff36d3e99731e642ad21f9b77e774',
+        sign: '0xe2d0b978101b54e0bdce2fe08d44543114a01f994eff0f1ec8ec6ff4f0c5ccbf217271cde8b6d73019bec4486d1914a7087253f4bd3e583f1b60bab66f75de1a1c',
+      },
+      orderHash:
+        '0x4dacfe7ed8883f9d3034d3367c7e6d8f5bc2f9434a58b2a60d480948e216f6d8',
+      chainId: 134,
+      publicationTimestamp: '2025-02-25T15:10:16.612Z',
+      signer: '0x0c2e2F5c360cB58dC9A4813fA29656b56b546BF3',
+      status: 'open',
+      remaining: 828,
+    },
+  ],
+  count: 1,
+};
+
 export function observableMockComplete() {
   const mockObservable: any = {
     subscribe: jest.fn(({ complete }) => {

packages/sdk/tests/test-utils.ts

@@ -255,7 +255,9 @@ describe('dataProtectorCore.grantAccess()', () => {
       const authorizedAppAddress = getRandomAddress();
       const iexec = {
         orderbook: {
-          fetchDatasetOrderbook: resolveWithNoOrder(), // Say that access does not yet exist
+          fetchDatasetOrderbook: jest
+            .fn<() => Promise<{ orders: []; count: 0 }>>()
+            .mockResolvedValue(resolveWithNoOrder()), // Say that access does not yet exist
         },
         app: {
           checkDeployedApp: jest.fn().mockReturnValue(true),