✨ Make the web3 constructor parameters optional

.eslintrc.js

@@ -2,10 +2,10 @@ module.exports = {
 	root: true,
 	env: {
 		browser: true,
-		es2021: true,
 		node: true,
 	},
 	parserOptions: {
+		ecmaVersion: 2016,
 		project: './tsconfig.json',
 		tsconfigRootDir: __dirname,
 		sourceType: 'module',

packages/web3-common/src/formatter.ts

@@ -60,9 +60,9 @@ export type DataFormat = {
 	readonly bytes: FMT_BYTES;
 };
 
-export const DEFAULT_RETURN_FORMAT = { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX } as const;
+export const DEFAULT_RETURN_FORMAT = { number: FMT_NUMBER.BIGINT, bytes: FMT_BYTES.HEX } as const;
+export const ETH_DATA_FORMAT = { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX } as const;
 
-// Added `undefined` to cover optional type
 export type FormatType<T, F extends DataFormat> = number extends Extract<T, Numbers>
 	? NumberTypes[F['number']] | Exclude<T, Numbers>
 	: Buffer extends Extract<T, Bytes>

packages/web3-common/src/formatters.ts

@@ -359,14 +359,14 @@ export const outputLogFormatter = (log: Partial<LogsInput>): LogsOutput => {
 		modifiedLog.id = undefined;
 	}
 
-	if (log.blockNumber) {
+	if (log.blockNumber && isHexStrict(log.blockNumber)) {
 		modifiedLog.blockNumber = hexToNumber(log.blockNumber);
 	}
-	if (log.transactionIndex) {
+	if (log.transactionIndex && isHexStrict(log.transactionIndex)) {
 		modifiedLog.transactionIndex = hexToNumber(log.transactionIndex);
 	}
 
-	if (log.logIndex) {
+	if (log.logIndex && isHexStrict(log.logIndex)) {
 		modifiedLog.logIndex = hexToNumber(log.logIndex);
 	}
 

packages/web3-common/src/index.ts

@@ -22,7 +22,8 @@ export * from './web3_base_wallet';
 export * from './web3_event_emitter';
 export * from './eth_execution_api';
 export * from './deferred_promise';
-export * from './promi_event';
+export * from './web3_promi_event';
 export * from './formatters';
+export * as formatters from './formatters';
 export * from './formatter';
 export * as jsonRpc from './json_rpc';

packages/web3-common/src/web3_base_provider.ts

@@ -15,6 +15,7 @@ You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+import { Web3Error } from 'web3-errors';
 import { EthExecutionAPI } from './eth_execution_api';
 import {
 	Web3APIPayload,
@@ -51,6 +52,51 @@ export abstract class Web3BaseProvider<API extends Web3APISpec = EthExecutionAPI
 	public abstract getStatus(): Web3BaseProviderStatus;
 	public abstract supportsSubscriptions(): boolean;
 
+	/**
+	 * @deprecated Please use `.request` instead.
+	 *
+	 * @param payload - Request Payload
+	 * @param cb - Callback
+	 */
+	public send<Method extends Web3APIMethod<API>, ResponseType = Web3APIReturnType<API, Method>>(
+		payload: Web3APIPayload<API, Method>,
+		// Used "null" value to match the legacy version
+		// eslint-disable-next-line @typescript-eslint/ban-types
+		cb: (err?: Error | Web3Error | null, response?: JsonRpcResponse<ResponseType>) => void,
+	) {
+		this.request(payload)
+			.then(response => {
+				cb(undefined, response);
+			})
+			.catch((err: Error | Web3Error) => {
+				cb(err);
+			});
+	}
+
+	/**
+	 * @deprecated Please use `.request` instead.
+	 *
+	 * @param payload - Request Payload
+	 * @param cb - Callback
+	 */
+	public sendAsync<
+		Method extends Web3APIMethod<API>,
+		ResponseType = Web3APIReturnType<API, Method>,
+	>(
+		payload: Web3APIPayload<API, Method>,
+		// Used "null" value to match the legacy version
+		// eslint-disable-next-line @typescript-eslint/ban-types
+		cb: (err?: Error | Web3Error | null, response?: JsonRpcResponse<ResponseType>) => void,
+	) {
+		this.request(payload)
+			.then(response => {
+				cb(undefined, response);
+			})
+			.catch((err: Error | Web3Error) => {
+				cb(err);
+			});
+	}
+
 	// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md#request
 	public abstract request<
 		Method extends Web3APIMethod<API>,

packages/web3-common/src/promi_event.ts → packages/web3-common/src/web3_promi_event.ts

@@ -22,7 +22,7 @@ export type PromiseExecutor<T> = (
 	reject: (reason: unknown) => void,
 ) => void;
 
-export class PromiEvent<ResolveType, EventMap extends Web3EventMap>
+export class Web3PromiEvent<ResolveType, EventMap extends Web3EventMap>
 	extends Web3EventEmitter<EventMap>
 	implements Promise<ResolveType>
 {

packages/web3-common/test/unit/formatters.test.ts

@@ -82,9 +82,9 @@ describe('formatters', () => {
 
 	describe('outputBigIntegerFormatter', () => {
 		it('should convert input to number', () => {
-			const result = outputBigIntegerFormatter(12n);
+			const result = outputBigIntegerFormatter(BigInt(12));
 
-			expect(utils.toNumber).toHaveBeenCalledWith(12n);
+			expect(utils.toNumber).toHaveBeenCalledWith(BigInt(12));
 			expect(result).toEqual(toNumberResult);
 		});
 	});
@@ -243,13 +243,13 @@ describe('formatters', () => {
 		it.each(['gasPrice', 'gas', 'value', 'maxPriorityFeePerGas', 'maxFeePerGas', 'nonce'])(
 			'should convert "%s" number value to hex',
 			attr => {
-				jest.spyOn(utils, 'toNumber').mockReturnValue(5678n);
+				jest.spyOn(utils, 'toNumber').mockReturnValue(BigInt(5678));
 
 				expect(
-					txInputOptionsFormatter({ ...txInput, data: '0xff0011', [attr]: 5678n }),
+					txInputOptionsFormatter({ ...txInput, data: '0xff0011', [attr]: BigInt(5678) }),
 				).toEqual(expect.objectContaining({ [attr]: numberToHexResult }));
 
-				expect(utils.numberToHex).toHaveBeenCalledWith(5678n);
+				expect(utils.numberToHex).toHaveBeenCalledWith(BigInt(5678));
 			},
 		);
 	});

packages/web3-common/test/unit/promi_event.test.ts → packages/web3-common/test/unit/web3_promi_event.test.ts

@@ -15,19 +15,19 @@ You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { PromiEvent } from '../../src/promi_event';
+import { Web3PromiEvent } from '../../src/web3_promi_event';
 
-describe('PromiEvent', () => {
+describe('Web3PromiEvent', () => {
 	it('should initialize and resolve promise', async () => {
-		const p = new PromiEvent(resolve => {
+		const p = new Web3PromiEvent(resolve => {
 			resolve('Resolved Value');
 		});
 
 		await expect(p).resolves.toBe('Resolved Value');
 	});
 
 	it('should initialize and reject promise', async () => {
-		const p = new PromiEvent((_, reject) => {
+		const p = new Web3PromiEvent((_, reject) => {
 			reject(new Error('My Error'));
 		});
 
@@ -36,7 +36,7 @@ describe('PromiEvent', () => {
 
 	it('should initialize and emit event', async () => {
 		return new Promise(done => {
-			const p = new PromiEvent<string, { data: string }>(resolve => {
+			const p = new Web3PromiEvent<string, { data: string }>(resolve => {
 				resolve('resolved value');
 			});
 
@@ -56,7 +56,7 @@ describe('PromiEvent', () => {
 	it('should initialize and emit later', async () => {
 		return new Promise(done => {
 			const func = () => {
-				const p = new PromiEvent<string, { data: string }>(resolve => {
+				const p = new Web3PromiEvent<string, { data: string }>(resolve => {
 					resolve('resolved value');
 				});
 

packages/web3-core/src/types.ts

@@ -51,8 +51,7 @@ export type SupportedProviders<API extends Web3APISpec> =
 	| Web3BaseProvider<API>
 	| LegacyRequestProvider
 	| LegacySendProvider
-	| LegacySendAsyncProvider
-	| string;
+	| LegacySendAsyncProvider;
 
 export type Web3BaseProviderConstructor = new <API extends Web3APISpec>(
 	url: string,

packages/web3-core/src/utils.ts

@@ -41,7 +41,7 @@ export const isLegacySendAsyncProvider = <API extends Web3APISpec>(
 
 export const isSupportedProvider = <API extends Web3APISpec>(
 	provider: SupportedProviders<API>,
-): boolean =>
+): provider is SupportedProviders<API> =>
 	Web3BaseProvider.isWeb3Provider(provider) ||
 	isLegacyRequestProvider(provider) ||
 	isLegacySendAsyncProvider(provider) ||

packages/web3-core/src/web3_context.ts

@@ -21,7 +21,7 @@ import {
 	Web3BaseWalletAccount,
 	Web3AccountProvider,
 } from 'web3-common';
-import { HexString } from 'web3-utils';
+import { HexString, isNullish } from 'web3-utils';
 import { SupportedProviders } from './types';
 import { isSupportedProvider } from './utils';
 // eslint-disable-next-line import/no-cycle
@@ -41,7 +41,7 @@ export type Web3ContextObject<
 	} = any,
 > = {
 	config: Web3ConfigOptions;
-	provider: SupportedProviders<API>;
+	provider?: SupportedProviders<API> | string;
 	requestManager: Web3RequestManager<API>;
 	subscriptionManager?: Web3SubscriptionManager<API, RegisteredSubs> | undefined;
 	registeredSubscriptions?: RegisteredSubs;
@@ -59,7 +59,7 @@ export type Web3ContextInitOptions<
 	} = any,
 > = {
 	config?: Partial<Web3ConfigOptions>;
-	provider: SupportedProviders<API>;
+	provider?: SupportedProviders<API> | string;
 	requestManager?: Web3RequestManager<API>;
 	subscriptionManager?: Web3SubscriptionManager<API, RegisteredSubs> | undefined;
 	registeredSubscriptions?: RegisteredSubs;
@@ -98,15 +98,25 @@ export class Web3Context<
 	private _wallet?: Web3BaseWallet<Web3BaseWalletAccount>;
 
 	public constructor(
-		providerOrContext: SupportedProviders<API> | Web3ContextInitOptions<API, RegisteredSubs>,
+		providerOrContext?:
+			| string
+			| SupportedProviders<API>
+			| Web3ContextInitOptions<API, RegisteredSubs>,
 	) {
 		super();
+
+		// If "providerOrContext" is provided as "string" or an objects matching "SupportedProviders" interface
 		if (
-			typeof providerOrContext === 'string' ||
+			isNullish(providerOrContext) ||
+			(typeof providerOrContext === 'string' && providerOrContext.trim() === '') ||
 			isSupportedProvider(providerOrContext as SupportedProviders<API>)
 		) {
 			this._requestManager = new Web3RequestManager<API>(
-				providerOrContext as SupportedProviders<API>,
+				providerOrContext as undefined | string | SupportedProviders<API>,
+			);
+			this._subscriptionManager = new Web3SubscriptionManager(
+				this._requestManager,
+				{} as RegisteredSubs,
 			);
 
 			return;
@@ -120,7 +130,7 @@ export class Web3Context<
 			registeredSubscriptions,
 			accountProvider,
 			wallet,
-		} = providerOrContext as Partial<Web3ContextObject<API, RegisteredSubs>>;
+		} = providerOrContext as Web3ContextInitOptions<API, RegisteredSubs>;
 
 		this.setConfig(config ?? {});
 
@@ -226,19 +236,19 @@ export class Web3Context<
 		});
 	}
 
-	public get provider(): SupportedProviders<API> {
+	public get provider(): SupportedProviders<API> | string | undefined {
 		return this.requestManager.provider;
 	}
 
-	public set provider(provider: SupportedProviders<API>) {
+	public set provider(provider: SupportedProviders<API> | string | undefined) {
 		this.requestManager.setProvider(provider);
 	}
 
-	public get currentProvider(): SupportedProviders<API> {
+	public get currentProvider(): SupportedProviders<API> | string | undefined {
 		return this.requestManager.provider;
 	}
 
-	public set currentProvider(provider: SupportedProviders<API>) {
+	public set currentProvider(provider: SupportedProviders<API> | string | undefined) {
 		this.requestManager.setProvider(provider);
 	}
 
@@ -247,7 +257,7 @@ export class Web3Context<
 		return Web3Context.givenProvider;
 	}
 
-	public setProvider(provider: SupportedProviders<API>) {
+	public setProvider(provider?: SupportedProviders<API> | string) {
 		this.provider = provider;
 	}
 

packages/web3-core/src/web3_request_manager.ts

@@ -31,7 +31,6 @@ import {
 	Web3APIRequest,
 	Web3APIReturnType,
 	Web3APISpec,
-	Web3BaseProvider,
 	Web3EventEmitter,
 } from 'web3-common';
 import HttpProvider from 'web3-providers-http';
@@ -60,14 +59,14 @@ const availableProviders = {
 export class Web3RequestManager<
 	API extends Web3APISpec = EthExecutionAPI,
 > extends Web3EventEmitter<{
-	[key in Web3RequestManagerEvent]: SupportedProviders<API>;
+	[key in Web3RequestManagerEvent]: SupportedProviders<API> | undefined;
 }> {
-	private _provider!: SupportedProviders<API>;
+	private _provider?: SupportedProviders<API>;
 
-	public constructor(provider?: SupportedProviders<API>, net?: Socket) {
+	public constructor(provider?: SupportedProviders<API> | string, net?: Socket) {
 		super();
 
-		if (provider) {
+		if (!isNullish(provider)) {
 			this.setProvider(provider, net);
 		}
 	}
@@ -77,10 +76,6 @@ export class Web3RequestManager<
 	}
 
 	public get provider() {
-		if (!this._provider) {
-			throw new ProviderError('Provider not available');
-		}
-
 		return this._provider;
 	}
 
@@ -89,8 +84,8 @@ export class Web3RequestManager<
 		return availableProviders;
 	}
 
-	public setProvider(provider: SupportedProviders<API>, net?: Socket) {
-		let newProvider!: Web3BaseProvider<API>;
+	public setProvider(provider?: SupportedProviders<API> | string, net?: Socket) {
+		let newProvider: SupportedProviders<API> | undefined;
 
 		// autodetect provider
 		if (provider && typeof provider === 'string' && this.providers) {
@@ -106,12 +101,17 @@ export class Web3RequestManager<
 			} else if (typeof net === 'object' && typeof net.connect === 'function') {
 				newProvider = new this.providers.IpcProvider<API>(provider, net);
 			} else {
-				throw new ProviderError(`Can't autodetect provider for "${provider}'"`);
+				throw new ProviderError(`Can't autodetect provider for "${provider}"`);
 			}
+		} else if (isNullish(provider)) {
+			// In case want to unset the provider
+			newProvider = undefined;
+		} else {
+			newProvider = provider as SupportedProviders<API>;
 		}
 
 		this.emit(Web3RequestManagerEvent.BEFORE_PROVIDER_CHANGE, this._provider);
-		this._provider = newProvider ?? provider;
+		this._provider = newProvider;
 		this.emit(Web3RequestManagerEvent.PROVIDER_CHANGED, this._provider);
 	}
 
@@ -142,6 +142,12 @@ export class Web3RequestManager<
 	): Promise<JsonRpcResponse<ResponseType>> {
 		const { provider } = this;
 
+		if (isNullish(provider)) {
+			throw new ProviderError(
+				'Provider not available. Use `.setProvider` or `.provider=` to initialize the provider.',
+			);
+		}
+
 		const payload = jsonRpc.isBatchRequest(request)
 			? jsonRpc.toBatchPayload(request)
 			: jsonRpc.toPayload(request);