Reload chainTypes

packages/node-core/CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- Fixed project upgrade missing reload network chainTypes when `onProjectChange` (#2505)
+
 ## [13.0.1] - 2024-07-29
 ### Fixed
 - Fixed get and set data not been deepCloned and data is not mutable

packages/node-core/src/api.service.ts

@@ -25,13 +25,14 @@ export interface IApiConnectionSpecific<A = any, SA = any, B extends Array<any>
   handleError(error: Error): ApiConnectionError;
   apiConnect(): Promise<void>;
   apiDisconnect(): Promise<void>;
+  updateChainTypes?(chainTypes: unknown): Promise<void>;
 }
 
 export abstract class ApiService<
   A = any,
   SA = any,
   B extends Array<any> = any[],
-  Connection extends IApiConnectionSpecific<A, SA, B> = IApiConnectionSpecific<A, SA, B>
+  Connection extends IApiConnectionSpecific<A, SA, B> = IApiConnectionSpecific<A, SA, B>,
 > implements IApi<A, SA, B>
 {
   constructor(

packages/node-core/src/indexer/connectionPool.service.ts

@@ -250,4 +250,11 @@ export class ConnectionPoolService<T extends IApiConnectionSpecific<any, any, an
     this.lastCacheFlushTime = Date.now();
     await this.handleConnectionStateChange();
   }
+
+  async updateChainTypes(newChainTypes: unknown): Promise<void> {
+    logger.info(`Network chain types updated!`);
+    for (const endpoint in this.allApi) {
+      await this.allApi[endpoint].updateChainTypes?.(newChainTypes);
+    }
+  }
 }

packages/node/CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- Fixed api didn't reload new deployment chainTypes when project upgraded (#2505)
+
 ## [5.0.1] - 2024-07-29
 ### Fixed
 - Fixed default Timezone to UTC in dockerfile and package.json (#2505)
@@ -15,7 +18,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 - Breaking change: Update with `@subql/node-core`, require indexing environment timezone set to UTC (#2495)
 - Update SubqueryProject to use code from node-core (#2496)
-
 ### Fixed
 - Bump with `@subql/node-core`, fixed various issues causing poi inconsistency (#2497)
 

packages/node/src/indexer/api.service.ts

@@ -206,12 +206,16 @@ export class ApiService
         });
       },
     );
-
     return this;
   }
 
