@iexec/web3mail 0.5.2 → 0.6.0

package/src/web3mail/fetchMyContacts.ts

@@ -1,14 +1,10 @@
-import {
-  WEB3_MAIL_DAPP_ADDRESS,
-  WHITELIST_SMART_CONTRACT_ADDRESS,
-} from '../config/config.js';
 import { WorkflowError } from '../utils/errors.js';
-import { autoPaginateRequest } from '../utils/paginate.js';
-import { getValidContact } from '../utils/subgraphQuery.js';
 import { throwIfMissing } from '../utils/validators.js';
+import { fetchUserContacts } from './fetchUserContacts.js';
 import {
   Contact,
-  FetchContactsParams,
+  DappAddressConsumer,
+  DappWhitelistAddressConsumer,
   IExecConsumer,
   SubgraphConsumer,
 } from './types.js';
@@ -16,60 +12,21 @@ import {
 export const fetchMyContacts = async ({
   graphQLClient = throwIfMissing(),
   iexec = throwIfMissing(),
-  page,
-  pageSize,
-}: IExecConsumer & SubgraphConsumer & FetchContactsParams): Promise<
-  Contact[]
-> => {
+  dappAddressOrENS = throwIfMissing(),
+  dappWhitelistAddress = throwIfMissing(),
+}: IExecConsumer &
+  SubgraphConsumer &
+  DappAddressConsumer &
+  DappWhitelistAddressConsumer): Promise<Contact[]> => {
   try {
     const userAddress = await iexec.wallet.getAddress();
-    const datasetOrderbookAuthorizedBySC =
-      await iexec.orderbook.fetchDatasetOrderbook('any', {
-        app: WHITELIST_SMART_CONTRACT_ADDRESS,
-        requester: userAddress,
-        page,
-        pageSize,
-      });
-    const datasetOrderbookAuthorizedByENS =
-      await iexec.orderbook.fetchDatasetOrderbook('any', {
-        app: WEB3_MAIL_DAPP_ADDRESS,
-        requester: userAddress,
-        page,
-        pageSize,
-      });
-
-    const { orders: ensOrders } = await autoPaginateRequest({
-      request: datasetOrderbookAuthorizedByENS,
-    });
-    const { orders: scOrders } = await autoPaginateRequest({
-      request: datasetOrderbookAuthorizedBySC,
+    return await fetchUserContacts({
+      iexec,
+      graphQLClient,
+      dappAddressOrENS,
+      dappWhitelistAddress,
+      userAddress,
     });
-
-    const orders = ensOrders.concat(scOrders);
-    const myContacts: Contact[] = [];
-    const web3DappResolvedAddress = await iexec.ens.resolveName(
-      WEB3_MAIL_DAPP_ADDRESS
-    );
-
-    orders.forEach((order) => {
-      if (
-        order.order.apprestrict.toLowerCase() ===
-          web3DappResolvedAddress.toLowerCase() ||
-        order.order.apprestrict.toLowerCase() ===
-          WHITELIST_SMART_CONTRACT_ADDRESS.toLowerCase()
-      ) {
-        const contact = {
-          address: order.order.dataset.toLowerCase(),
-          owner: order.signer.toLowerCase(),
-          accessGrantTimestamp: order.publicationTimestamp,
-        };
-        myContacts.push(contact);
-      }
-    });
-
-    const validContacts = await getValidContact(graphQLClient, myContacts);
-
-    return validContacts;
   } catch (error) {
     throw new WorkflowError(
       `Failed to fetch my contacts: ${error.message}`,

package/src/web3mail/fetchUserContacts.ts

@@ -0,0 +1,105 @@
+import { ANY_DATASET_ADDRESS } from '../config/config.js';
+import { WorkflowError } from '../utils/errors.js';
+import { autoPaginateRequest } from '../utils/paginate.js';
+import { getValidContact } from '../utils/subgraphQuery.js';
+import {
+  addressOrEnsSchema,
+  addressSchema,
+  isEnsTest,
+  throwIfMissing,
+} from '../utils/validators.js';
+import {
+  Contact,
+  DappAddressConsumer,
+  DappWhitelistAddressConsumer,
+  FetchUserContactsParams,
+  IExecConsumer,
+  SubgraphConsumer,
+} from './types.js';
+
+export const fetchUserContacts = async ({
+  graphQLClient = throwIfMissing(),
+  iexec = throwIfMissing(),
+  dappAddressOrENS = throwIfMissing(),
+  dappWhitelistAddress = throwIfMissing(),
+  userAddress,
+}: IExecConsumer &
+  SubgraphConsumer &
+  DappAddressConsumer &
+  DappWhitelistAddressConsumer &
+  FetchUserContactsParams): Promise<Contact[]> => {
+  try {
+    const vDappAddressOrENS = addressOrEnsSchema()
+      .required()
+      .label('dappAddressOrENS')
+      .validateSync(dappAddressOrENS);
+    const vDappWhitelistAddress = addressSchema()
+      .required()
+      .label('dappWhitelistAddress')
+      .validateSync(dappWhitelistAddress);
+    const vUserAddress = addressOrEnsSchema()
+      .required()
+      .label('userAddress')
+      .validateSync(userAddress);
+
+    const [dappOrders, whitelistOrders] = await Promise.all([
+      fetchAllOrdersByApp({
+        iexec,
+        userAddress: vUserAddress,
+        appAddress: vDappAddressOrENS,
+      }),
+      fetchAllOrdersByApp({
+        iexec,
+        userAddress: vUserAddress,
+        appAddress: vDappWhitelistAddress,
+      }),
+    ]);
+
+    const orders = dappOrders.concat(whitelistOrders);
+    const myContacts: Contact[] = [];
+    let web3DappResolvedAddress = vDappAddressOrENS;
+    if (isEnsTest(vDappAddressOrENS)) {
+      web3DappResolvedAddress = await iexec.ens.resolveName(vDappAddressOrENS);
+    }
+    orders.forEach((order) => {
+      if (
+        order.order.apprestrict.toLowerCase() ===
+          web3DappResolvedAddress.toLowerCase() ||
+        order.order.apprestrict.toLowerCase() ===
+          vDappWhitelistAddress.toLowerCase()
+      ) {
+        const contact = {
+          address: order.order.dataset.toLowerCase(),
+          owner: order.signer.toLowerCase(),
+          accessGrantTimestamp: order.publicationTimestamp,
+        };
+        myContacts.push(contact);
+      }
+    });
+
+    //getValidContact function remove duplicated contacts for the same protectedData address,
+    //keeping the most recent one
+    return await getValidContact(graphQLClient, myContacts);
+  } catch (error) {
+    throw new WorkflowError(
+      `Failed to fetch my contacts: ${error.message}`,
+      error
+    );
+  }
+};
+
+async function fetchAllOrdersByApp({ iexec, userAddress, appAddress }) {
+  const ordersFirstPage = iexec.orderbook.fetchDatasetOrderbook(
+    ANY_DATASET_ADDRESS,
+    {
+      app: appAddress,
+      requester: userAddress,
+      // Use maxPageSize here to avoid too many round-trips (we want everything anyway)
+      pageSize: 1000,
+    }
+  );
+  const { orders: allOrders } = await autoPaginateRequest({
+    request: ordersFirstPage,
+  });
+  return allOrders;
+}

package/src/web3mail/sendEmail.ts

@@ -1,39 +1,59 @@
 import {
   DEFAULT_CONTENT_TYPE,
   MAX_DESIRED_APP_ORDER_PRICE,
+  MAX_DESIRED_DATA_ORDER_PRICE,
   MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
-  WEB3_MAIL_DAPP_ADDRESS,
-  WORKERPOOL_ADDRESS,
+  PROD_WORKERPOOL_ADDRESS,
 } from '../config/config.js';
 import { 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,
   contentTypeSchema,
   emailContentSchema,
   emailSubjectSchema,
+  labelSchema,
+  positiveNumberSchema,
   senderNameSchema,
   throwIfMissing,
 } from '../utils/validators.js';
 import {
+  DappAddressConsumer,
+  DappWhitelistAddressConsumer,
   IExecConsumer,
+  IpfsGatewayConfigConsumer,
+  IpfsNodeConfigConsumer,
   SendEmailParams,
   SendEmailResponse,
   SubgraphConsumer,
 } from './types.js';
-import * as ipfs from './../utils/ipfs-service.js';
 
 export const sendEmail = async ({
   graphQLClient = throwIfMissing(),
   iexec = throwIfMissing(),
+  workerpoolAddressOrEns = PROD_WORKERPOOL_ADDRESS,
+  dappAddressOrENS,
+  dappWhitelistAddress,
+  ipfsNode,
+  ipfsGateway,
   emailSubject,
   emailContent,
   contentType = DEFAULT_CONTENT_TYPE,
+  label,
+  dataMaxPrice = MAX_DESIRED_DATA_ORDER_PRICE,
+  appMaxPrice = MAX_DESIRED_APP_ORDER_PRICE,
+  workerpoolMaxPrice = MAX_DESIRED_WORKERPOOL_ORDER_PRICE,
   senderName,
   protectedData,
 }: IExecConsumer &
   SubgraphConsumer &
+  DappAddressConsumer &
+  DappWhitelistAddressConsumer &
+  IpfsNodeConfigConsumer &
+  IpfsGatewayConfigConsumer &
   SendEmailParams): Promise<SendEmailResponse> => {
   try {
     const vDatasetAddress = addressOrEnsSchema()
@@ -55,6 +75,28 @@ export const sendEmail = async ({
     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);
 
     // Check protected data validity through subgraph
     const isValidProtectedData = await checkProtectedDataValidity(
@@ -75,67 +117,83 @@ export const sendEmail = async ({
       await iexec.storage.pushStorageToken(token);
     }
 
-    // Fetch dataset order
-    const datasetOrderbook = await iexec.orderbook.fetchDatasetOrderbook(
-      vDatasetAddress,
-      {
-        app: WEB3_MAIL_DAPP_ADDRESS,
-        requester: requesterAddress,
-      }
-    );
-    const datasetorder = datasetOrderbook?.orders[0]?.order;
-    if (!datasetorder) {
-      throw new Error('Dataset order not found');
-    }
-
-    // Fetch app order
-    const appOrderbook = await iexec.orderbook.fetchAppOrderbook(
-      WEB3_MAIL_DAPP_ADDRESS,
-      {
-        minTag: ['tee', 'scone'],
-        maxTag: ['tee', 'scone'],
-        workerpool: WORKERPOOL_ADDRESS,
-      }
-    );
-    const appOrder = appOrderbook?.orders[0]?.order;
-    if (!appOrder) {
-      throw new Error('App order not found');
-    }
-
-    const desiredPriceAppOrderbook = appOrderbook.orders.filter(
-      (order) => order.order.appprice <= MAX_DESIRED_APP_ORDER_PRICE
-    );
-    const desiredPriceAppOrder = desiredPriceAppOrderbook[0]?.order;
-    if (!desiredPriceAppOrder) {
-      throw new Error('No App order found for the desired price');
-    }
-
-    // Fetch workerpool order
-    const workerpoolOrderbook = await iexec.orderbook.fetchWorkerpoolOrderbook({
-      workerpool: WORKERPOOL_ADDRESS,
-      app: WEB3_MAIL_DAPP_ADDRESS,
-      dataset: vDatasetAddress,
-      minTag: ['tee', 'scone'],
-      maxTag: ['tee', 'scone'],
-      category: 0,
-    });
-
-    const workerpoolorder = workerpoolOrderbook?.orders[0]?.order;
-    if (!workerpoolorder) {
-      throw new Error('Workerpool order not found');
-    }
+    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
+      iexec.orderbook
+        .fetchWorkerpoolOrderbook({
+          workerpool: workerpoolAddressOrEns,
+          app: dappAddressOrENS,
+          dataset: vDatasetAddress,
+          minTag: ['tee', 'scone'],
+          maxTag: ['tee', 'scone'],
+          category: 0,
+        })
+        .then((workerpoolOrderbook) => {
+          const desiredPriceWorkerpoolOrderbook =
+            workerpoolOrderbook.orders.filter(
+              (order) => order.order.workerpoolprice <= vWorkerpoolMaxPrice
+            );
+          const randomIndex = Math.floor(
+            Math.random() * desiredPriceWorkerpoolOrderbook.length
+          );
+          const desiredPriceWorkerpoolOrder =
+            desiredPriceWorkerpoolOrderbook[randomIndex]?.order;
+          if (!desiredPriceWorkerpoolOrder) {
+            throw new Error('No Workerpool order found for the desired price');
+          }
+          return desiredPriceWorkerpoolOrder;
+        }),
+    ]);
 
-    const desiredPriceWorkerpoolOrderbook = workerpoolOrderbook.orders.filter(
-      (order) =>
-        order.order.workerpoolprice <= MAX_DESIRED_WORKERPOOL_ORDER_PRICE
-    );
-    const randomIndex = Math.floor(
-      Math.random() * desiredPriceWorkerpoolOrderbook.length
-    );
-    const desiredPriceWorkerpoolOrder =
-      desiredPriceWorkerpoolOrderbook[randomIndex]?.order;
-    if (!desiredPriceWorkerpoolOrder) {
-      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
@@ -146,9 +204,14 @@ export const sendEmail = async ({
       .catch((e) => {
         throw new WorkflowError('Failed to encrypt email content', e);
       });
-    const cid = await ipfs.add(encryptedFile).catch((e) => {
-      throw new WorkflowError('Failed to upload encrypted email content', e);
-    });
+    const cid = await ipfs
+      .add(encryptedFile, {
+        ipfsNode: ipfsNode,
+        ipfsGateway: ipfsGateway,
+      })
+      .catch((e) => {
+        throw new WorkflowError('Failed to upload encrypted email content', e);
+      });
     const multiaddr = `/ipfs/${cid}`;
 
     await iexec.secrets.pushRequesterSecret(
@@ -163,27 +226,29 @@ export const sendEmail = async ({
     );
 
     const requestorderToSign = await iexec.order.createRequestorder({
-      app: WEB3_MAIL_DAPP_ADDRESS,
-      category: desiredPriceWorkerpoolOrder.category,
+      app: vDappAddressOrENS,
+      category: workerpoolorder.category,
       dataset: vDatasetAddress,
-      appmaxprice: desiredPriceAppOrder.appprice,
-      workerpoolmaxprice: desiredPriceWorkerpoolOrder.workerpoolprice,
+      datasetmaxprice: datasetorder.datasetprice,
+      appmaxprice: apporder.appprice,
+      workerpoolmaxprice: workerpoolorder.workerpoolprice,
       tag: ['tee', 'scone'],
-      workerpool: WORKERPOOL_ADDRESS,
+      workerpool: vWorkerpoolAddressOrEns,
       params: {
         iexec_developer_logger: true,
         iexec_secrets: {
           1: requesterSecretId,
         },
+        iexec_args: vLabel,
       },
     });
     const requestorder = await iexec.order.signRequestorder(requestorderToSign);
 
     // Match orders and compute task ID
     const { dealid } = await iexec.order.matchOrders({
-      apporder: desiredPriceAppOrder,
+      apporder: apporder,
       datasetorder: datasetorder,
-      workerpoolorder: desiredPriceWorkerpoolOrder,
+      workerpoolorder: workerpoolorder,
       requestorder: requestorder,
     });
     const taskId = await iexec.deal.computeTaskId(dealid, 0);

package/src/web3mail/types.ts

@@ -1,5 +1,6 @@
 import { GraphQLClient } from 'graphql-request';
 import { EnhancedWallet, IExec } from 'iexec';
+import { IExecConfigOptions } from 'iexec/IExecConfig';
 
 export type Web3SignerProvider = EnhancedWallet;
 
@@ -7,6 +8,10 @@ export type IExecConsumer = {
   iexec: IExec;
 };
 
+export type ENS = string;
+
+export type AddressOrENS = Address | ENS;
+
 export type Address = string;
 
 export type TimeStamp = string;
@@ -16,24 +21,27 @@ export type Contact = {
   owner: Address;
   accessGrantTimestamp: TimeStamp;
 };
+
 export type SendEmailParams = {
   emailSubject: string;
   emailContent: string;
   protectedData: Address;
   contentType?: string;
   senderName?: string;
+  label?: string;
+  workerpoolAddressOrEns?: AddressOrENS;
+  dataMaxPrice?: number;
+  appMaxPrice?: number;
+  workerpoolMaxPrice?: number;
 };
 
-export type FetchContactsParams = {
-  /**
-   * Index of the page to fetch
-   */
-  page?: number;
+export type FetchUserContactsParams = {
   /**
-   * Size of the page to fetch
+   * Address of the user
    */
-  pageSize?: number;
+  userAddress: Address;
 };
+
 export type SendEmailResponse = {
   taskId: Address;
 };
@@ -52,3 +60,60 @@ export type GraphQLResponse = {
 export type SubgraphConsumer = {
   graphQLClient: GraphQLClient;
 };
+
+/**
+ * Configuration options for Web3Mail.
+ */
+export type Web3MailConfigOptions = {
+  /**
+   * The Ethereum contract address or ENS (Ethereum Name Service) for the email sender dapp.
+   * If not provided, the default web3mail address will be used.
+   */
+  dappAddressOrENS?: AddressOrENS;
+
+  /**
+   * The Ethereum contract address for the whitelist.
+   * If not provided, the default whitelist smart contract address will be used.
+   */
+  dappWhitelistAddress?: Address;
+
+  /**
+   * The subgraph URL for querying data.
+   * If not provided, the default data protector subgraph URL will be used.
+   */
+  dataProtectorSubgraph?: string;
+
+  /**
+   * Options specific to iExec integration.
+   * If not provided, default iexec options will be used.
+   */
+  iexecOptions?: IExecConfigOptions;
+
+  /**
+   * The IPFS node URL.
+   * If not provided, the default IPFS node URL will be used.
+   */
+  ipfsNode?: string;
+
+  /**
+   * The IPFS gateway URL.
+   * If not provided, the default IPFS gateway URL will be used.
+   */
+  ipfsGateway?: string;
+};
+
+export type DappAddressConsumer = {
+  dappAddressOrENS: AddressOrENS;
+};
+
+export type IpfsNodeConfigConsumer = {
+  ipfsNode: string;
+};
+
+export type IpfsGatewayConfigConsumer = {
+  ipfsGateway: string;
+};
+
+export type DappWhitelistAddressConsumer = {
+  dappWhitelistAddress: string;
+};