Merge branch 'develop' of https://github.com/eea-oasis/baseline into …

…815-sri-add-the-verifirersol-as-an-zkp-artifact-to-the-bpi-and-env
ethereum-oasis-op · Jul 22, 2024 · 1a977e2 · 1a977e2
2 parents 83b6b82 + e8e7208
commit 1a977e2
Show file tree

Hide file tree

Showing 5 changed files with 57 additions and 48 deletions.
diff --git a/examples/bri-3/ccsm/contracts/CcsmBpiStateAnchor.sol b/examples/bri-3/ccsm/contracts/CcsmBpiStateAnchor.sol
@@ -5,7 +5,7 @@ import '@openzeppelin/contracts/access/AccessControl.sol';
 
 contract CcsmBpiStateAnchor is AccessControl {
   mapping(string => string) public anchorHashStore;
-  event AnchorHashSet(string indexed workgroupId, string anchorHash);
+  event AnchorHashSet(string indexed workstepInstanceId, string anchorHash);
 
   bytes32 public constant ADMIN_ROLE = keccak256('ADMIN_ROLE');
 
@@ -18,29 +18,32 @@ contract CcsmBpiStateAnchor is AccessControl {
   }
 
   function setAnchorHash(
-    string calldata _workgroupId,
+    string calldata _workstepInstanceId,
     string calldata _anchorHash
   ) external onlyAdmin {
-    require(bytes(_workgroupId).length > 0, 'WorkgroupId cannot be empty');
     require(
-      bytes(_workgroupId).length < 36,
-      'WorkgroupId cannot exceed 36 bytes'
+      bytes(_workstepInstanceId).length > 0,
+      'WorkstepInstanceId cannot be empty'
+    );
+    require(
+      bytes(_workstepInstanceId).length < 36,
+      'WorkstepInstanceId cannot exceed 36 bytes'
     );
     require(bytes(_anchorHash).length > 0, 'AnchorHash cannot be empty');
     require(
       bytes(_anchorHash).length <= 256,
       'AnchorHash cannot exceed 256 bytes'
     );
 
-    anchorHashStore[_workgroupId] = _anchorHash;
+    anchorHashStore[_workstepInstanceId] = _anchorHash;
 
-    emit AnchorHashSet(_workgroupId, _anchorHash);
+    emit AnchorHashSet(_workstepInstanceId, _anchorHash);
   }
 
   function getAnchorHash(
-    string calldata _workgroupId
+    string calldata _workstepInstanceId
   ) external view returns (string memory) {
-    return anchorHashStore[_workgroupId];
+    return anchorHashStore[_workstepInstanceId];
   }
 
   modifier onlyAdmin() {

diff --git a/examples/bri-3/ccsm/test/CcsmBpiStateAnchor.ts b/examples/bri-3/ccsm/test/CcsmBpiStateAnchor.ts
@@ -42,111 +42,111 @@ describe('CcsmBpiStateAnchor', function () {
       const { ccsmBpiStateAnchor, owner } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const workgroupId = 'testWorkgroup';
+      const workstepInstanceId = 'testWorkstepInstance';
       const anchorHash = '0x1234567890abcdef';
 
       await expect(
         ccsmBpiStateAnchor
           .connect(owner)
-          .setAnchorHash(workgroupId, anchorHash),
+          .setAnchorHash(workstepInstanceId, anchorHash),
       )
         .to.emit(ccsmBpiStateAnchor, 'AnchorHashSet')
-        .withArgs(workgroupId, anchorHash);
+        .withArgs(workstepInstanceId, anchorHash);
 
-      expect(await ccsmBpiStateAnchor.anchorHashStore(workgroupId)).to.equal(
-        anchorHash,
-      );
+      expect(
+        await ccsmBpiStateAnchor.anchorHashStore(workstepInstanceId),
+      ).to.equal(anchorHash);
     });
 
     it('Should not allow a non-admin to set an anchor hash', async function () {
       const { ccsmBpiStateAnchor, otherAccount } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const workgroupId = 'testWorkgroup';
+      const workstepInstanceId = 'testWorkstepInstance';
       const anchorHash = '0x1234567890abcdef';
 
       await expect(
         ccsmBpiStateAnchor
           .connect(otherAccount)
-          .setAnchorHash(workgroupId, anchorHash),
+          .setAnchorHash(workstepInstanceId, anchorHash),
       ).to.be.revertedWith('Only admin can call this function');
     });
 
-    it('Should revert when workgroupId is empty', async function () {
+    it('Should revert when workstepInstanceId is empty', async function () {
       const { ccsmBpiStateAnchor, owner } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
       const anchorHash = '0x1234567890abcdef';
 
       await expect(
         ccsmBpiStateAnchor.connect(owner).setAnchorHash('', anchorHash),
-      ).to.be.revertedWith('WorkgroupId cannot be empty');
+      ).to.be.revertedWith('WorkstepInstanceId cannot be empty');
     });
 
-    it('Should revert when workgroupId exceeds 36 bytes', async function () {
+    it('Should revert when workstepInstanceId exceeds 36 bytes', async function () {
       const { ccsmBpiStateAnchor, owner } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const longWorkgroupId = 'a'.repeat(37);
+      const longWorkstepInstanceId = 'a'.repeat(37);
       const anchorHash = '0x1234567890abcdef';
 
       await expect(
         ccsmBpiStateAnchor
           .connect(owner)
-          .setAnchorHash(longWorkgroupId, anchorHash),
-      ).to.be.revertedWith('WorkgroupId cannot exceed 36 bytes');
+          .setAnchorHash(longWorkstepInstanceId, anchorHash),
+      ).to.be.revertedWith('WorkstepInstanceId cannot exceed 36 bytes');
     });
 
     it('Should revert when anchorHash is empty', async function () {
       const { ccsmBpiStateAnchor, owner } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const workgroupId = 'testWorkgroup';
+      const workstepInstanceId = 'testWorkstepInstance';
 
       await expect(
-        ccsmBpiStateAnchor.connect(owner).setAnchorHash(workgroupId, ''),
+        ccsmBpiStateAnchor.connect(owner).setAnchorHash(workstepInstanceId, ''),
       ).to.be.revertedWith('AnchorHash cannot be empty');
     });
 
     it('Should revert when anchorHash exceeds 256 bytes', async function () {
       const { ccsmBpiStateAnchor, owner } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const workgroupId = 'testWorkgroup';
+      const workstepInstanceId = 'testWorkstepInstance';
       const longAnchorHash = '0x' + 'a'.repeat(257);
 
       await expect(
         ccsmBpiStateAnchor
           .connect(owner)
-          .setAnchorHash(workgroupId, longAnchorHash),
+          .setAnchorHash(workstepInstanceId, longAnchorHash),
       ).to.be.revertedWith('AnchorHash cannot exceed 256 bytes');
     });
   });
 
   describe('getAnchorHash', function () {
-    it('Should return the correct anchor hash for a given workgroupId', async function () {
+    it('Should return the correct anchor hash for a given workstepInstanceId', async function () {
       const { ccsmBpiStateAnchor, owner } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const workgroupId = 'testWorkgroup';
+      const workstepInstanceId = 'testWorkstepInstance';
       const anchorHash = '0x1234567890abcdef';
 
       await ccsmBpiStateAnchor
         .connect(owner)
-        .setAnchorHash(workgroupId, anchorHash);
-      expect(await ccsmBpiStateAnchor.getAnchorHash(workgroupId)).to.equal(
-        anchorHash,
-      );
+        .setAnchorHash(workstepInstanceId, anchorHash);
+      expect(
+        await ccsmBpiStateAnchor.getAnchorHash(workstepInstanceId),
+      ).to.equal(anchorHash);
     });
 
-    it('Should return an empty string for a non-existent workgroupId', async function () {
+    it('Should return an empty string for a non-existent workstepInstanceId', async function () {
       const { ccsmBpiStateAnchor } = await loadFixture(
         deployCcsmBpiStateAnchor,
       );
-      const nonExistentWorkgroupId = 'nonExistent';
+      const nonExistentWorkstepInstanceId = 'nonExistent';
 
       expect(
-        await ccsmBpiStateAnchor.getAnchorHash(nonExistentWorkgroupId),
+        await ccsmBpiStateAnchor.getAnchorHash(nonExistentWorkstepInstanceId),
       ).to.equal('');
     });
   });

diff --git a/examples/bri-3/src/bri/ccsm/services/ccsm.interface.ts b/examples/bri-3/src/bri/ccsm/services/ccsm.interface.ts
@@ -1,6 +1,9 @@
 import { Contract } from 'ethers';
 export interface ICcsmService {
   connectToContract(): Promise<Contract>;
-  storeAnchorHash(workgroupId: string, anchorHash: string): Promise<void>;
-  getAnchorHash(workgroupId: string): Promise<string>;
+  storeAnchorHash(
+    workstepInstanceId: string,
+    anchorHash: string,
+  ): Promise<void>;
+  getAnchorHash(workstepInstanceId: string): Promise<string>;
 }
diff --git a/examples/bri-3/src/bri/ccsm/services/ethereum.service.spec.ts b/examples/bri-3/src/bri/ccsm/services/ethereum.service.spec.ts
@@ -13,27 +13,27 @@ describe.skip('Ethereum services', () => {
   describe('storeAnchorHash', () => {
     it('should set anchor hash in the mapping', async () => {
       //Arrange
-      const workgroupdId = '123';
+      const workstepInstanceId = '123';
       const anchorHash = 'anchorHash';
 
       //Act
-      await ccsm.storeAnchorHash(workgroupdId, anchorHash);
+      await ccsm.storeAnchorHash(workstepInstanceId, anchorHash);
       const ccsmContract = await ccsm.connectToContract();
 
       //Assert
-      expect(await ccsmContract.anchorHashStore(workgroupdId)).toEqual(
+      expect(await ccsmContract.anchorHashStore(workstepInstanceId)).toEqual(
         anchorHash,
       );
     });
   });
   describe('getAnchorHash', () => {
-    it('should get anchor hash of the workgroupId from the mapping', async () => {
+    it('should get anchor hash of the WorkstepInstanceId from the mapping', async () => {
       //Arrange
-      const workgroupdId = '123';
+      const workstepInstanceId = '123';
       const anchorHash = 'anchorHash';
 
       //Act
-      const response = await ccsm.getAnchorHash(workgroupdId);
+      const response = await ccsm.getAnchorHash(workstepInstanceId);
 
       //Assert
       expect(response).toEqual(anchorHash);

diff --git a/examples/bri-3/src/bri/ccsm/services/ethereum.service.ts b/examples/bri-3/src/bri/ccsm/services/ethereum.service.ts
@@ -44,12 +44,15 @@ export class EthereumService implements ICcsmService {
   }
 
   public async storeAnchorHash(
-    workgroupId: string,
+    workstepInstanceId: string,
     anchorHash: string,
   ): Promise<void> {
     const ccsmContract = await this.connectToContract();
     try {
-      const tx = await ccsmContract.setAnchorHash(workgroupId, anchorHash);
+      const tx = await ccsmContract.setAnchorHash(
+        workstepInstanceId,
+        anchorHash,
+      );
       await tx.wait();
     } catch (error) {
       throw new InternalServerErrorException(
@@ -58,9 +61,9 @@ export class EthereumService implements ICcsmService {
     }
   }
 
-  public async getAnchorHash(workgroupdId: string): Promise<string> {
+  public async getAnchorHash(workstepInstanceId: string): Promise<string> {
     const ccsmContract = await this.connectToContract();
-    const anchorHash = await ccsmContract.getAnchorHash(workgroupdId);
+    const anchorHash = await ccsmContract.getAnchorHash(workstepInstanceId);
     return anchorHash;
   }
 }