fix!: ensure iapp exit 0 and update outputs

- App always create result files
- upon success `result.json` contains `"success": true` (rather than `"status": 200`)
- upon failure `result.json` contains `"success": false` and the error message in `"error"`

Author: PierreJeanjacquot

dapp/.gitignore

@@ -1,3 +1,4 @@
 .env
 node_modules
 coverage
+tests/_test_outputs_

dapp/src/app.js

@@ -1,4 +1,4 @@
-const start = require('./sendEmail');
+const start = require('./executeTask');
 
 start().catch((error) => {
   console.error(`Error: ${error.message}`);

dapp/src/checkEmailPreviousValidation.js

@@ -1,10 +1,12 @@
 const { request, gql } = require('graphql-request');
 
+// TODO: the method could return true if valid, false if invalid, null if no prior validation or unable to check
 async function checkEmailPreviousValidation({
   datasetAddress,
   dappAddresses,
   pocoSubgraphUrl,
 }) {
+  // TODO: add check in bulk task
   const query = gql`
     query checkSuccessfulTaskQuery($apps: [String!], $dataset: String!) {
       tasks(

dapp/src/emailService.js

@@ -40,9 +40,5 @@ async function sendEmail({
     .catch(() => {
       throw new Error('Failed to send email');
     });
-  return {
-    message: 'Your email has been sent successfully.',
-    status: 200,
-  };
 }
 module.exports = sendEmail;

dapp/src/executeTask.js

@@ -0,0 +1,218 @@
+const { promises: fs } = require('fs');
+const {
+  IExecDataProtectorDeserializer,
+} = require('@iexec/dataprotector-deserializer');
+const sendEmail = require('./emailService');
+const {
+  validateWorkerEnv,
+  validateAppSecret,
+  validateRequesterSecret,
+  validateProtectedData,
+} = require('./validation');
+const {
+  downloadEncryptedContent,
+  decryptContent,
+} = require('./decryptEmailContent');
+const { validateEmailAddress } = require('./validateEmailAddress');
+const {
+  checkEmailPreviousValidation,
+} = require('./checkEmailPreviousValidation');
+
+async function processProtectedData({
+  index,
+  IEXEC_IN,
+  appDeveloperSecret,
+  requesterSecret,
+}) {
+  const datasetFilename =
+    index > 0
+      ? process.env[`IEXEC_DATASET_${index}_FILENAME`]
+      : process.env.IEXEC_DATASET_FILENAME;
+  const result = { index, protectedData: datasetFilename };
+  try {
+    let protectedData;
+    try {
+      const deserializerConfig = datasetFilename
+        ? { protectedDataPath: `${IEXEC_IN}/${datasetFilename}` }
+        : {};
+      const deserializer = new IExecDataProtectorDeserializer(
+        deserializerConfig
+      );
+      protectedData = {
+        email: await deserializer.getValue('email', 'string'),
+      };
+    } catch (e) {
+      throw Error(`Failed to parse ProtectedData ${index}: ${e.message}`);
+    }
+
+    // Validate the protected data
+    validateProtectedData(protectedData);
+
+    // Step 1: Check if email was already validated
+    const isEmailValid = await checkEmailPreviousValidation({
+      datasetAddress: protectedData.email,
+      dappAddresses: appDeveloperSecret.WEB3MAIL_WHITELISTED_APPS,
+      pocoSubgraphUrl: appDeveloperSecret.POCO_SUBGRAPH_URL,
+    });
+
+    // Step 2: If not, try Mailgun
+    if (!isEmailValid) {
+      console.log('No prior verification found. Trying Mailgun...');
+      const mailgunResult = await validateEmailAddress({
+        emailAddress: protectedData.email,
+        mailgunApiKey: appDeveloperSecret.MAILGUN_APIKEY,
+      });
+
+      if (mailgunResult === true) {
+        result.isEmailValid = true;
+      } else if (mailgunResult === false) {
+        result.isEmailValid = false;
+        throw Error('The protected email address seems to be invalid.');
+      } else {
+        console.warn(
+          'Mailgun verification failed or was unreachable. Proceeding without check.'
+        );
+      }
+    } else {
+      result.isEmailValid = true;
+      console.log('Email already verified, skipping Mailgun check.');
+    }
+
+    // Step 3: Decrypt email content
+    const encryptedEmailContent = await downloadEncryptedContent(
+      requesterSecret.emailContentMultiAddr
+    );
+    const requesterEmailContent = decryptContent(
+      encryptedEmailContent,
+      requesterSecret.emailContentEncryptionKey
+    );
+
+    // Step 4: Send email
+    await sendEmail({
+      email: protectedData.email,
+      mailJetApiKeyPublic: appDeveloperSecret.MJ_APIKEY_PUBLIC,
+      mailJetApiKeyPrivate: appDeveloperSecret.MJ_APIKEY_PRIVATE,
+      mailJetSender: appDeveloperSecret.MJ_SENDER,
+      mailgunApiKey: appDeveloperSecret.MAILGUN_APIKEY,
+      emailContent: requesterEmailContent,
+      emailSubject: requesterSecret.emailSubject,
+      contentType: requesterSecret.contentType,
+      senderName: requesterSecret.senderName,
+    });
+    result.success = true;
+  } catch (e) {
+    result.success = false;
+    result.error = e.message;
+  }
+  console.log(`Protected data ${index} processed:`, result);
+  return result;
+}
+
+async function start() {
+  const {
+    IEXEC_IN,
+    IEXEC_OUT,
+    IEXEC_APP_DEVELOPER_SECRET,
+    IEXEC_REQUESTER_SECRET_1,
+    IEXEC_BULK_SLICE_SIZE,
+  } = process.env;
+
+  // Check worker env
+  const workerEnv = validateWorkerEnv({ IEXEC_OUT });
+
+  let result; // { success: boolean, error?: string, protectedData?: string, results?: { index: number, protectedData: string, success: boolean, error?: string }[] }
+  let callbackData;
+  try {
+    // Parse the app developer secret environment variable
+    let appDeveloperSecret;
+    try {
+      appDeveloperSecret = JSON.parse(IEXEC_APP_DEVELOPER_SECRET);
+      appDeveloperSecret.WEB3MAIL_WHITELISTED_APPS =
+        appDeveloperSecret.WEB3MAIL_WHITELISTED_APPS
+          ? JSON.parse(appDeveloperSecret.WEB3MAIL_WHITELISTED_APPS)
+          : undefined;
+    } catch {
+      throw Error('Failed to parse the developer secret');
+    }
+    appDeveloperSecret = validateAppSecret(appDeveloperSecret);
+
+    let requesterSecret;
+    try {
+      requesterSecret = JSON.parse(IEXEC_REQUESTER_SECRET_1);
+    } catch {
+      throw Error('Failed to parse requester secret');
+    }
+    requesterSecret = validateRequesterSecret(requesterSecret);
+
+    const bulkSize = parseInt(IEXEC_BULK_SLICE_SIZE, 10) || 0;
+
+    // Process multiple protected data
+    if (bulkSize > 0) {
+      console.log(`Processing ${bulkSize} protected data...`);
+      const processPromises = new Array(bulkSize).fill(null).map((_, index) =>
+        processProtectedData({
+          index: index + 1,
+          IEXEC_IN,
+          appDeveloperSecret,
+          requesterSecret,
+        })
+      );
+      const results = await Promise.all(processPromises);
+      const successCount = results.filter((r) => r.success === true).length;
+      const errorCount = results.filter((r) => r.success !== true).length;
+      result = {
+        success: errorCount === 0,
+        error: errorCount > 0 ? 'Partial failure' : undefined,
+        totalCount: results.length,
+        successCount,
+        errorCount,
+        results: results.map((r) => ({
+          index: r.index,
+          protectedData: r.protectedData,
+          success: r.success,
+          error: r.error,
+        })),
+      };
+    } else {
+      console.log('Processing single protected data...');
+      const { protectedData, success, error, isEmailValid } =
+        await processProtectedData({
+          index: 0,
+          IEXEC_IN,
+          appDeveloperSecret,
+          requesterSecret,
+        });
+
+      // Add callback data for single processing if useCallback is enabled
+      if (requesterSecret.useCallback && isEmailValid !== undefined) {
+        const bool32Bytes = Buffer.alloc(32);
+        if (isEmailValid) {
+          bool32Bytes[31] = 1; // set last byte to 1 for true
+        }
+        callbackData = `0x${bool32Bytes.toString('hex')}`;
+      }
+      result = { protectedData, success, error };
+    }
+  } catch (e) {
+    console.error('Something went wrong:', e.message);
+    result = { success: false, error: e.message };
+  }
+
+  console.log('Writing results:', JSON.stringify(result));
+  await fs.writeFile(
+    `${workerEnv.IEXEC_OUT}/result.json`,
+    JSON.stringify(result, null, 2)
+  );
+
+  const computedData = {
+    'deterministic-output-path': `${workerEnv.IEXEC_OUT}/result.json`,
+    'callback-data': callbackData,
+  };
+
+  await fs.writeFile(
+    `${workerEnv.IEXEC_OUT}/computed.json`,
+    JSON.stringify(computedData, null, 2)
+  );
+}
+
+module.exports = start;