@iexec/web3mail 1.6.0-nightly-b2a0e93 → 1.7.0

package/src/web3mail/sendEmail.ts

@@ -1,15 +1,18 @@
 import { Buffer } from 'buffer';
 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,
@@ -19,11 +22,14 @@ import {
   senderNameSchema,
   throwIfMissing,
 } from '../utils/validators.js';
+import {
+  checkUserVoucher,
+  filterWorkerpoolOrders,
+} from './sendEmail.models.js';
 import { SendEmailParams, SendEmailResponse } from './types.js';
 import {
   DappAddressConsumer,
   DappWhitelistAddressConsumer,
-  DataProtectorConsumer,
   IExecConsumer,
   IpfsGatewayConfigConsumer,
   IpfsNodeConfigConsumer,
@@ -35,9 +41,9 @@ export type SendEmail = typeof sendEmail;
 export const sendEmail = async ({
   graphQLClient = throwIfMissing(),
   iexec = throwIfMissing(),
-  dataProtector = throwIfMissing(),
-  workerpoolAddressOrEns = throwIfMissing(),
+  workerpoolAddressOrEns,
   dappAddressOrENS,
+  dappWhitelistAddress,
   ipfsNode,
   ipfsGateway,
   emailSubject,
@@ -49,8 +55,6 @@ export const sendEmail = async ({
   workerpoolMaxPrice = MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
   senderName,
   protectedData,
-  grantedAccess,
-  maxProtectedDataPerTask,
   useVoucher = false,
 }: IExecConsumer &
   SubgraphConsumer &
@@ -58,53 +62,203 @@ export const sendEmail = async ({
   DappWhitelistAddressConsumer &
   IpfsNodeConfigConsumer &
   IpfsGatewayConfigConsumer &
-  SendEmailParams &
-  DataProtectorConsumer): Promise<SendEmailResponse<SendEmailParams>> => {
+  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;
+    }
+  }
+
   try {
-    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 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);
-
-    // Encrypt email content
+    const [
+      datasetorderForApp,
+      datasetorderForWhitelist,
+      apporder,
+      workerpoolorder,
+    ] = await Promise.all([
+      // Fetch dataset order for web3mail app
+      iexec.orderbook
+        .fetchDatasetOrderbook({
+          dataset: 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({
+          dataset: 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({
+          app: 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 datasetorder = datasetorderForApp || datasetorderForWhitelist;
+    if (!datasetorder) {
+      throw new Error('No Dataset order found for the desired price');
+    }
+
+    // Push requester secrets
+    const requesterSecretId = generateSecureUniqueId(16);
     const emailContentEncryptionKey = iexec.dataset.generateEncryptionKey();
     const encryptedFile = await iexec.dataset
       .encrypt(Buffer.from(vEmailContent, 'utf8'), emailContentEncryptionKey)
@@ -115,11 +269,10 @@ export const sendEmail = async ({
         });
       });
 
-    // Push email message to IPFS
     const cid = await ipfs
       .add(encryptedFile, {
-        ipfsNode,
-        ipfsGateway,
+        ipfsNode: ipfsNode,
+        ipfsGateway: ipfsGateway,
       })
       .catch((e) => {
         throw new WorkflowError({
@@ -127,118 +280,61 @@ export const sendEmail = async ({
           errorCause: e,
         });
       });
+
     const multiaddr = `/ipfs/${cid}`;
 
-    // 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,
+    await iexec.secrets.pushRequesterSecret(
+      requesterSecretId,
+      JSON.stringify({
         emailSubject: vEmailSubject,
         emailContentMultiAddr: multiaddr,
         contentType: vContentType,
+        senderName: vSenderName,
         emailContentEncryptionKey,
-      }),
-    };
-    // 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,
-        bulkAccesses: grantedAccess,
-        maxProtectedDataPerTask: vMaxProtectedDataPerTask,
-      });
-      const processBulkRequestResponse = await dataProtector.processBulkRequest(
-        {
-          bulkRequest: bulkRequest.bulkRequest,
-          useVoucher: vUseVoucher,
-          workerpool: vWorkerpoolAddressOrEns,
-        }
-      );
-      return {
-        tasks: processBulkRequestResponse.tasks.map((task) => ({
-          taskId: task.taskId,
-          dealId: task.dealId,
-          bulkIndex: task.bulkIndex,
-        })),
-      } as unknown as SendEmailResponse<SendEmailParams>;
-    }
-
-    // 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
+        useCallback: true,
+      })
     );
-    if (!isValidProtectedData) {
-      throw new Error(
-        'This protected data does not contain "email:string" in its schema.'
-      );
-    }
 
-    // Use processProtectedData from dataprotector
-    const result = await dataProtector.processProtectedData({
-      defaultWorkerpool: vWorkerpoolAddressOrEns,
-      protectedData: vDatasetAddress,
+    const requestorderToSign = await iexec.order.createRequestorder({
       app: vDappAddressOrENS,
-      // userWhitelist: vDappWhitelistAddress, // Removed due to bug in dataprotector v2.0.0-beta.20
-      dataMaxPrice: vDataMaxPrice,
-      appMaxPrice: vAppMaxPrice,
-      workerpoolMaxPrice: vWorkerpoolMaxPrice,
+      category: workerpoolorder.category,
+      dataset: vDatasetAddress,
+      datasetmaxprice: datasetorder.datasetprice,
+      appmaxprice: apporder.appprice,
+      workerpoolmaxprice: workerpoolorder.workerpoolprice,
+      tag: ['tee', 'scone'],
       workerpool: vWorkerpoolAddressOrEns,
-      args: vLabel,
-      inputFiles: [],
-      secrets,
-      useVoucher: vUseVoucher,
-      waitForResult: false,
+      callback: CALLBACK_WEB3MAIL,
+      params: {
+        iexec_secrets: {
+          1: requesterSecretId,
+        },
+        iexec_args: vLabel,
+      },
     });
 
+    const requestorder = await iexec.order.signRequestorder(requestorderToSign);
+
+    // Match orders and compute task ID
+    const { dealid: 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: result.taskId,
-    } as unknown as SendEmailResponse<SendEmailParams>;
+      taskId,
+      dealId,
+    };
   } 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/sendEmailCampaign.ts

@@ -0,0 +1,69 @@
+import { NULL_ADDRESS } from 'iexec/utils';
+import { ValidationError } from 'yup';
+import { handleIfProtocolError, WorkflowError } from '../utils/errors.js';
+import {
+  addressOrEnsSchema,
+  campaignRequestSchema,
+  throwIfMissing,
+} from '../utils/validators.js';
+import {
+  CampaignRequest,
+  SendEmailCampaignParams,
+  SendEmailCampaignResponse,
+} from './types.js';
+import { DataProtectorConsumer } from './internalTypes.js';
+
+export type SendEmailCampaign = typeof sendEmailCampaign;
+
+export const sendEmailCampaign = async ({
+  dataProtector = throwIfMissing(),
+  workerpoolAddressOrEns = throwIfMissing(),
+  campaignRequest,
+}: DataProtectorConsumer &
+  SendEmailCampaignParams): Promise<SendEmailCampaignResponse> => {
+  const vCampaignRequest = campaignRequestSchema()
+    .required()
+    .label('campaignRequest')
+    .validateSync(campaignRequest) as CampaignRequest;
+
+  const vWorkerpoolAddressOrEns = addressOrEnsSchema()
+    .required()
+    .label('workerpoolAddressOrEns')
+    .validateSync(workerpoolAddressOrEns);
+
+  if (
+    vCampaignRequest.workerpool !== NULL_ADDRESS &&
+    vCampaignRequest.workerpool.toLowerCase() !==
+      vWorkerpoolAddressOrEns.toLowerCase()
+  ) {
+    throw new ValidationError(
+      "workerpoolAddressOrEns doesn't match campaignRequest workerpool"
+    );
+  }
+
+  try {
+    // Process the prepared bulk request
+    const processBulkRequestResponse = await dataProtector.processBulkRequest({
+      bulkRequest: vCampaignRequest,
+      workerpool: vWorkerpoolAddressOrEns,
+      waitForResult: false,
+    });
+
+    return processBulkRequestResponse;
+  } 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);
+
+    // For all other errors
+    throw new WorkflowError({
+      message: 'Failed to sendEmailCampaign',
+      errorCause: error,
+    });
+  }
+};

package/src/web3mail/types.ts

@@ -1,5 +1,6 @@
 import { EnhancedWallet } from 'iexec';
 import { IExecConfigOptions } from 'iexec/IExecConfig';
+import type { BulkRequest } from '@iexec/dataprotector';
 
 export type Web3SignerProvider = EnhancedWallet;
 
@@ -11,6 +12,22 @@ export type Address = string;
 
 export type TimeStamp = string;
 
+/**
+ * request to send email in bulk
+ *
+ * use `prepareEmailCampaign()` to create a `CampaignRequest`
+ *
+ * then use `sendEmailCampaign()` to send the campaign
+ */
+export type CampaignRequest = BulkRequest;
+
+/**
+ * authorization signed by the data owner granting access to this contact
+ *
+ * `GrantedAccess` are obtained by fetching contacts (e.g. `fetchMyContacts()` or `fetchUserContacts()`)
+ *
+ * `GrantedAccess` can be consumed for email campaigns (e.g. `prepareEmailCampaign()` then `sendEmailCampaign()`)
+ */
 export type GrantedAccess = {
   dataset: string;
   datasetprice: string;
@@ -38,14 +55,7 @@ export type Contact = {
 export type SendEmailParams = {
   emailSubject: string;
   emailContent: string;
-  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;
+  protectedData: Address;
   contentType?: string;
   senderName?: string;
   label?: string;
@@ -61,6 +71,9 @@ export type FetchMyContactsParams = {
    * Get contacts for this specific user only
    */
   isUserStrict?: boolean;
+  /**
+   * If true, returns only contacts with bulk processing access grants
+   */
   bulkOnly?: boolean;
 };
 
@@ -71,27 +84,17 @@ export type FetchUserContactsParams = {
   userAddress: Address;
 } & FetchMyContactsParams;
 
-type SendEmailSingleResponse = {
+export type SendEmailResponse = {
+  /**
+   * ID of the task
+   */
   taskId: string;
+  /**
+   * ID of the deal containing the task
+   */
+  dealId: string;
 };
 
-type SendEmailBulkResponse = {
-  tasks: {
-    bulkIndex: number;
-    taskId: string;
-    dealId: string;
-  }[];
-};
-
-export type SendEmailResponse<Params = { protectedData: Address }> =
-  Params extends {
-    grantedAccess: GrantedAccess[];
-  }
-    ? SendEmailBulkResponse
-    : never & Params extends { protectedData: Address }
-    ? SendEmailSingleResponse
-    : never;
-
 /**
  * Configuration options for Web3Mail.
  */
@@ -139,3 +142,62 @@ export type Web3MailConfigOptions = {
    */
   allowExperimentalNetworks?: boolean;
 };
+
+export type PrepareEmailCampaignParams = {
+  /**
+   * List of `GrantedAccess` to contacts to send emails to in bulk.
+   *
+   * use `fetchMyContacts({ bulkOnly: true })` to get granted accesses.
+   */
+  grantedAccesses: GrantedAccess[];
+  maxProtectedDataPerTask?: number;
+  senderName?: string;
+  emailSubject: string;
+  emailContent: string;
+  contentType?: string;
+  label?: string;
+  workerpoolAddressOrEns?: AddressOrENS;
+  dataMaxPrice?: number;
+  appMaxPrice?: number;
+  workerpoolMaxPrice?: number;
+};
+
+export type PrepareEmailCampaignResponse = {
+  /**
+   * The prepared campaign request
+   *
+   * Use this in `sendEmailCampaign()` to start or continue sending the campaign
+   */
+  campaignRequest: CampaignRequest;
+};
+
+export type SendEmailCampaignParams = {
+  /**
+   * The prepared campaign request from `prepareEmailCampaign()`
+   */
+  campaignRequest: CampaignRequest;
+  /**
+   * Workerpool address or ENS to use for processing
+   */
+  workerpoolAddressOrEns?: AddressOrENS;
+};
+
+export type SendEmailCampaignResponse = {
+  /**
+   * List of tasks created for the campaign
+   */
+  tasks: Array<{
+    /**
+     * ID of the task
+     */
+    taskId: string;
+    /**
+     * ID of the deal containing the task
+     */
+    dealId: string;
+    /**
+     * Index of the task in the bulk request
+     */
+    bulkIndex: number;
+  }>;
+};