Disconnect function doesn't exists in types of currentProvider (#5865)

* fix disconnect function

* add link

* test types

* add disconnect function test

* fix eth tests

* test stuck

* trace

* fix

* check

* fix test

* add empty disconnect function

* add test for provider instances

* fix http unit test

* remove logs

* revert to throw error http provider

---------

Co-authored-by: Muhammad Altabba <24407834+Muhammad-Altabba@users.noreply.github.com>

packages/web3-core/src/web3_context.ts

@@ -23,6 +23,7 @@ import {
 	SupportedProviders,
 	HexString,
 	EthExecutionAPI,
+	Web3BaseProvider,
 } from 'web3-types';
 import { isNullish } from 'web3-utils';
 import { ExistingPluginNamespaceError } from 'web3-errors';
@@ -268,8 +269,8 @@ export class Web3Context<
 	 * ```
 	 */
 
-	public get provider(): SupportedProviders<API> | string | undefined {
-		return this.requestManager.provider;
+	public get provider(): Web3BaseProvider<API> | undefined {
+		return this.currentProvider;
 	}
 
 	/**
@@ -310,8 +311,8 @@ export class Web3Context<
 	 *  }
 	 * ```
 	 */
-	public get currentProvider(): SupportedProviders<API> | string | undefined {
-		return this.requestManager.provider;
+	public get currentProvider(): Web3BaseProvider<API> | undefined {
+		return this.requestManager.provider as Web3BaseProvider<API>;
 	}
 
 	/**

packages/web3-eth/test/integration/defaults.test.ts

@@ -543,16 +543,15 @@ describe('defaults', () => {
 			// It will cause providers that does not support subscriptions (like http) to throw exception when subscribing.
 			// This case is tested to ensure that even if an error happen at subscription,
 			//	polling will still get the data from next blocks.
-			(tempEth.provider as Web3BaseProvider<Record<string, never>>).supportsSubscriptions =
-				() => true;
+			(tempEth.provider as Web3BaseProvider).supportsSubscriptions = () => true;
 
 			// Cause the events to take a long time (more than blockHeaderTimeout),
 			//	to ensure that polling of new blocks works in such cases.
 			// This will cause the providers that supports subscription (like WebSocket)
 			// 	to never return data through listening to new events
 
 			// eslint-disable-next-line @typescript-eslint/no-misused-promises
-			(tempEth.provider as Web3BaseProvider<Record<string, never>>).on = async () => {
+			(tempEth.provider as Web3BaseProvider).on = async () => {
 				await new Promise(res => {
 					setTimeout(res, 1000000);
 				});

packages/web3-providers-ws/test/integration/reconnection.test.ts

@@ -89,33 +89,14 @@ describeIf(isWs && !isBrowser)('WebSocketProvider - reconnection', () => {
 		it.skip('should connect, disconnect and reconnect', async () => {
 			const server = await createProxy(18546, getSystemTestProvider());
 			const web3Provider = new WebSocketProvider(server.path, {}, reconnectionOptions);
-
 			expect(!!(await waitForEvent(web3Provider, 'connect'))).toBe(true);
-
-			// @ts-expect-error-next-line
-			// eslint-disable-next-line @typescript-eslint/no-unused-vars
-			web3Provider._onCloseHandler = (_: CloseEvent) => {
-				// @ts-expect-error-next-line
-				web3Provider._onCloseEvent({ code: 1002 });
-			};
-			// @ts-expect-error-next-line
-			web3Provider._removeSocketListeners();
-			// @ts-expect-error-next-line
-			web3Provider._addSocketListeners();
+			web3Provider.disconnect(1002);
 			await server.close();
 			const connectEvent = waitForEvent(web3Provider, 'connect');
 			const server2 = await createProxy(18546, getSystemTestProvider());
 			expect(!!(await connectEvent)).toBe(true);
-			// @ts-expect-error-next-line
-			web3Provider._onCloseHandler = (event: CloseEvent) => {
-				// @ts-expect-error-next-line
-				web3Provider._onCloseEvent(event);
-			};
-			// @ts-expect-error-next-line
-			web3Provider._removeSocketListeners();
-			// @ts-expect-error-next-line
-			web3Provider._addSocketListeners();
-			web3Provider.disconnect(1000, 'test');
+
+			web3Provider.disconnect();
 			await waitForEvent(web3Provider, 'disconnect');
 			await server2.close();
 		});

packages/web3-utils/src/socket_provider.ts

@@ -55,6 +55,8 @@ type ReconnectOptions = {
 
 type EventType = 'message' | 'connect' | 'disconnect' | 'chainChanged' | 'accountsChanged' | string;
 
+const NORMAL_CLOSE_CODE = 1000; // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
+
 export abstract class SocketProvider<
 	MessageEvent,
 	CloseEvent,
@@ -216,11 +218,12 @@ export abstract class SocketProvider<
 	 * @param data - The data to be sent to the server
 	 */
 	public disconnect(code?: number, data?: string): void {
+		const disconnectCode = code ?? NORMAL_CLOSE_CODE;
 		this._removeSocketListeners();
 		if (this.getStatus() !== 'disconnected') {
-			this._closeSocketConnection(code, data);
+			this._closeSocketConnection(disconnectCode, data);
 		}
-		this._onDisconnect(code, data);
+		this._onDisconnect(disconnectCode, data);
 	}
 
 	/**

packages/web3/test/integration/web3.test.ts

@@ -19,7 +19,7 @@ import { JsonRpcOptionalRequest, Web3BaseProvider, SupportedProviders } from 'we
 import Contract from 'web3-eth-contract';
 import HttpProvider from 'web3-providers-http';
 import IpcProvider from 'web3-providers-ipc';
-import WebsocketProvider from 'web3-providers-ws';
+import WebSocketProvider from 'web3-providers-ws';
 import Web3 from '../../src/index';
 import { BasicAbi } from '../shared_fixtures/Basic';
 import { validEncodeParametersData } from '../shared_fixtures/data';
@@ -32,9 +32,13 @@ import {
 	isIpc,
 	isWs,
 	waitForOpenConnection,
+	itIf,
+	isSocket,
 } from '../shared_fixtures/system_tests_utils';
 import { GreeterAbi, GreeterBytecode } from '../shared_fixtures/build/Greeter';
 
+/* eslint-disable jest/no-standalone-expect */
+
 describe('Web3 instance', () => {
 	let clientUrl: string;
 	let accounts: string[];
@@ -75,6 +79,44 @@ describe('Web3 instance', () => {
 		expect(() => new Web3()).not.toThrow();
 	});
 
+	it('check disconnect function', async () => {
+		const web3Instance = new Web3(clientUrl);
+		await web3Instance.eth.getBlockNumber();
+		expect(typeof web3Instance.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.currentProvider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.currentProvider?.disconnect).toBe('function');
+		if (isSocket) {
+			web3Instance.currentProvider?.disconnect();
+		}
+	});
+	itIf(isWs)('check disconnect function for WebSocket provider', async () => {
+		const web3Instance = new Web3(new WebSocketProvider(clientUrl));
+		await web3Instance.eth.getBlockNumber();
+		expect(typeof web3Instance.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.currentProvider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.currentProvider?.disconnect).toBe('function');
+		web3Instance.currentProvider?.disconnect();
+	});
+	itIf(isIpc)('check disconnect function for ipc provider', async () => {
+		const web3Instance = new Web3(new IpcProvider(clientUrl));
+		await web3Instance.eth.getBlockNumber();
+		expect(typeof web3Instance.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.currentProvider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.currentProvider?.disconnect).toBe('function');
+		web3Instance.currentProvider?.disconnect();
+	});
+	itIf(isHttp)('check disconnect function for http provider', async () => {
+		const web3Instance = new Web3(new HttpProvider(clientUrl));
+		await web3Instance.eth.getBlockNumber();
+		expect(typeof web3Instance.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.provider?.disconnect).toBe('function');
+		expect(typeof web3Instance.currentProvider?.disconnect).toBe('function');
+		expect(typeof web3Instance.eth.currentProvider?.disconnect).toBe('function');
+	});
+
 	it('should be able use "utils" without provider', () => {
 		web3 = new Web3();
 
@@ -179,7 +221,7 @@ describe('Web3 instance', () => {
 			const res = Web3.providers;
 
 			expect(Web3.providers.HttpProvider).toBe(HttpProvider);
-			expect(res.WebsocketProvider).toBe(WebsocketProvider);
+			expect(res.WebsocketProvider).toBe(WebSocketProvider);
 			expect(res.IpcProvider).toBe(IpcProvider);
 		});