@iexec/web3mail 1.6.0-nightly-b2a0e93 → 1.7.0

package/src/utils/validators.ts

@@ -1,6 +1,7 @@
 import { isAddress } from 'ethers';
 import { IExec } from 'iexec';
-import { ValidationError, boolean, number, string } from 'yup';
+import { NULL_ADDRESS } from 'iexec/utils';
+import { ValidationError, boolean, number, object, string } from 'yup';
 
 export const isValidProvider = async (iexec: IExec) => {
   const client = await iexec.config.resolveContractsClient();
@@ -61,3 +62,69 @@ export const positiveNumberSchema = () =>
 
 export const booleanSchema = () =>
   boolean().strict().typeError('${path} should be a boolean');
+
+const isPositiveIntegerStringTest = (value: string) => /^\d+$/.test(value);
+
+const stringSchema = () =>
+  string().strict().typeError('${path} should be a string');
+
+const positiveIntegerStringSchema = () =>
+  string().test(
+    'is-positive-int',
+    '${path} should be a positive integer',
+    (value) => isUndefined(value) || isPositiveIntegerStringTest(value)
+  );
+
+const positiveStrictIntegerStringSchema = () =>
+  string().test(
+    'is-positive-strict-int',
+    '${path} should be a strictly positive integer',
+    (value) =>
+      isUndefined(value) ||
+      (value !== '0' && isPositiveIntegerStringTest(value))
+  );
+
+export const campaignRequestSchema = () =>
+  object({
+    app: addressSchema().required(),
+    appmaxprice: positiveIntegerStringSchema().required(),
+    workerpool: addressSchema().required(),
+    workerpoolmaxprice: positiveIntegerStringSchema().required(),
+    dataset: addressSchema().oneOf([NULL_ADDRESS]).required(),
+    datasetmaxprice: positiveIntegerStringSchema().oneOf(['0']).required(),
+    params: stringSchema()
+      .test(
+        'is-valid-bulk-params',
+        '${path} should be a valid JSON string with bulk_cid field',
+        (value) => {
+          try {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const { bulk_cid } = JSON.parse(value);
+            if (typeof bulk_cid === 'string') {
+              return true;
+            }
+          } catch {}
+          return false;
+        }
+      )
+      .required(),
+    requester: addressSchema().required(),
+    beneficiary: addressSchema().required(),
+    callback: addressSchema().required(),
+    category: positiveIntegerStringSchema().required(),
+    volume: positiveStrictIntegerStringSchema().required(),
+    tag: stringSchema().required(),
+    trust: positiveIntegerStringSchema().required(),
+    salt: stringSchema().required(),
+    sign: stringSchema().required(),
+  })
+    .strict()
+    .typeError('${path} should be a BulkRequest object')
+    .test('is-defined', '${path} is required', (value) => {
+      // Check if value is undefined, null, or an empty object (which would be coerced from undefined)
+      return (
+        value !== undefined &&
+        value !== null &&
+        !(typeof value === 'object' && Object.keys(value).length === 0)
+      );
+    });

package/src/web3mail/IExecWeb3mail.ts

@@ -5,6 +5,8 @@ import { GraphQLClient } from 'graphql-request';
 import { fetchUserContacts } from './fetchUserContacts.js';
 import { fetchMyContacts } from './fetchMyContacts.js';
 import { sendEmail } from './sendEmail.js';
+import { prepareEmailCampaign } from './prepareEmailCampaign.js';
+import { sendEmailCampaign } from './sendEmailCampaign.js';
 import {
   Contact,
   FetchUserContactsParams,
@@ -14,6 +16,10 @@ import {
   SendEmailResponse,
   Web3SignerProvider,
   FetchMyContactsParams,
+  PrepareEmailCampaignParams,
+  PrepareEmailCampaignResponse,
+  SendEmailCampaignParams,
+  SendEmailCampaignResponse,
 } from './types.js';
 import { isValidProvider } from '../utils/validators.js';
 import { getChainIdFromProvider } from '../utils/getChainId.js';
@@ -110,9 +116,7 @@ export class IExecWeb3mail {
     });
   }
 
