Use new hashing service

ot-node.js

@@ -49,6 +49,12 @@ class OTNode {
 
         await this.initializeModules();
 
+        await MigrationExecutor.executeRemoveServiceAgreementsForChiadoDevnetMigration(
+            this.container,
+            this.logger,
+            this.config,
+        );
+
         await this.createProfiles();
 
         await this.initializeCommandExecutor();

package.json

@@ -50,7 +50,7 @@
         "chai": "^4.3.6",
         "d3": "^7.8.5",
         "d3-node": "^3.0.0",
-        "dkg.js": "^6.0.2",
+        "dkg.js": "^6.1.2",
         "eslint": "^8.23.0",
         "eslint-config-airbnb": "^19.0.4",
         "eslint-config-prettier": "^8.5.0",

src/commands/protocols/common/epoch-check-command.js

@@ -20,6 +20,8 @@ class EpochCheckCommand extends Command {
         this.blockchainModuleManager = ctx.blockchainModuleManager;
         this.serviceAgreementService = ctx.serviceAgreementService;
         this.fileService = ctx.fileService;
+        this.proximityScoringService = ctx.proximityScoringService;
+        this.hashingService = ctx.hashingService;
 
         this.errorType = ERROR_TYPE.COMMIT_PROOF.EPOCH_CHECK_ERROR;
     }
@@ -124,12 +126,39 @@ class EpochCheckCommand extends Command {
         for (const serviceAgreement of eligibleAgreementForSubmitCommit) {
             if (scheduleSubmitCommitCommands.length >= maxTransactions) break;
 
+            const neighbourhood = await this.shardingTableService.findNeighbourhood(
+                blockchain,
+                serviceAgreement.keyword,
+                r2,
+                serviceAgreement.hashFunctionId,
+                serviceAgreement.scoreFunctionId,
+                true,
+            );
+
+            let neighbourhoodEdges = null;
+            if (serviceAgreement.scoreFunctionId === 2) {
+                neighbourhoodEdges = await this.shardingTableService.getNeighboorhoodEdgeNodes(
+                    neighbourhood,
+                    blockchain,
+                    serviceAgreement.hashFunctionId,
+                    serviceAgreement.scoreFunctionId,
+                    serviceAgreement.keyword,
+                );
+            }
+
+            if (!neighbourhoodEdges && serviceAgreement.scoreFunctionId === 2) {
+                throw Error('Unable to find neighbourhood edges for asset');
+            }
+
             try {
-                const rank = await this.calculateRank(
+                const rank = await this.serviceAgreementService.calculateRank(
                     blockchain,
                     serviceAgreement.keyword,
                     serviceAgreement.hashFunctionId,
+                    serviceAgreement.scoreFunctionId,
                     r2,
+                    neighbourhood,
+                    neighbourhoodEdges,
                 );
 
                 updateServiceAgreementsLastCommitEpoch.push(
@@ -164,9 +193,13 @@ class EpochCheckCommand extends Command {
                         serviceAgreement.agreementId
                     }. Scheduling submitCommitCommand.`,
                 );
-
+                const closestNode = neighbourhood[0];
                 scheduleSubmitCommitCommands.push(
-                    this.scheduleSubmitCommitCommand(serviceAgreement),
+                    this.scheduleSubmitCommitCommand(
+                        serviceAgreement,
+                        neighbourhoodEdges,
+                        closestNode,
+                    ),
                 );
             } catch (error) {
                 this.logger.warn(
@@ -239,37 +272,6 @@ class EpochCheckCommand extends Command {
         ]);
     }
 
-    async calculateRank(blockchain, keyword, hashFunctionId, r2) {
-        const neighbourhood = await this.shardingTableService.findNeighbourhood(
-            blockchain,
-            keyword,
-            r2,
-            hashFunctionId,
-            true,
-        );
-
-        const peerId = this.networkModuleManager.getPeerId().toB58String();
-        if (!neighbourhood.some((node) => node.peerId === peerId)) {
-            return;
-        }
-
-        const scores = await Promise.all(
-            neighbourhood.map(async (node) => ({
-                score: await this.serviceAgreementService.calculateScore(
-                    node.peerId,
-                    blockchain,
-                    keyword,
-                    hashFunctionId,
-                ),
-                peerId: node.peerId,
-            })),
-        );
-
-        scores.sort((a, b) => b.score - a.score);
-
-        return scores.findIndex((node) => node.peerId === peerId);
-    }
-
     async isEligibleForRewards(blockchain, agreementId, epoch, stateIndex, r0) {
         const identityId = await this.blockchainModuleManager.getIdentityId(blockchain);
         const commits = await this.blockchainModuleManager.getTopCommitSubmissions(
@@ -288,7 +290,7 @@ class EpochCheckCommand extends Command {
         return false;
     }
 
-    async scheduleSubmitCommitCommand(agreement) {
+    async scheduleSubmitCommitCommand(agreement, neighbourhoodEdges, closestNode) {
         const commandData = {
             operationId: this.operationIdService.generateId(),
             blockchain: agreement.blockchainId,
@@ -299,6 +301,9 @@ class EpochCheckCommand extends Command {
             epoch: agreement.currentEpoch,
             agreementId: agreement.agreementId,
             stateIndex: agreement.stateIndex,
+            closestNode: closestNode.index,
+            leftNeighborhoodEdge: neighbourhoodEdges?.leftEdge.index,
+            rightNeighborhoodEdge: neighbourhoodEdges?.rightEdge.index,
         };
 
         await this.commandExecutor.add({

src/commands/protocols/common/find-nodes-command.js

@@ -22,14 +22,21 @@ class FindNodesCommand extends Command {
             networkProtocols,
             hashFunctionId,
             minAckResponses,
+            proximityScoreFunctionsPairId,
         } = command.data;
 
         this.errorType = errorType;
         this.logger.debug(`Searching for closest node(s) for keyword ${keyword}`);
 
         // TODO: protocol selection
         const closestNodes = [];
-        const foundNodes = await this.findNodes(blockchain, keyword, operationId, hashFunctionId);
+        const foundNodes = await this.findNodes(
+            blockchain,
+            keyword,
+            operationId,
+            hashFunctionId,
+            proximityScoreFunctionsPairId,
+        );
         for (const node of foundNodes) {
             if (node.id !== this.networkModuleManager.getPeerId().toB58String()) {
                 closestNodes.push({ id: node.id, protocol: networkProtocols[0] });
@@ -66,7 +73,13 @@ class FindNodesCommand extends Command {
         );
     }
 
-    async findNodes(blockchainId, keyword, operationId, hashFunctionId) {
+    async findNodes(
+        blockchainId,
+        keyword,
+        operationId,
+        hashFunctionId,
+        proximityScoreFunctionsPairId,
+    ) {
         await this.operationIdService.updateOperationIdStatus(
             operationId,
             blockchainId,
@@ -78,6 +91,7 @@ class FindNodesCommand extends Command {
             keyword,
             r2,
             hashFunctionId,
+            proximityScoreFunctionsPairId,
             true,
         );
 

src/commands/protocols/common/handle-protocol-message-command.js

@@ -47,12 +47,19 @@ class HandleProtocolMessageCommand extends Command {
         throw Error('prepareMessage not implemented');
     }
 
-    async validateNeighborhood(blockchain, keyword, hashFunctionId, ual) {
+    async validateNeighborhood(
+        blockchain,
+        keyword,
+        hashFunctionId,
+        proximityScoreFunctionsPairId,
+        ual,
+    ) {
         const closestNodes = await this.shardingTableService.findNeighbourhood(
             blockchain,
             keyword,
             await this.blockchainModuleManager.getR2(blockchain),
             hashFunctionId,
+            proximityScoreFunctionsPairId,
             true,
         );
         const peerId = this.networkModuleManager.getPeerId().toB58String();
@@ -179,11 +186,20 @@ class HandleProtocolMessageCommand extends Command {
         tokenId,
         keyword,
         hashFunctionId,
+        proximityScoreFunctionsPairId,
     ) {
         const ual = this.ualService.deriveUAL(blockchain, contract, tokenId);
 
         this.logger.trace(`Validating neighborhood for ual: ${ual}`);
-        if (!(await this.validateNeighborhood(blockchain, keyword, hashFunctionId, ual))) {
+        if (
+            !(await this.validateNeighborhood(
+                blockchain,
+                keyword,
+                hashFunctionId,
+                proximityScoreFunctionsPairId,
+                ual,
+            ))
+        ) {
             return {
                 messageType: NETWORK_MESSAGE_TYPES.RESPONSES.NACK,
                 messageData: { errorMessage: 'Invalid neighbourhood' },

src/commands/protocols/common/network-protocol-command.js

@@ -4,19 +4,34 @@ class NetworkProtocolCommand extends Command {
     constructor(ctx) {
         super(ctx);
         this.commandExecutor = ctx.commandExecutor;
+        this.blockchainModuleManager = ctx.blockchainModuleManager;
+        this.serviceAgreementService = ctx.serviceAgreementService;
     }
 
     /**
      * Executes command and produces one or more events
      * @param command
      */
     async execute(command) {
-        const { blockchain } = command.data;
+        const { blockchain, contract, tokenId, hashFunctionId } = command.data;
 
         const keywords = await this.getKeywords(command);
         const batchSize = await this.getBatchSize(blockchain);
         const minAckResponses = await this.getMinAckResponses(blockchain);
 
+        const serviceAgreementId = await this.serviceAgreementService.generateId(
+            blockchain,
+            contract,
+            tokenId,
+            keywords[0],
+            hashFunctionId,
+        );
+        const proximityScoreFunctionsPairId =
+            await this.blockchainModuleManager.getAgreementScoreFunctionId(
+                blockchain,
+                serviceAgreementId,
+            );
+
         const commandSequence = [
             'findNodesCommand',
             `${this.operationService.getOperationName()}ScheduleMessagesCommand`,
@@ -34,6 +49,7 @@ class NetworkProtocolCommand extends Command {
                     minAckResponses,
                     errorType: this.errorType,
                     networkProtocols: this.operationService.getNetworkProtocols(),
+                    proximityScoreFunctionsPairId,
                 },
                 transactional: false,
             }),