fix: bumped json rpc relay to v0.67.0 to fix hiero migration issue (#1845)

Signed-off-by: Jeromy Cannon <[email protected]>

Author: jeromy-cannon

src/core/config/remote/remote-config-manager.ts

@@ -473,8 +473,6 @@ export class RemoteConfigManager {
     const consensusNodes: ConsensusNode[] = [];
 
     for (const node of Object.values(this.components.consensusNodes)) {
-      this.logger.debug(`Adding consensus node ${node.name} , node.cluster = ${node.cluster}`);
-
       const cluster = this.clusters[node.cluster];
       const context = this.localConfig.clusterRefs[node.cluster];
 

src/core/constants.ts

@@ -61,7 +61,7 @@ export const SOLO_DEPLOYMENT_CHART = 'solo-deployment';
 export const SOLO_CERT_MANAGER_CHART = 'solo-cert-manager';
 
 export const JSON_RPC_RELAY_CHART_URL =
-  process.env.JSON_RPC_RELAY_CHART_URL ?? 'https://hashgraph.github.io/hedera-json-rpc-relay/charts';
+  process.env.JSON_RPC_RELAY_CHART_URL ?? 'https://hiero-ledger.github.io/hiero-json-rpc-relay/charts';
 export const JSON_RPC_RELAY_CHART = 'hedera-json-rpc-relay';
 
 export const MIRROR_NODE_CHART_URL =

test/e2e/commands/relay.test.ts

@@ -1,11 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
-import {after, afterEach, describe} from 'mocha';
+import {after, describe} from 'mocha';
 import {expect} from 'chai';
 import each from 'mocha-each';
 
 import {Flags as flags} from '../../../src/commands/flags.js';
-import {endToEndTestSuite, getTestCluster, HEDERA_PLATFORM_VERSION_TAG} from '../../test-utility.js';
+import {
+  type BootstrapResponse,
+  endToEndTestSuite,
+  getTestCluster,
+  HEDERA_PLATFORM_VERSION_TAG,
+} from '../../test-utility.js';
 import * as version from '../../../version.js';
 import {sleep} from '../../../src/core/helpers.js';
 import {RelayCommand} from '../../../src/commands/relay.js';
@@ -15,10 +20,12 @@ import {type NetworkNodes} from '../../../src/core/network-nodes.js';
 import {container} from 'tsyringe-neo';
 import {InjectTokens} from '../../../src/core/dependency-injection/inject-tokens.js';
 import {Argv} from '../../helpers/argv-wrapper.js';
+import {type ArgvStruct} from '../../../src/types/aliases.js';
+import {type SoloLogger} from '../../../src/core/logging/solo-logger.js';
 
-const testName = 'relay-cmd-e2e';
-const namespace = NamespaceName.of(testName);
-const argv = Argv.getDefaultArgv(namespace);
+const testName: string = 'relay-cmd-e2e';
+const namespace: NamespaceName = NamespaceName.of(testName);
+const argv: Argv = Argv.getDefaultArgv(namespace);
 argv.setArg(flags.namespace, namespace.name);
 argv.setArg(flags.releaseTag, HEDERA_PLATFORM_VERSION_TAG);
 argv.setArg(flags.nodeAliasesUnparsed, 'node1,node2');
@@ -29,54 +36,65 @@ argv.setArg(flags.soloChartVersion, version.SOLO_CHART_VERSION);
 argv.setArg(flags.force, true);
 argv.setArg(flags.relayReleaseTag, flags.relayReleaseTag.definition.defaultValue);
 
-endToEndTestSuite(testName, argv, {}, bootstrapResp => {
+endToEndTestSuite(testName, argv, {}, (bootstrapResp: BootstrapResponse): void => {
   const {
     opts: {k8Factory, logger, commandInvoker},
   } = bootstrapResp;
 
-  describe('RelayCommand', async () => {
-    const relayCmd = new RelayCommand(bootstrapResp.opts);
+  describe('RelayCommand', async (): Promise<void> => {
+    const relayCmd: RelayCommand = new RelayCommand(bootstrapResp.opts);
+    const testLogger: SoloLogger = container.resolve(InjectTokens.SoloLogger);
 
-    after(async function () {
+    afterEach(async (): Promise<void> => {
+      // wait for k8s to finish destroying containers from relay destroy
+      await sleep(Duration.ofMillis(5));
+    });
+
+    after(async function (): Promise<void> {
       this.timeout(Duration.ofMinutes(5).toMillis());
       await container.resolve<NetworkNodes>(InjectTokens.NetworkNodes).getLogs(namespace);
       await k8Factory.default().namespaces().delete(namespace);
     });
 
-    afterEach(async () => await sleep(Duration.ofMillis(5)));
-
-    each(['node1', 'node1,node2']).it('relay deploy and destroy should work with $value', async function (relayNodes) {
-      this.timeout(Duration.ofMinutes(5).toMillis());
+    each(['node1', 'node1,node2']).describe(
+      'relay and deploy and destroy for each',
+      async (relayNodes: string): Promise<void> => {
+        it(`relay deploy and destroy should work with ${relayNodes}`, async function (): Promise<void> {
+          testLogger.info(`#### Running relay deploy for: ${relayNodes} ####`);
+          this.timeout(Duration.ofMinutes(5).toMillis());
 
-      argv.setArg(flags.nodeAliasesUnparsed, relayNodes);
+          argv.setArg(flags.nodeAliasesUnparsed, relayNodes);
 
-      try {
-        await commandInvoker.invoke({
-          argv: argv,
-          command: RelayCommand.COMMAND_NAME,
-          subcommand: 'deploy',
-          // @ts-expect-error to access private property
-          callback: async argv => relayCmd.deploy(argv),
-        });
-      } catch (error) {
-        logger.showUserError(error);
-        expect.fail();
-      }
-      await sleep(Duration.ofMillis(500));
+          try {
+            await commandInvoker.invoke({
+              argv: argv,
+              command: RelayCommand.COMMAND_NAME,
+              subcommand: 'deploy',
+              // @ts-expect-error to access private property
+              callback: async (argv: ArgvStruct): Promise<boolean> => relayCmd.deploy(argv),
+            });
+          } catch (error) {
+            logger.showUserError(error);
+            expect.fail();
+          }
+          await sleep(Duration.ofMillis(500));
 
-      // test relay destroy
-      try {
-        await commandInvoker.invoke({
-          argv: argv,
-          command: RelayCommand.COMMAND_NAME,
-          subcommand: 'destroy',
-          // @ts-expect-error to access private modifier
-          callback: async argv => relayCmd.destroy(argv),
+          testLogger.info(`#### Running relay destroy for: ${relayNodes} ####`);
+          try {
+            await commandInvoker.invoke({
+              argv: argv,
+              command: RelayCommand.COMMAND_NAME,
+              subcommand: 'destroy',
+              // @ts-expect-error to access private modifier
+              callback: async (argv: ArgvStruct): Promise<boolean> => relayCmd.destroy(argv),
+            });
+          } catch (error) {
+            logger.showUserError(error);
+            expect.fail();
+          }
+          testLogger.info(`#### Finished relay deploy and destroy for: ${relayNodes} ####`);
         });
-      } catch (error) {
-        logger.showUserError(error);
-        expect.fail();
-      }
-    });
+      },
+    );
   });
 });

test/test-utility.ts

@@ -104,7 +104,7 @@ interface TestOptions {
   commandInvoker: CommandInvoker;
 }
 
-interface BootstrapResponse {
+export interface BootstrapResponse {
   deployment: string;
   namespace: NamespaceName;
   opts: TestOptions;

version.ts

@@ -15,7 +15,7 @@ export const SOLO_CHART_VERSION = '0.50.0';
 export const HEDERA_PLATFORM_VERSION = 'v0.59.5';
 export const MIRROR_NODE_VERSION = 'v0.126.0';
 export const HEDERA_EXPLORER_VERSION = '24.12.1';
-export const HEDERA_JSON_RPC_RELAY_VERSION = 'v0.66.0';
+export const HEDERA_JSON_RPC_RELAY_VERSION = 'v0.67.0';
 export const INGRESS_CONTROLLER_VERSION = '0.14.5';
 
 export function getSoloVersion(): Version {