fix: allow TEE datasetorders without framework

src/common/execution/order-helper.js

@@ -26,7 +26,7 @@ import {
 import { resolveTeeFrameworkFromApp, showApp } from '../protocol/registries.js';
 
 export const resolveTeeFrameworkFromTag = async (tag) => {
-  const vTag = await tagSchema().validate(tag);
+  const vTag = await tagSchema({ allowAgnosticTee: true }).validate(tag);
   if (checkActiveBitInTag(vTag, TAG_MAP[TEE_FRAMEWORKS.SCONE])) {
     return TEE_FRAMEWORKS.SCONE;
   }

src/common/market/order.js

@@ -1129,7 +1129,7 @@ export const createDatasetorder = async (
     .validate(dataset),
   datasetprice: await nRlcAmountSchema().validate(datasetprice),
   volume: await uint256Schema().validate(volume),
-  tag: await tagSchema().validate(tag),
+  tag: await tagSchema({ allowAgnosticTee: true }).validate(tag),
   apprestrict: await addressSchema({
     ethProvider: contracts.provider,
   }).validate(apprestrict),

src/common/utils/validator.js

@@ -369,7 +369,7 @@ export const paramsSchema = () =>
       },
     );
 
-export const tagSchema = () =>
+export const tagSchema = ({ allowAgnosticTee = false } = {}) =>
   mixed()
     .transform((value) => {
       if (Array.isArray(value)) {
@@ -424,7 +424,7 @@ export const tagSchema = () =>
         );
         try {
           if (isTee) {
-            if (teeFrameworks.length < 1) {
+            if (!allowAgnosticTee && teeFrameworks.length < 1) {
               throw new Error(
                 `'tee' tag must be used with a tee framework (${Object.values(
                   TEE_FRAMEWORKS,
@@ -486,7 +486,7 @@ export const datasetorderSchema = (opt) =>
       dataset: addressSchema(opt).required(),
       datasetprice: nRlcAmountSchema().required(),
       volume: uint256Schema().required(),
-      tag: tagSchema().required(),
+      tag: tagSchema({ allowAgnosticTee: true }).required(),
       apprestrict: addressSchema(opt).required(),
       workerpoolrestrict: addressSchema(opt).required(),
       requesterrestrict: addressSchema(opt).required(),

test/lib/e2e/IExecOrderModule.test.js

@@ -113,15 +113,15 @@ describe('order', () => {
         apprestrict,
         workerpoolrestrict,
         requesterrestrict,
-        tag: ['tee', 'scone'],
+        tag: ['tee'],
         volume: 100,
       });
       expect(order).toEqual({
         dataset,
         datasetprice: '1000000000',
         apprestrict,
         requesterrestrict,
-        tag: '0x0000000000000000000000000000000000000000000000000000000000000003',
+        tag: '0x0000000000000000000000000000000000000000000000000000000000000001',
         volume: '100',
         workerpoolrestrict,
       });
@@ -384,6 +384,13 @@ describe('signDatasetorder()', () => {
     const order = await iexec.order.createDatasetorder({
       dataset: address,
     });
+    await expect(
+      iexec.order.signDatasetorder({ ...order, tag: ['tee'] }),
+    ).rejects.toThrow(
+      new Error(
+        `Dataset encryption key is not set for dataset ${address} in the SMS. Dataset decryption will fail.`,
+      ),
+    );
     await expect(
       iexec.order.signDatasetorder({ ...order, tag: ['tee', 'scone'] }),
     ).rejects.toThrow(
@@ -395,6 +402,9 @@ describe('signDatasetorder()', () => {
       address,
       iexec.dataset.generateEncryptionKey(),
     );
+    await expect(
+      iexec.order.signDatasetorder({ ...order, tag: ['tee'] }),
+    ).resolves.toBeDefined();
     await expect(
       iexec.order.signDatasetorder({ ...order, tag: ['tee', 'scone'] }),
     ).resolves.toBeDefined();
@@ -412,13 +422,6 @@ describe('signDatasetorder()', () => {
     const order = await iexec.order.createDatasetorder({
       dataset: getRandomAddress(),
     });
-    await expect(
-      iexec.order.signDatasetorder({ ...order, tag: ['tee'] }),
-    ).rejects.toThrow(
-      new Error(
-        "'tee' tag must be used with a tee framework ('scone'|'gramine')",
-      ),
-    );
     await expect(
       iexec.order.signDatasetorder({ ...order, tag: ['scone'] }),
     ).rejects.toThrow(Error("'scone' tag must be used with 'tee' tag"));
@@ -883,7 +886,7 @@ describe('publish...order()', () => {
     test('preflightChecks dataset secret exists for tee tag', async () => {
       const { iexec } = getTestConfig(iexecTestChain)();
       const datasetorder = await deployAndGetDatasetorder(iexec, {
-        tag: ['tee', 'scone'],
+        tag: ['tee'],
       });
       const datasetAddress = datasetorder.dataset;
       await expect(
@@ -2456,7 +2459,7 @@ describe('matchOrders()', () => {
     });
     const teeDatasetorder = await deployAndGetDatasetorder(
       iexecResourcesProvider,
-      { tag: ['tee', 'scone'] },
+      { tag: ['tee'] },
     );
     const teeWorkerpoolorder = await deployAndGetWorkerpoolorder(
       iexecResourcesProvider,

test/lib/unit/validator.test.js

@@ -865,6 +865,12 @@ describe('[tagSchema]', () => {
     ).rejects.toThrow(
       new ValidationError("'gramine' tag must be used with 'tee' tag"),
     );
+    const agnosticTeeTag = await tagSchema({ allowAgnosticTee: true }).validate(
+      ['tee'],
+    );
+    expect(agnosticTeeTag).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+    );
     await expect(tagSchema().validate('tee,gramine,scone')).rejects.toThrow(
       new ValidationError(
         "tee framework tags are exclusive ('scone'|'gramine')",