Migrate 00_matchorders.js file - part 2 (#113)

Author: zguesmi

CHANGELOG.md

@@ -6,7 +6,7 @@
 - Migrate unit test files to Typescript & Hardhat:
     - IexecPoco2
         - contribute (#108, #109, #110)
-    - IexecPoco/00_matchorders.js (#107)
+    - IexecPoco1 (#107, #113)
     - Add `.test` suffix to unit test files (#106)
     - ENSIntegration (#105)
     - IexecOrderManagement (#101, #102, #103, #104)

test/byContract/IexecPoco/IexecPoco1.test.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2020-2024 IEXEC BLOCKCHAIN TECH <[email protected]>
 // SPDX-License-Identifier: Apache-2.0
 
+import { AddressZero } from '@ethersproject/constants';
 import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
 import { ethers, expect } from 'hardhat';
@@ -9,8 +10,11 @@ import {
     IexecInterfaceNative,
     IexecInterfaceNative__factory,
     IexecPocoAccessors__factory,
+    TestClient,
+    TestClient__factory,
 } from '../../../typechain';
 import {
+    IexecOrders,
     OrdersActors,
     OrdersAssets,
     OrdersPrices,
@@ -21,7 +25,7 @@ import { getDealId, getIexecAccounts, setNextBlockTimestamp } from '../../../uti
 import { IexecWrapper } from '../../utils/IexecWrapper';
 
 /*
- * TODO add TEE tests
+ * TODO add Standard tests.
  */
 
 const appPrice = 1000;
@@ -54,6 +58,9 @@ describe('IexecPoco1', () => {
     let ordersActors: OrdersActors;
     let ordersAssets: OrdersAssets;
     let ordersPrices: OrdersPrices;
+    let orders: IexecOrders;
+    let randomAddress: string;
+    let randomContract: TestClient;
 
     beforeEach('Deploy', async () => {
         // Deploy all contracts
@@ -94,6 +101,23 @@ describe('IexecPoco1', () => {
             dataset: datasetPrice,
             workerpool: workerpoolPrice,
         };
+        ({ orders } = buildOrders({
+            assets: ordersAssets,
+            prices: ordersPrices,
+            requester: requester.address,
+            beneficiary: beneficiary.address,
+            tag: teeDealTag,
+            volume: volume,
+            callback: callback,
+            trust: trust,
+            category: category,
+            params: params,
+        }));
+        randomAddress = ethers.Wallet.createRandom().address;
+        randomContract = await new TestClient__factory()
+            .connect(anyone)
+            .deploy()
+            .then((contract) => contract.deployed());
         // TODO check why this is done in 00_matchorders.js
         // await Workerpool__factory.connect(workerpoolAddress, scheduler)
         //     .changePolicy(35, 5)
@@ -106,13 +130,15 @@ describe('IexecPoco1', () => {
     describe('Verify presignature or signature', () => {});
 
     describe('Match orders', () => {
-        it('Should match orders with all assets (Standard)', async () => {
+        it('[TEE] Should match orders with all assets, callback, and BoT', async () => {
+            // Recreate orders here instead of using the default ones created
+            // in beforeEach to make this test as explicit as possible.
             const { orders } = buildOrders({
                 assets: ordersAssets,
+                prices: ordersPrices,
                 requester: requester.address,
                 beneficiary: beneficiary.address,
-                tag: standardDealTag,
-                prices: ordersPrices,
+                tag: teeDealTag,
                 volume: volume,
                 callback: callback,
                 trust: trust,
@@ -158,16 +184,6 @@ describe('IexecPoco1', () => {
                 dealId,
             );
             const tx = iexecPocoAsRequester.matchOrders(...orders.toArray());
-            await expect(tx)
-                .to.emit(iexecPoco, 'OrdersMatched')
-                .withArgs(
-                    dealId,
-                    appOrderHash,
-                    datasetOrderHash,
-                    workerpoolOrderHash,
-                    requestOrderHash,
-                    volume,
-                );
             // Check balances and frozen after.
             await expect(tx).to.changeTokenBalances(
                 iexecPoco,
@@ -178,6 +194,17 @@ describe('IexecPoco1', () => {
             // See https://github.com/NomicFoundation/hardhat/blob/main/packages/hardhat-chai-matchers/src/internal/changeTokenBalance.ts#L42
             expect(await iexecPoco.frozenOf(requester.address)).to.equal(dealPrice);
             expect(await iexecPoco.frozenOf(scheduler.address)).to.equal(schedulerStake);
+            // Check events.
+            await expect(tx)
+                .to.emit(iexecPoco, 'OrdersMatched')
+                .withArgs(
+                    dealId,
+                    appOrderHash,
+                    datasetOrderHash,
+                    workerpoolOrderHash,
+                    requestOrderHash,
+                    volume,
+                );
             // Check deal
             const deal = await iexecPoco.viewDeal(dealId);
             expect(deal.app.pointer).to.equal(appAddress);
@@ -191,7 +218,7 @@ describe('IexecPoco1', () => {
             expect(deal.workerpool.price.toNumber()).to.equal(workerpoolPrice);
             expect(deal.trust.toNumber()).to.equal(trust);
             expect(deal.category.toNumber()).to.equal(category);
-            expect(deal.tag).to.equal(standardDealTag);
+            expect(deal.tag).to.equal(teeDealTag);
             expect(deal.requester).to.equal(requester.address);
             expect(deal.beneficiary).to.equal(beneficiary.address);
             expect(deal.callback).to.equal(callback);
@@ -204,10 +231,222 @@ describe('IexecPoco1', () => {
             expect(deal.sponsor).to.equal(requester.address);
         });
 
-        it('[TODO] Should match orders with all assets and callback (Standard)', () => {});
-        it('[TODO] Should match orders without dataset (Standard)', () => {});
-        it('[TODO] Should match orders without dataset and with callback (Standard)', () => {});
+        it('[TEE] Should match orders without callback', async () => {
+            orders.requester.callback = AddressZero;
+            await depositForRequesterAndSchedulerWithDefaultPrices();
+            // Sign and match orders.
+            await signOrders(iexecWrapper.getDomain(), orders, ordersActors);
+            const dealId = getDealId(iexecWrapper.getDomain(), orders.requester, taskIndex);
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.emit(
+                iexecPoco,
+                'OrdersMatched',
+            );
+            // Check deal
+            const deal = await iexecPoco.viewDeal(dealId);
+            expect(deal.callback).to.equal(AddressZero);
+        });
+
+        it('[TEE] Should match orders without dataset', async () => {
+            orders.dataset.dataset = AddressZero;
+            orders.requester.dataset = AddressZero;
+            // Set dataset volume lower than other assets to make sure
+            // it does not impact final volume computation.
+            orders.dataset.volume = volume - 1;
+            // Compute prices, stakes, rewards, ...
+            const dealPrice = (appPrice + workerpoolPrice) * volume; // no dataset price
+            const schedulerStake = await iexecWrapper.computeSchedulerDealStake(
+                workerpoolPrice,
+                volume,
+            );
+            // Deposit required amounts.
+            await iexecWrapper.depositInIexecAccount(requester, dealPrice);
+            await iexecWrapper.depositInIexecAccount(scheduler, schedulerStake);
+            // Sign and match orders.
+            await signOrders(iexecWrapper.getDomain(), orders, ordersActors);
+            const dealId = getDealId(iexecWrapper.getDomain(), orders.requester, taskIndex);
+            const tx = iexecPocoAsRequester.matchOrders(...orders.toArray());
+            // Check balances and frozen.
+            // Dataset price shouldn't be included.
+            await expect(tx).to.changeTokenBalances(
+                iexecPoco,
+                [iexecPoco, requester, scheduler],
+                [dealPrice + schedulerStake, -dealPrice, -schedulerStake],
+            );
+            expect(await iexecPoco.frozenOf(requester.address)).to.equal(dealPrice);
+            // Check events.
+            await expect(tx).to.emit(iexecPoco, 'OrdersMatched');
+            // Check deal
+            const deal = await iexecPoco.viewDeal(dealId);
+            expect(deal.dataset.pointer).to.equal(AddressZero);
+            expect(deal.dataset.owner).to.equal(AddressZero);
+            expect(deal.dataset.price.toNumber()).to.equal(0);
+            // BoT size should not be impacted even if the dataset order is the order with the lowest volume
+            expect(deal.botSize.toNumber()).to.equal(volume);
+        });
+
+        it('[TODO][TEE] Should match orders with restrictions', async () => {});
+
+        it('[TEE] Should fail when categories are different', async () => {
+            orders.requester.category = category + 1; // Valid but different category.
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x00',
+            );
+        });
+
+        it('[TEE] Should fail when category is unknown', async () => {
+            const lastCategoryIndex = (await iexecPoco.countCategory()).toNumber() - 1;
+            orders.requester.category = lastCategoryIndex + 1;
+            orders.workerpool.category = lastCategoryIndex + 1;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x01',
+            );
+        });
+
+        it('[TEE] Should fail when requested trust is above workerpool trust', async () => {
+            orders.requester.trust = Number(orders.workerpool.trust) + 1;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x02',
+            );
+        });
+
+        it('[TEE] Should fail when app max price is less than app price', async () => {
+            orders.requester.appmaxprice = Number(orders.app.appprice) - 1;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x03',
+            );
+        });
+
+        it('[TEE] Should fail when dataset max price is less than dataset price', async () => {
+            orders.requester.datasetmaxprice = Number(orders.dataset.datasetprice) - 1;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x04',
+            );
+        });
+
+        it('[TEE] Should fail when workerpool max price is less than workerpool price', async () => {
+            orders.requester.workerpoolmaxprice = Number(orders.workerpool.workerpoolprice) - 1;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x05',
+            );
+        });
+
+        it('[TEE] Should fail when workerpool tag does not satisfy app, dataset and request requirements', async () => {
+            orders.app.tag = '0x0000000000000000000000000000000000000000000000000000000000000001'; // 0b0001
+            orders.dataset.tag =
+                '0x0000000000000000000000000000000000000000000000000000000000000002'; // 0b0010
+            orders.requester.tag =
+                '0x0000000000000000000000000000000000000000000000000000000000000003'; // 0b0011
+            // Workerpool order is supposed to satisfy conditions of all actors.
+            // Bad tag, correct tag should be 0b0011.
+            orders.workerpool.tag =
+                '0x0000000000000000000000000000000000000000000000000000000000000004'; // 0b0100
+            // Match orders.
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x06',
+            );
+        });
+
+        it('[TEE] Should fail when the last bit of app tag does not satisfy dataset or request requirements', async () => {
+            // The last bit of dataset and request tag is 1, but app tag does not set it
+            orders.app.tag = '0x0000000000000000000000000000000000000000000000000000000000000002'; // 0b0010
+            orders.dataset.tag =
+                '0x0000000000000000000000000000000000000000000000000000000000000003'; // 0b0011
+            orders.requester.tag =
+                '0x0000000000000000000000000000000000000000000000000000000000000003'; // 0b0011
+            // Set the workerpool tag in a way to pass first tag check.
+            orders.workerpool.tag =
+                '0x0000000000000000000000000000000000000000000000000000000000000003'; // 0b0011
+            // Match orders.
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x07',
+            );
+        });
+
+        it('[TEE] Should fail when apps are different', async () => {
+            orders.requester.app = randomAddress;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x10',
+            );
+        });
+
+        it('[TEE] Should fail when datasets are different', async () => {
+            orders.requester.dataset = randomAddress;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x11',
+            );
+        });
+
+        it('[TEE] Should fail when request order workerpool mismatches workerpool order workerpool (EOA, SC)', async () => {
+            orders.requester.workerpool = randomAddress;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x12',
+            );
+            orders.requester.workerpool = randomContract.address;
+            await expect(iexecPocoAsRequester.matchOrders(...orders.toArray())).to.be.revertedWith(
+                'iExecV5-matchOrders-0x12',
+            );
+        });
+
+        /**
+         * Dynamically generated tests for all different restrictions in orders
+         * (requesterrestrict, apprestrict, workerpoolrestrict, datasetrestrict).
+         */
+        const revertMessages: { [key: string]: { [key: string]: string } } = {
+            app: {
+                dataset: 'iExecV5-matchOrders-0x13',
+                workerpool: 'iExecV5-matchOrders-0x14',
+                requester: 'iExecV5-matchOrders-0x15',
+            },
+            dataset: {
+                app: 'iExecV5-matchOrders-0x16',
+                workerpool: 'iExecV5-matchOrders-0x17',
+                requester: 'iExecV5-matchOrders-0x18',
+            },
+            workerpool: {
+                app: 'iExecV5-matchOrders-0x19',
+                dataset: 'iExecV5-matchOrders-0x1a',
+                requester: 'iExecV5-matchOrders-0x1b',
+            },
+        };
+        ['app', 'workerpool', 'dataset'].forEach((orderName) => {
+            // No request order
+            ['requester', 'app', 'workerpool', 'dataset'].forEach((assetName) => {
+                // Filter irrelevant cases. E.g. no need to change the app address in the app order.
+                if (orderName.includes(assetName)) {
+                    return;
+                }
+                it(`[TEE] Should fail when ${orderName} order mismatch ${assetName} restriction (EOA, SC)`, async function () {
+                    const message = revertMessages[orderName][assetName];
+                    // EOA
+                    orders[orderName][assetName + 'restrict'] = randomAddress; // e.g. orders['app']['apprestrict'] = 0xEOA
+                    await expect(iexecPoco.matchOrders(...orders.toArray())).to.be.revertedWith(
+                        message,
+                    );
+                    // SC
+                    orders[orderName][assetName + 'restrict'] = randomContract.address; // e.g. orders['app']['apprestrict'] = 0xSC
+                    await expect(iexecPoco.matchOrders(...orders.toArray())).to.be.revertedWith(
+                        message,
+                    );
+                });
+            });
+        });
+
         it('[TODO] Should match orders with replication', () => {});
     });
     describe('[TODO] Sponsor match orders', () => {});
+
+    /**
+     * Helper function to deposit requester and scheduler stakes with
+     * default prices for tests that do not rely on price changes.
+     */
+    async function depositForRequesterAndSchedulerWithDefaultPrices() {
+        const dealPrice = (appPrice + datasetPrice + workerpoolPrice) * volume;
+        const schedulerStake = await iexecWrapper.computeSchedulerDealStake(
+            workerpoolPrice,
+            volume,
+        );
+        // Deposit required amounts.
+        await iexecWrapper.depositInIexecAccount(requester, dealPrice);
+        await iexecWrapper.depositInIexecAccount(scheduler, schedulerStake);
+    }
 });