-  updateBlockFetching(): void {
-    const onlyEventHandlers = isOnlyEventHandlers(this.project);
+  async updateChainTypes(newChainTypes: unknown): Promise<void> {
+    const chainTypes = await updateChainTypesHasher(newChainTypes);
+    await this.connectionPoolService.updateChainTypes(chainTypes);
+  }
+
+  updateBlockFetching(project?: SubqueryProject): void {
+    const onlyEventHandlers = isOnlyEventHandlers(project ?? this.project);
     const skipTransactions =
       this.nodeConfig.skipTransactions && onlyEventHandlers;
 

packages/node/src/indexer/apiPromise.connection.ts

@@ -1,7 +1,6 @@
 // Copyright 2020-2024 SubQuery Pte Ltd authors & contributors
 // SPDX-License-Identifier: GPL-3.0
 
-import assert from 'assert';
 import { ApiPromise, WsProvider } from '@polkadot/api';
 import { ProviderInterface } from '@polkadot/rpc-provider/types';
 import { RegisteredTypes } from '@polkadot/types/types';
@@ -46,6 +45,7 @@ export class ApiPromiseConnection
   private constructor(
     public unsafeApi: ApiPromise,
     private fetchBlocksBatches: GetFetchFunc,
+    private endpoint: string,
   ) {
     this.networkMeta = {
       chain: unsafeApi.runtimeChain.toString(),
@@ -59,6 +59,14 @@ export class ApiPromiseConnection
     fetchBlocksBatches: GetFetchFunc,
     args: { chainTypes?: RegisteredTypes },
   ): Promise<ApiPromiseConnection> {
+    const api = await this.createApiPromise(endpoint, args);
+    return new ApiPromiseConnection(api, fetchBlocksBatches, endpoint);
+  }
+
+  static async createApiPromise(
+    endpoint: string,
+    args: { chainTypes?: RegisteredTypes },
+  ): Promise<ApiPromise> {
     let provider: ProviderInterface;
     let throwOnConnect = false;
 
@@ -83,8 +91,8 @@ export class ApiPromiseConnection
       noInitWarn: true,
       ...args.chainTypes,
     };
-    const api = await ApiPromise.create(apiOption);
-    return new ApiPromiseConnection(api, fetchBlocksBatches);
+
+    return ApiPromise.create(apiOption);
   }
 
   safeApi(height: number): ApiAt {
@@ -123,6 +131,14 @@ export class ApiPromiseConnection
     await this.unsafeApi.disconnect();
   }
 
+  async updateRegisteredChainTypes(chainTypes: RegisteredTypes): Promise<void> {
+    this.unsafeApi = await ApiPromiseConnection.createApiPromise(
+      this.endpoint,
+      { chainTypes },
+    );
+    await this.apiConnect();
+  }
+
   handleError = ApiPromiseConnection.handleError;
 
   static handleError(e: Error): ApiConnectionError {

packages/node/src/indexer/project.service.spec.ts

@@ -0,0 +1,139 @@
+// Copyright 2020-2024 SubQuery Pte Ltd authors & contributors
+// SPDX-License-Identifier: GPL-3.0
+
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import {
+  ConnectionPoolService,
+  ConnectionPoolStateManager,
+  NodeConfig,
+  ProjectUpgradeService,
+} from '@subql/node-core';
+import { SubstrateDatasourceKind, SubstrateHandlerKind } from '@subql/types';
+import { GraphQLSchema } from 'graphql';
+import { SubqueryProject } from '../configure/SubqueryProject';
+import { ApiService } from './api.service';
+import { ApiPromiseConnection } from './apiPromise.connection';
+import { DsProcessorService } from './ds-processor.service';
+import { DynamicDsService } from './dynamic-ds.service';
+import { ProjectService } from './project.service';
+
+const nodeConfig = new NodeConfig({
+  subquery: 'test',
+  subqueryName: 'test',
+  networkEndpoint: ['https://polkadot.api.onfinality.io/public'],
+  dictionaryTimeout: 10,
+});
+
+function testSubqueryProject(): SubqueryProject {
+  return {
+    id: 'test',
+    root: './',
+    network: {
+      endpoint: ['https://polkadot.api.onfinality.io/public'],
+      chainId:
+        '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3',
+    },
+    dataSources: [
+      {
+        kind: SubstrateDatasourceKind.Runtime,
+        startBlock: 1,
+        mapping: {
+          file: '',
+          handlers: [
+            { handler: 'testSandbox', kind: SubstrateHandlerKind.Event },
+          ],
+        },
+      },
+    ],
+    schema: new GraphQLSchema({}),
+    templates: [],
+    chainTypes: {
+      types: {
+        TestType: 'u32',
+      },
+    },
+    applyCronTimestamps: () => jest.fn(),
+  } as unknown as SubqueryProject;
+}
+
+const demoProjects = [
+  testSubqueryProject(),
+  {
+    parent: {
+      utilBlock: 5,
+      reference: '0',
+    },
+    ...testSubqueryProject(),
+  },
+] as SubqueryProject[];
+
+jest.setTimeout(10_000);
+
+describe('ProjectService', () => {
+  let service: ProjectService;
+
+  const apiService = new ApiService(
+    demoProjects[0],
+    new ConnectionPoolService<ApiPromiseConnection>(
+      nodeConfig,
+      new ConnectionPoolStateManager(),
+    ),
+    new EventEmitter2(),
+    nodeConfig,
+  );
+
+  beforeEach(async () => {
+    // Api service init at bootstrap
+    await apiService.init();
+
+    const projectUpgradeService = await ProjectUpgradeService.create(
+      demoProjects[0],
+      (id) => Promise.resolve(demoProjects[parseInt(id, 10)]),
+      1,
+    );
+
+    (projectUpgradeService as any).init = jest.fn();
+    (projectUpgradeService as any).updateIndexedDeployments = jest.fn();
+
+    service = new ProjectService(
+      {
+        validateProjectCustomDatasources: jest.fn(),
+      } as unknown as DsProcessorService,
+      apiService,
+      null as unknown as any,
+      null as unknown as any,
+      { query: jest.fn() } as unknown as any,
+      demoProjects[0],
+      projectUpgradeService,
+      {
+        initCoreTables: jest.fn(),
+        storeCache: { metadata: {}, flushCache: jest.fn() },
+      } as unknown as any,
+      { unsafe: false } as unknown as NodeConfig,
+      {
+        getDynamicDatasources: jest.fn().mockResolvedValue([]),
+        init: jest.fn(),
+      } as unknown as DynamicDsService,
+      null as unknown as any,
+      null as unknown as any,
+    );
+
+    // Mock db related returns
+    (service as any).ensureProject = jest.fn().mockResolvedValue('mock-schema');
+    (service as any).ensureMetadata = jest.fn();
+    (service as any).initDbSchema = jest.fn();
+    (service as any).initUnfinalizedInternal = jest
+      .fn()
+      .mockResolvedValue(undefined);
+  });
+
+  it('reload chainTypes when project changed, on init', async () => {
+    const spyOnApiUpdateChainTypes = jest.spyOn(apiService, 'updateChainTypes');
+    // mock last processed height
+    (service as any).getLastProcessedHeight = jest.fn().mockResolvedValue(4);
+
+    await service.init(5);
+
+    expect(spyOnApiUpdateChainTypes).toHaveBeenCalledTimes(1);
+  });
+});

packages/node/src/indexer/project.service.ts

@@ -74,7 +74,9 @@ export class ProjectService extends BaseProjectService<
     return getTimestamp(block);
   }
 
-  protected onProjectChange(project: SubqueryProject): void | Promise<void> {
-    this.apiService.updateBlockFetching();
+  protected async onProjectChange(project: SubqueryProject): Promise<void> {
+    // Only network with chainTypes require to reload
+    await this.apiService.updateChainTypes(project.chainTypes);
+    this.apiService.updateBlockFetching(project);
   }
 }