@iexec/web3mail 1.5.0 → 1.6.0-nightly-8729cd2

package/src/web3mail/fetchUserContacts.ts

@@ -12,7 +12,7 @@ import {
   isEnsTest,
   throwIfMissing,
 } from '../utils/validators.js';
-import { Contact, FetchUserContactsParams } from './types.js';
+import { Contact, FetchUserContactsParams, GrantedAccess } from './types.js';
 import {
   DappAddressConsumer,
   DappWhitelistAddressConsumer,
@@ -27,6 +27,7 @@ export const fetchUserContacts = async ({
   dappWhitelistAddress = throwIfMissing(),
   userAddress,
   isUserStrict = false,
+  bulkOnly = false,
 }: IExecConsumer &
   SubgraphConsumer &
   DappAddressConsumer &
@@ -47,6 +48,7 @@ export const fetchUserContacts = async ({
   const vIsUserStrict = booleanSchema()
     .label('isUserStrict')
     .validateSync(isUserStrict);
+  const vBulkOnly = booleanSchema().label('bulkOnly').validateSync(bulkOnly);
 
   try {
     const [dappOrders, whitelistOrders] = await Promise.all([
@@ -55,15 +57,16 @@ export const fetchUserContacts = async ({
         userAddress: vUserAddress,
         appAddress: vDappAddressOrENS,
         isUserStrict: vIsUserStrict,
+        bulkOnly: vBulkOnly,
       }),
       fetchAllOrdersByApp({
         iexec,
         userAddress: vUserAddress,
         appAddress: vDappWhitelistAddress,
         isUserStrict: vIsUserStrict,
+        bulkOnly: vBulkOnly,
       }),
     ]);
-
     const orders = dappOrders.concat(whitelistOrders);
     const myContacts: Omit<Contact, 'name'>[] = [];
     let web3DappResolvedAddress = vDappAddressOrENS;
@@ -77,13 +80,25 @@ export const fetchUserContacts = async ({
         order.order.apprestrict.toLowerCase() ===
           vDappWhitelistAddress.toLowerCase()
       ) {
-        const contact = {
+        const contact: Contact = {
           address: order.order.dataset.toLowerCase(),
           owner: order.signer.toLowerCase(),
           remainingAccess: order.remaining,
           accessPrice: order.order.datasetprice,
           accessGrantTimestamp: order.publicationTimestamp,
           isUserStrict: order.order.requesterrestrict !== ZeroAddress,
+          grantedAccess: {
+            dataset: order.order.dataset,
+            datasetprice: order.order.datasetprice.toString(),
+            volume: order.order.volume.toString(),
+            tag: order.order.tag,
+            apprestrict: order.order.apprestrict,
+            workerpoolrestrict: order.order.workerpoolrestrict,
+            requesterrestrict: order.order.requesterrestrict,
+            salt: order.order.salt,
+            sign: order.order.sign,
+            remainingAccess: order.remaining,
+          } as GrantedAccess,
         };
         myContacts.push(contact);
       }
@@ -94,7 +109,6 @@ export const fetchUserContacts = async ({
     return await getValidContact(graphQLClient, myContacts);
   } catch (error) {
     handleIfProtocolError(error);
-
     throw new WorkflowError({
       message: 'Failed to fetch user contacts',
       errorCause: error,
@@ -107,23 +121,24 @@ async function fetchAllOrdersByApp({
   userAddress,
   appAddress,
   isUserStrict,
+  bulkOnly,
 }: {
   iexec: IExec;
   userAddress: string;
   appAddress: string;
   isUserStrict: boolean;
+  bulkOnly?: boolean;
 }): Promise<PublishedDatasetorder[]> {
-  const ordersFirstPage = iexec.orderbook.fetchDatasetOrderbook(
-    ANY_DATASET_ADDRESS,
-    {
-      app: appAddress,
-      requester: userAddress,
-      isAppStrict: true,
-      isRequesterStrict: isUserStrict,
-      // Use maxPageSize here to avoid too many round-trips (we want everything anyway)
-      pageSize: 1000,
-    }
-  );
+  const ordersFirstPage = iexec.orderbook.fetchDatasetOrderbook({
+    dataset: ANY_DATASET_ADDRESS,
+    app: appAddress,
+    requester: userAddress,
+    isAppStrict: true,
+    isRequesterStrict: isUserStrict,
+    bulkOnly,
+    // Use maxPageSize here to avoid too many round-trips (we want everything anyway)
+    pageSize: 1000,
+  });
   const { orders: allOrders } = await autoPaginateRequest({
     request: ordersFirstPage,
   });

package/src/web3mail/internalTypes.ts

@@ -1,6 +1,7 @@
 import { IExec } from 'iexec';
 import { AddressOrENS } from './types.js';
 import { GraphQLClient } from 'graphql-request';
+import { IExecDataProtectorCore } from '@iexec/dataprotector';
 
 export type ProtectedDataQuery = {
   id: string;
@@ -31,6 +32,8 @@ export type IExecConsumer = {
   iexec: IExec;
 };
 
+export type DataProtectorConsumer = { dataProtector: IExecDataProtectorCore };
+
 export type SubgraphConsumer = {
   graphQLClient: GraphQLClient;
 };

package/src/web3mail/sendEmail.ts

@@ -1,18 +1,16 @@
 import { Buffer } from 'buffer';
+import { ProcessBulkRequestResponse } from '@iexec/dataprotector';
 import {
-  CALLBACK_WEB3MAIL,
   DEFAULT_CONTENT_TYPE,
   MAX_DESIRED_APP_ORDER_PRICE,
   MAX_DESIRED_DATA_ORDER_PRICE,
   MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
 } from '../config/config.js';
 import { handleIfProtocolError, WorkflowError } from '../utils/errors.js';
-import { generateSecureUniqueId } from '../utils/generateUniqueId.js';
 import * as ipfs from '../utils/ipfs-service.js';
 import { checkProtectedDataValidity } from '../utils/subgraphQuery.js';
 import {
   addressOrEnsSchema,
-  addressSchema,
   booleanSchema,
   contentTypeSchema,
   emailContentSchema,
@@ -22,14 +20,11 @@ import {
   senderNameSchema,
   throwIfMissing,
 } from '../utils/validators.js';
-import {
-  checkUserVoucher,
-  filterWorkerpoolOrders,
-} from './sendEmail.models.js';
-import { SendEmailParams, SendEmailResponse } from './types.js';
+import { SendEmailParams, SendEmailSingleResponse } from './types.js';
 import {
   DappAddressConsumer,
   DappWhitelistAddressConsumer,
+  DataProtectorConsumer,
   IExecConsumer,
   IpfsGatewayConfigConsumer,
   IpfsNodeConfigConsumer,
@@ -41,9 +36,9 @@ export type SendEmail = typeof sendEmail;
 export const sendEmail = async ({
   graphQLClient = throwIfMissing(),
   iexec = throwIfMissing(),
-  workerpoolAddressOrEns,
+  dataProtector = throwIfMissing(),
+  workerpoolAddressOrEns = throwIfMissing(),
   dappAddressOrENS,
-  dappWhitelistAddress,
   ipfsNode,
   ipfsGateway,
   emailSubject,
@@ -55,6 +50,8 @@ export const sendEmail = async ({
   workerpoolMaxPrice = MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
   senderName,
   protectedData,
+  grantedAccess,
+  maxProtectedDataPerTask,
   useVoucher = false,
 }: IExecConsumer &
   SubgraphConsumer &
@@ -62,182 +59,55 @@ export const sendEmail = async ({
   DappWhitelistAddressConsumer &
   IpfsNodeConfigConsumer &
   IpfsGatewayConfigConsumer &
-  SendEmailParams): Promise<SendEmailResponse> => {
-  const vDatasetAddress = addressOrEnsSchema()
-    .required()
-    .label('protectedData')
-    .validateSync(protectedData);
-  const vEmailSubject = emailSubjectSchema()
-    .required()
-    .label('emailSubject')
-    .validateSync(emailSubject);
-  const vEmailContent = emailContentSchema()
-    .required()
-    .label('emailContent')
-    .validateSync(emailContent);
-  const vContentType = contentTypeSchema()
-    .required()
-    .label('contentType')
-    .validateSync(contentType);
-  const vSenderName = senderNameSchema()
-    .label('senderName')
-    .validateSync(senderName);
-  const vLabel = labelSchema().label('label').validateSync(label);
-  const vWorkerpoolAddressOrEns = addressOrEnsSchema()
-    .required()
-    .label('WorkerpoolAddressOrEns')
-    .validateSync(workerpoolAddressOrEns);
-  const vDappAddressOrENS = addressOrEnsSchema()
-    .required()
-    .label('dappAddressOrENS')
-    .validateSync(dappAddressOrENS);
-  const vDappWhitelistAddress = addressSchema()
-    .required()
-    .label('dappWhitelistAddress')
-    .validateSync(dappWhitelistAddress);
-  const vDataMaxPrice = positiveNumberSchema()
-    .label('dataMaxPrice')
-    .validateSync(dataMaxPrice);
-  const vAppMaxPrice = positiveNumberSchema()
-    .label('appMaxPrice')
-    .validateSync(appMaxPrice);
-  const vWorkerpoolMaxPrice = positiveNumberSchema()
-    .label('workerpoolMaxPrice')
-    .validateSync(workerpoolMaxPrice);
-  const vUseVoucher = booleanSchema()
-    .label('useVoucher')
-    .validateSync(useVoucher);
-
-  // Check protected data schema through subgraph
-  const isValidProtectedData = await checkProtectedDataValidity(
-    graphQLClient,
-    vDatasetAddress
-  );
-  if (!isValidProtectedData) {
-    throw new Error(
-      'This protected data does not contain "email:string" in its schema.'
-    );
-  }
-
-  const requesterAddress = await iexec.wallet.getAddress();
-
-  let userVoucher;
-  if (vUseVoucher) {
-    try {
-      userVoucher = await iexec.voucher.showUserVoucher(requesterAddress);
-      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;
-    }
-  }
-
+  SendEmailParams &
+  DataProtectorConsumer): Promise<
+  ProcessBulkRequestResponse | SendEmailSingleResponse
+> => {
   try {
-    const [
-      datasetorderForApp,
-      datasetorderForWhitelist,
-      apporder,
-      workerpoolorder,
-    ] = await Promise.all([
-      // Fetch dataset order for web3mail app
-      iexec.orderbook
-        .fetchDatasetOrderbook(vDatasetAddress, {
-          app: dappAddressOrENS,
-          requester: requesterAddress,
-        })
-        .then((datasetOrderbook) => {
-          const desiredPriceDataOrderbook = datasetOrderbook.orders.filter(
-            (order) => order.order.datasetprice <= vDataMaxPrice
-          );
-          return desiredPriceDataOrderbook[0]?.order; // may be undefined
-        }),
-      // Fetch dataset order for web3mail whitelist
-      iexec.orderbook
-        .fetchDatasetOrderbook(vDatasetAddress, {
-          app: vDappWhitelistAddress,
-          requester: requesterAddress,
-        })
-        .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(dappAddressOrENS, {
-          minTag: ['tee', 'scone'],
-          maxTag: ['tee', 'scone'],
-          workerpool: workerpoolAddressOrEns,
-        })
-        .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: workerpoolAddressOrEns,
-          app: vDappAddressOrENS,
-          dataset: vDatasetAddress,
-          requester: requesterAddress, // 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: workerpoolAddressOrEns,
-          app: vDappWhitelistAddress,
-          dataset: vDatasetAddress,
-          requester: requesterAddress, // 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;
-        }
-      ),
-    ]);
-
-    if (!workerpoolorder) {
-      throw new Error('No Workerpool order found for the desired price');
-    }
+    const vUseVoucher = booleanSchema()
+      .label('useVoucher')
+      .validateSync(useVoucher);
+    const vWorkerpoolAddressOrEns = addressOrEnsSchema()
+      .required()
+      .label('WorkerpoolAddressOrEns')
+      .validateSync(workerpoolAddressOrEns);
+    const vSenderName = senderNameSchema()
+      .label('senderName')
+      .validateSync(senderName);
+    const vEmailSubject = emailSubjectSchema()
+      .required()
+      .label('emailSubject')
+      .validateSync(emailSubject);
+    const vEmailContent = emailContentSchema()
+      .required()
+      .label('emailContent')
+      .validateSync(emailContent);
+    const vContentType = contentTypeSchema()
+      .required()
+      .label('contentType')
+      .validateSync(contentType);
+    const vLabel = labelSchema().label('label').validateSync(label);
 
-    const datasetorder = datasetorderForApp || datasetorderForWhitelist;
-    if (!datasetorder) {
-      throw new Error('No Dataset order found for the desired price');
-    }
+    const vDappAddressOrENS = addressOrEnsSchema()
+      .required()
+      .label('dappAddressOrENS')
+      .validateSync(dappAddressOrENS);
+    // TODO: remove this once we have a way to pass appWhitelist to processProtectedData function
+    // const vDappWhitelistAddress = addressSchema()
+    //   .required()
+    //   .label('dappWhitelistAddress')
+    //   .validateSync(dappWhitelistAddress);
+    const vDataMaxPrice = positiveNumberSchema()
+      .label('dataMaxPrice')
+      .validateSync(dataMaxPrice);
+    const vAppMaxPrice = positiveNumberSchema()
+      .label('appMaxPrice')
+      .validateSync(appMaxPrice);
+    const vWorkerpoolMaxPrice = positiveNumberSchema()
+      .label('workerpoolMaxPrice')
+      .validateSync(workerpoolMaxPrice);
 
-    // Push requester secrets
-    const requesterSecretId = generateSecureUniqueId(16);
+    // Encrypt email content
     const emailContentEncryptionKey = iexec.dataset.generateEncryptionKey();
     const encryptedFile = await iexec.dataset
       .encrypt(Buffer.from(vEmailContent, 'utf8'), emailContentEncryptionKey)
@@ -247,10 +117,12 @@ export const sendEmail = async ({
           errorCause: e,
         });
       });
+
+    // Push email message to IPFS
     const cid = await ipfs
       .add(encryptedFile, {
-        ipfsNode: ipfsNode,
-        ipfsGateway: ipfsGateway,
+        ipfsNode,
+        ipfsGateway,
       })
       .catch((e) => {
         throw new WorkflowError({
@@ -260,55 +132,109 @@ export const sendEmail = async ({
       });
     const multiaddr = `/ipfs/${cid}`;
 
-    await iexec.secrets.pushRequesterSecret(
-      requesterSecretId,
-      JSON.stringify({
+    // Prepare secrets for the requester
+    // Use a positive integer as secret ID (required by iexec)
+    // Using "1" as a fixed ID for the requester secret
+    const requesterSecretId = 1;
+    const secrets = {
+      [requesterSecretId]: JSON.stringify({
+        senderName: vSenderName,
         emailSubject: vEmailSubject,
         emailContentMultiAddr: multiaddr,
         contentType: vContentType,
-        senderName: vSenderName,
         emailContentEncryptionKey,
-        useCallback: true,
-      })
+      }),
+    };
+    // Bulk processing
+    if (grantedAccess) {
+      const vMaxProtectedDataPerTask = positiveNumberSchema()
+        .label('maxProtectedDataPerTask')
+        .validateSync(maxProtectedDataPerTask);
+
+      const bulkRequest = await dataProtector.prepareBulkRequest({
+        app: vDappAddressOrENS,
+        appMaxPrice: vAppMaxPrice,
+        workerpoolMaxPrice: vWorkerpoolMaxPrice,
+        workerpool: vWorkerpoolAddressOrEns,
+        args: vLabel,
+        inputFiles: [],
+        secrets,
+        bulkOrders: grantedAccess,
+        maxProtectedDataPerTask: vMaxProtectedDataPerTask,
+      });
+      const processBulkRequestResponse: ProcessBulkRequestResponse =
+        await dataProtector.processBulkRequest({
+          bulkRequest: bulkRequest.bulkRequest,
+          useVoucher: vUseVoucher,
+          workerpool: vWorkerpoolAddressOrEns,
+        });
+      return processBulkRequestResponse;
+    }
+
+    // Single processing mode - protectedData is required
+    const vDatasetAddress = addressOrEnsSchema()
+      .required()
+      .label('protectedData')
+      .validateSync(protectedData);
+    // Check protected data validity through subgraph
+    const isValidProtectedData = await checkProtectedDataValidity(
+      graphQLClient,
+      vDatasetAddress
     );
+    if (!isValidProtectedData) {
+      throw new Error(
+        'This protected data does not contain "email:string" in its schema.'
+      );
+    }
 
-    const requestorderToSign = await iexec.order.createRequestorder({
+    // Use processProtectedData from dataprotector
+    const result = await dataProtector.processProtectedData({
+      defaultWorkerpool: vWorkerpoolAddressOrEns,
+      protectedData: vDatasetAddress,
       app: vDappAddressOrENS,
-      category: workerpoolorder.category,
-      dataset: vDatasetAddress,
-      datasetmaxprice: datasetorder.datasetprice,
-      appmaxprice: apporder.appprice,
-      workerpoolmaxprice: workerpoolorder.workerpoolprice,
-      tag: ['tee', 'scone'],
+      // userWhitelist: vDappWhitelistAddress, // Removed due to bug in dataprotector v2.0.0-beta.20
+      dataMaxPrice: vDataMaxPrice,
+      appMaxPrice: vAppMaxPrice,
+      workerpoolMaxPrice: vWorkerpoolMaxPrice,
       workerpool: vWorkerpoolAddressOrEns,
-      callback: CALLBACK_WEB3MAIL,
-      params: {
-        iexec_secrets: {
-          1: requesterSecretId,
-        },
-        iexec_args: vLabel,
-      },
+      args: vLabel,
+      inputFiles: [],
+      secrets,
+      useVoucher: vUseVoucher,
+      waitForResult: false,
     });
-    const requestorder = await iexec.order.signRequestorder(requestorderToSign);
-
-    // Match orders and compute task ID
-    const { dealid } = await iexec.order.matchOrders(
-      {
-        apporder: apporder,
-        datasetorder: datasetorder,
-        workerpoolorder: workerpoolorder,
-        requestorder: requestorder,
-      },
-      { useVoucher: vUseVoucher }
-    );
-    const taskId = await iexec.deal.computeTaskId(dealid, 0);
 
     return {
-      taskId,
+      taskId: result.taskId,
     };
   } catch (error) {
+    //  Protocol error detected, re-throwing as-is
+    if ((error as any)?.isProtocolError === true) {
+      throw error;
+    }
+
+    // Handle protocol errors - this will throw if it's an ApiCallError
+    // handleIfProtocolError transforms ApiCallError into a WorkflowError with isProtocolError=true
     handleIfProtocolError(error);
 
+    // If we reach here, it's not a protocol error
+    // Check if it's a WorkflowError from processProtectedData by checking the message
+    const isProcessProtectedDataError =
+      error instanceof Error &&
+      error.message === 'Failed to process protected data';
+
+    if (isProcessProtectedDataError) {
+      const cause = (error as any)?.cause;
+      // Return unwrapped cause (the actual Error object)
+      // error.cause should be an Error, but ensure it is
+      const unwrappedCause = cause instanceof Error ? cause : error;
+      throw new WorkflowError({
+        message: 'Failed to sendEmail',
+        errorCause: unwrappedCause,
+      });
+    }
+
+    // For all other errors
     throw new WorkflowError({
       message: 'Failed to sendEmail',
       errorCause: error,

package/src/web3mail/types.ts

@@ -11,20 +11,41 @@ export type Address = string;
 
 export type TimeStamp = string;
 
+export type GrantedAccess = {
+  dataset: string;
+  datasetprice: string;
+  volume: string;
+  tag: string;
+  apprestrict: string;
+  workerpoolrestrict: string;
+  requesterrestrict: string;
+  salt: string;
+  sign: string;
+  remainingAccess: number;
+};
+
 export type Contact = {
   address: Address;
   owner: Address;
   accessGrantTimestamp: TimeStamp;
   isUserStrict: boolean;
-  name: string;
+  name?: string;
   remainingAccess: number;
   accessPrice: number;
+  grantedAccess: GrantedAccess;
 };
 
 export type SendEmailParams = {
   emailSubject: string;
   emailContent: string;
-  protectedData: Address;
+  protectedData?: Address;
+  /**
+   * Granted access to process.
+   * use prepareBulkRequest of dataprotector to create a bulk request.
+   * if not provided, the single message will be processed.
+   */
+  grantedAccess?: GrantedAccess[];
+  maxProtectedDataPerTask?: number;
   contentType?: string;
   senderName?: string;
   label?: string;
@@ -40,6 +61,7 @@ export type FetchMyContactsParams = {
    * Get contacts for this specific user only
    */
   isUserStrict?: boolean;
+  bulkOnly?: boolean;
 };
 
 export type FetchUserContactsParams = {
@@ -49,7 +71,7 @@ export type FetchUserContactsParams = {
   userAddress: Address;
 } & FetchMyContactsParams;
 
-export type SendEmailResponse = {
+export type SendEmailSingleResponse = {
   taskId: string;
 };