-  async sendEmail<Params extends SendEmailParams>(
-    args: Params
-  ): Promise<SendEmailResponse<Params>> {
+  async sendEmail(args: SendEmailParams): Promise<SendEmailResponse> {
     await this.init();
     await isValidProvider(this.iexec);
     return sendEmail({
@@ -120,13 +124,42 @@ export class IExecWeb3mail {
       workerpoolAddressOrEns:
         args.workerpoolAddressOrEns || this.defaultWorkerpool,
       iexec: this.iexec,
-      dataProtector: this.dataProtector,
       ipfsNode: this.ipfsNode,
       ipfsGateway: this.ipfsGateway,
       dappAddressOrENS: this.dappAddressOrENS,
       dappWhitelistAddress: this.dappWhitelistAddress,
       graphQLClient: this.graphQLClient,
-    }) as Promise<SendEmailResponse<Params>>;
+    });
+  }
+
+  async prepareEmailCampaign(
+    args: PrepareEmailCampaignParams
+  ): Promise<PrepareEmailCampaignResponse> {
+    await this.init();
+    await isValidProvider(this.iexec);
+    return prepareEmailCampaign({
+      ...args,
+      workerpoolAddressOrEns:
+        args.workerpoolAddressOrEns || this.defaultWorkerpool,
+      iexec: this.iexec,
+      dataProtector: this.dataProtector,
+      ipfsNode: this.ipfsNode,
+      ipfsGateway: this.ipfsGateway,
+      dappAddressOrENS: this.dappAddressOrENS,
+    });
+  }
+
+  async sendEmailCampaign(
+    args: SendEmailCampaignParams
+  ): Promise<SendEmailCampaignResponse> {
+    await this.init();
+    await isValidProvider(this.iexec);
+    return sendEmailCampaign({
+      ...args,
+      workerpoolAddressOrEns:
+        args.workerpoolAddressOrEns || this.defaultWorkerpool,
+      dataProtector: this.dataProtector,
+    });
   }
 
   private async resolveConfig(): Promise<Web3mailResolvedConfig> {

package/src/web3mail/fetchMyContacts.ts

@@ -25,6 +25,7 @@ export const fetchMyContacts = async ({
   const vIsUserStrict = booleanSchema()
     .label('isUserStrict')
     .validateSync(isUserStrict);
+  const vBulkOnly = booleanSchema().label('bulkOnly').validateSync(bulkOnly);
 
   const userAddress = await iexec.wallet.getAddress();
   return fetchUserContacts({
@@ -34,6 +35,6 @@ export const fetchMyContacts = async ({
     dappWhitelistAddress,
     userAddress,
     isUserStrict: vIsUserStrict,
-    bulkOnly,
+    bulkOnly: vBulkOnly,
   });
 };

package/src/web3mail/fetchUserContacts.ts

@@ -12,7 +12,7 @@ import {
   isEnsTest,
   throwIfMissing,
 } from '../utils/validators.js';
-import { Contact, FetchUserContactsParams, GrantedAccess } from './types.js';
+import { Contact, FetchUserContactsParams } from './types.js';
 import {
   DappAddressConsumer,
   DappWhitelistAddressConsumer,
@@ -67,6 +67,7 @@ export const fetchUserContacts = async ({
         bulkOnly: vBulkOnly,
       }),
     ]);
+
     const orders = dappOrders.concat(whitelistOrders);
     const myContacts: Omit<Contact, 'name'>[] = [];
     let web3DappResolvedAddress = vDappAddressOrENS;
@@ -80,7 +81,7 @@ export const fetchUserContacts = async ({
         order.order.apprestrict.toLowerCase() ===
           vDappWhitelistAddress.toLowerCase()
       ) {
-        const contact: Contact = {
+        const contact = {
           address: order.order.dataset.toLowerCase(),
           owner: order.signer.toLowerCase(),
           remainingAccess: order.remaining,
@@ -91,14 +92,14 @@ export const fetchUserContacts = async ({
             dataset: order.order.dataset,
             datasetprice: order.order.datasetprice.toString(),
             volume: order.order.volume.toString(),
-            tag: order.order.tag,
+            tag: order.order.tag.toString(),
             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);
       }
@@ -109,6 +110,7 @@ export const fetchUserContacts = async ({
     return await getValidContact(graphQLClient, myContacts);
   } catch (error) {
     handleIfProtocolError(error);
+
     throw new WorkflowError({
       message: 'Failed to fetch user contacts',
       errorCause: error,
@@ -127,7 +129,7 @@ async function fetchAllOrdersByApp({
   userAddress: string;
   appAddress: string;
   isUserStrict: boolean;
-  bulkOnly?: boolean;
+  bulkOnly: boolean;
 }): Promise<PublishedDatasetorder[]> {
   const ordersFirstPage = iexec.orderbook.fetchDatasetOrderbook({
     dataset: ANY_DATASET_ADDRESS,

package/src/web3mail/internalTypes.ts

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

package/src/web3mail/prepareEmailCampaign.ts

@@ -0,0 +1,170 @@
+import { Buffer } from 'buffer';
+import {
+  DEFAULT_CONTENT_TYPE,
+  MAX_DESIRED_APP_ORDER_PRICE,
+  MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
+} from '../config/config.js';
+import { handleIfProtocolError, WorkflowError } from '../utils/errors.js';
+import * as ipfs from '../utils/ipfs-service.js';
+import {
+  addressOrEnsSchema,
+  contentTypeSchema,
+  emailContentSchema,
+  emailSubjectSchema,
+  labelSchema,
+  positiveNumberSchema,
+  senderNameSchema,
+  throwIfMissing,
+} from '../utils/validators.js';
+import {
+  PrepareEmailCampaignParams,
+  PrepareEmailCampaignResponse,
+} from './types.js';
+import {
+  DappAddressConsumer,
+  DataProtectorConsumer,
+  IExecConsumer,
+  IpfsGatewayConfigConsumer,
+  IpfsNodeConfigConsumer,
+} from './internalTypes.js';
+
+export type PrepareEmailCampaign = typeof prepareEmailCampaign;
+
+export const prepareEmailCampaign = async ({
+  iexec = throwIfMissing(),
+  dataProtector = throwIfMissing(),
+  workerpoolAddressOrEns,
+  dappAddressOrENS,
+  ipfsNode,
+  ipfsGateway,
+  senderName,
+  emailSubject,
+  emailContent,
+  contentType = DEFAULT_CONTENT_TYPE,
+  label,
+  appMaxPrice = MAX_DESIRED_APP_ORDER_PRICE,
+  workerpoolMaxPrice = MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
+  grantedAccesses,
+  maxProtectedDataPerTask,
+}: IExecConsumer &
+  DappAddressConsumer &
+  IpfsNodeConfigConsumer &
+  IpfsGatewayConfigConsumer &
+  DataProtectorConsumer &
+  PrepareEmailCampaignParams): Promise<PrepareEmailCampaignResponse> => {
+  try {
+    const vWorkerpoolAddressOrEns = addressOrEnsSchema()
+      .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()
+      .label('contentType')
+      .validateSync(contentType);
+
+    const vLabel = labelSchema().label('label').validateSync(label);
+
+    const vDappAddressOrENS = addressOrEnsSchema()
+      .required()
+      .label('dappAddressOrENS')
+      .validateSync(dappAddressOrENS);
+
+    const vAppMaxPrice = positiveNumberSchema()
+      .label('appMaxPrice')
+      .validateSync(appMaxPrice);
+
+    const vWorkerpoolMaxPrice = positiveNumberSchema()
+      .label('workerpoolMaxPrice')
+      .validateSync(workerpoolMaxPrice);
+
+    const vMaxProtectedDataPerTask = positiveNumberSchema()
+      .label('maxProtectedDataPerTask')
+      .validateSync(maxProtectedDataPerTask);
+
+    // TODO: factor this
+    // Encrypt email content
+    const emailContentEncryptionKey = iexec.dataset.generateEncryptionKey();
+    const encryptedFile = await iexec.dataset
+      .encrypt(Buffer.from(vEmailContent, 'utf8'), emailContentEncryptionKey)
+      .catch((e) => {
+        throw new WorkflowError({
+          message: 'Failed to encrypt email content',
+          errorCause: e,
+        });
+      });
+
+    // Push email content to IPFS
+    const cid = await ipfs
+      .add(encryptedFile, {
+        ipfsNode,
+        ipfsGateway,
+      })
+      .catch((e) => {
+        throw new WorkflowError({
+          message: 'Failed to upload encrypted email content',
+          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({
+        emailSubject: vEmailSubject,
+        emailContentMultiAddr: multiaddr,
+        contentType: vContentType,
+        senderName: vSenderName,
+        emailContentEncryptionKey,
+        useCallback: true,
+      }),
+    };
+
+    // TODO: end factor this
+    const { bulkRequest: campaignRequest } =
+      await dataProtector.prepareBulkRequest({
+        app: vDappAddressOrENS,
+        appMaxPrice: vAppMaxPrice,
+        workerpoolMaxPrice: vWorkerpoolMaxPrice,
+        workerpool: vWorkerpoolAddressOrEns,
+        args: vLabel,
+        inputFiles: [],
+        secrets,
+        bulkAccesses: grantedAccesses,
+        maxProtectedDataPerTask: vMaxProtectedDataPerTask,
+      });
+
+    return { campaignRequest };
+  } 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 prepareEmailCampaign',
+      errorCause: error,
+    });
+  }
+};