web3 · nazarhussain · Mar 4, 2022 · Jan 10, 2022 · Jan 10, 2022 · Jan 10, 2022
@@ -357,3 +357,4 @@ Released with 1.0.0-beta.37 code base.
 4. `recover` function's last param is boolean `hashed`, it is used to indicate if data provided is already hashed or not. By default this function will assume data is not hashed.
 5. The `Wallet` no more supports address/number indexing. Have to use `wallet.get` instead.
 6. `Wallet.create` function doesn't accepts `entropy` param
+7. `contract.method.send()` will resolve to transaction receipt instead of `transactionHash`. User can use `receipt.transactionHash` instead.
diff --git a/packages/web3-common/src/eth_execution_api.ts b/packages/web3-common/src/eth_execution_api.ts
@@ -24,14 +24,17 @@ export type AccessList = AccessListEntry[];
 export type TransactionHash = HexString;
 export type Uncles = HexString32Bytes[];
 
-// TODO Should probably support EIP-2930 and EIP-1559
 export interface TransactionCall {
 	readonly from?: Address;
 	readonly to: Address;
 	readonly gas?: Uint;
 	readonly gasPrice?: Uint;
 	readonly value?: Uint;
-	readonly data?: HexString;
+	readonly data?: HexStringBytes;
+	readonly type?: HexStringSingleByte;
+	readonly maxFeePerGas?: Uint;
+	readonly maxPriorityFeePerGas?: Uint;
+	readonly accessList?: AccessList;
 }
 
 export interface BaseTransaction {
@@ -42,7 +45,7 @@ export interface BaseTransaction {
 	readonly value: Uint;
 	// TODO - Investigate if this should actually be data instead of input
 	readonly input: HexStringBytes;
-	chainId?: Uint;
+	readonly chainId?: Uint;
 }
 
 export interface Transaction1559Unsigned extends BaseTransaction {
@@ -257,7 +260,9 @@ export type EthExecutionAPI = {
 
 	// https://github.com/ethereum/execution-apis/blob/main/src/eth/sign.json
 	eth_sign: (address: Address, message: HexStringBytes) => HexString256Bytes;
-	eth_signTransaction: (transaction: TransactionWithSender) => HexStringBytes;
+	eth_signTransaction: (
+		transaction: TransactionWithSender | Partial<TransactionWithSender>,
+	) => HexStringBytes;
 
 	// https://github.com/ethereum/execution-apis/blob/main/src/eth/state.json
 	eth_getBalance: (address: Address, blockNumber: BlockNumberOrTag) => Uint;
@@ -270,7 +275,9 @@ export type EthExecutionAPI = {
 	eth_getCode: (address: Address, blockNumber: BlockNumberOrTag) => HexStringBytes;
 
 	// https://github.com/ethereum/execution-apis/blob/main/src/eth/submit.json
-	eth_sendTransaction: (transaction: TransactionWithSender) => HexString32Bytes;
+	eth_sendTransaction: (
+		transaction: TransactionWithSender | Partial<TransactionWithSender>,
+	) => HexString32Bytes;
 	eth_sendRawTransaction: (transaction: HexStringBytes) => HexString32Bytes;
 
 	// https://geth.ethereum.org/docs/rpc/pubsub

@@ -31,4 +31,16 @@ export class Web3EventEmitter<T extends Web3EventMap> implements Web3Emitter<T>
 	public emit<K extends Web3EventKey<T>>(eventName: K, params: T[K]) {
 		this._emitter.emit(eventName, params);
 	}
+
+	public listenerCount<K extends Web3EventKey<T>>(eventName: K) {
+		return this._emitter.listenerCount(eventName);
+	}
+
+	public listeners<K extends Web3EventKey<T>>(eventName: K) {
+		return this._emitter.listeners(eventName);
+	}
+
+	public eventNames() {
+		return this._emitter.eventNames();
+	}
 }
diff --git a/packages/web3-core/src/types.ts b/packages/web3-core/src/types.ts
@@ -46,6 +46,8 @@ export interface Web3ConfigOptions {
 	transactionBlockTimeout: number;
 	transactionConfirmationBlocks: number;
 	transactionPollingTimeout: number;
+	transactionReceiptPollingInterval: number;
+	transactionConfirmationPollingInterval: number;
 	blockHeaderTimeout: number;
 	maxListenersWarningThreshold: number;
 	defaultNetworkId: Numbers | null;

diff --git a/packages/web3-core/src/web3_config.ts b/packages/web3-core/src/web3_config.ts
@@ -22,6 +22,8 @@ export abstract class Web3Config
 		transactionBlockTimeout: 50,
 		transactionConfirmationBlocks: 24,
 		transactionPollingTimeout: 750,
+		transactionReceiptPollingInterval: 1000,
+		transactionConfirmationPollingInterval: 13000,
 		blockHeaderTimeout: 10,
 		maxListenersWarningThreshold: 100,
 		defaultNetworkId: null,
@@ -118,6 +120,34 @@ export abstract class Web3Config
 		this._config.transactionPollingTimeout = val;
 	}
 
+	public get transactionReceiptPollingInterval() {
+		return this._config.transactionReceiptPollingInterval;
+	}
+
+	public set transactionReceiptPollingInterval(val) {
+		this.emit(Web3ConfigEvent.CONFIG_CHANGE, {
+			name: 'transactionReceiptPollingInterval',
+			oldValue: this._config.transactionReceiptPollingInterval,
+			newValue: val,
+		});
+
+		this._config.transactionReceiptPollingInterval = val;
+	}
+
+	public get transactionConfirmationPollingInterval() {
+		return this._config.transactionConfirmationPollingInterval;
+	}
+
+	public set transactionConfirmationPollingInterval(val) {
+		this.emit(Web3ConfigEvent.CONFIG_CHANGE, {
+			name: 'transactionConfirmationPollingInterval',
+			oldValue: this._config.transactionConfirmationPollingInterval,
+			newValue: val,
+		});
+
+		this._config.transactionConfirmationPollingInterval = val;
+	}
+
 	public get blockHeaderTimeout() {
 		return this._config.blockHeaderTimeout;
 	}

diff --git a/packages/web3-core/src/web3_context.ts b/packages/web3-core/src/web3_context.ts
@@ -9,6 +9,7 @@ export class Web3Context<
 	API extends Web3APISpec,
 	RegisteredSubs extends {
 		[key: string]: Web3SubscriptionConstructor<API>;
+		// eslint-disable-next-line @typescript-eslint/ban-types
 	} = {},
 > extends Web3Config {
 	public static readonly providers = Web3RequestManager.providers;

diff --git a/packages/web3-core/src/web3_subscriptions.ts b/packages/web3-core/src/web3_subscriptions.ts
@@ -104,6 +104,7 @@ export abstract class Web3Subscription<
 
 export type Web3SubscriptionConstructor<
 	API extends Web3APISpec,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	SubscriptionType extends Web3Subscription<any, any, API> = Web3Subscription<any, any, API>,
 > = new (
 	// We accept any type of arguments here and don't deal with this type internally

@@ -29,7 +29,8 @@
 		"web3-core": "4.0.0-alpha.0",
 		"web3-eth-abi": "4.0.0-alpha.0",
 		"web3-utils": "4.0.0-alpha.1",
-		"web3-validator": "0.1.0-alpha.0"
+		"web3-validator": "0.1.0-alpha.0",
+		"web3-eth": "4.0.0-alpha.1"
 	},
 	"devDependencies": {
 		"@humeris/espresso-shot": "^4.0.0",

@@ -14,13 +14,14 @@ import {
 	isAbiFunctionFragment,
 	jsonInterfaceMethodToString,
 } from 'web3-eth-abi';
+import { estimateGas, sendTransaction, call } from 'web3-eth/src/rpc_method_wrappers';
 import {
 	Address,
 	BlockNumberOrTag,
 	BlockTags,
-	hexToNumber,
-	toChecksumAddress,
 	HexString,
+	toChecksumAddress,
+	ValidTypes,
 } from 'web3-utils';
 import { validator } from 'web3-validator';
 import { decodeMethodReturn, encodeEventABI, encodeMethodABI } from './encoding';
@@ -169,14 +170,19 @@ export class Contract<Abi extends ContractAbi>
 				const modifiedOptions = { ...options };
 				delete modifiedOptions.to;
 
-				const txHash = await this._contractMethodSend(
+				const promiEvent = this._contractMethodSend(
 					abi as AbiFunctionFragment,
 					args,
 					modifiedOptions,
 					contractOptions,
 				);
 
-				return txHash;
+				// eslint-disable-next-line no-void
+				void promiEvent.then(res => {
+					this._address = res.contractAddress;
+				});
+
+				return promiEvent;
 
 				// TODO: Use eth-tx functions to
 				//
@@ -194,17 +200,20 @@ export class Contract<Abi extends ContractAbi>
 				// 	provider: this.currentProvider,
 				// });
 			},
-			estimateGas: async (options?: PayableCallOptions, block?: BlockNumberOrTag) => {
+			estimateGas: async <ReturnType extends ValidTypes = ValidTypes.HexString>(
+				options?: PayableCallOptions,
+				returnType?: ReturnType,
+			) => {
 				const modifiedOptions = { ...options };
 				delete modifiedOptions.to;
 
-				return this._contractMethodEstimateGas(
-					abi as AbiFunctionFragment,
-					args,
-					modifiedOptions,
-					block,
+				return this._contractMethodEstimateGas({
+					abi: abi as AbiFunctionFragment,
+					params: args,
+					returnType,
+					options: modifiedOptions,
 					contractOptions,
-				);
+				});
 			},
 			encodeABI: () => encodeMethodABI(abi as AbiFunctionFragment, args, data),
 		};
@@ -297,10 +306,12 @@ export class Contract<Abi extends ContractAbi>
 					call: async (options?: PayableCallOptions, block?: BlockNumberOrTag) =>
 						this._contractMethodCall(abi, params, options, block),
 					// TODO: Use `web3-eth-tx` package to return `PromiEvent` instead.
-					send: async (options?: PayableCallOptions) =>
+					send: (options?: PayableCallOptions) =>
 						this._contractMethodSend(abi, params, options),
-					estimateGas: async (options?: PayableCallOptions, block?: BlockNumberOrTag) =>
-						this._contractMethodEstimateGas(abi, params, options, block),
+					estimateGas: async <ReturnType extends ValidTypes = ValidTypes.HexString>(
+						options?: PayableCallOptions,
+						returnType?: ReturnType,
+					) => this._contractMethodEstimateGas({ abi, params, returnType, options }),
 					encodeABI: () => encodeMethodABI(abi, params),
 				} as unknown as PayableMethodObject<
 					ContractMethod<T>['Inputs'],
@@ -312,10 +323,12 @@ export class Contract<Abi extends ContractAbi>
 				arguments: params,
 				call: async (options?: NonPayableCallOptions, block?: BlockNumberOrTag) =>
 					this._contractMethodCall(abi, params, options, block),
-				send: async (options?: NonPayableCallOptions) =>
+				send: (options?: NonPayableCallOptions) =>
 					this._contractMethodSend(abi, params, options),
-				estimateGas: async (options?: NonPayableCallOptions, block?: BlockNumberOrTag) =>
-					this._contractMethodEstimateGas(abi, params, options, block),
+				estimateGas: async <ReturnType extends ValidTypes = ValidTypes.HexString>(
+					options?: NonPayableCallOptions,
+					returnType?: ReturnType,
+				) => this._contractMethodEstimateGas({ abi, params, returnType, options }),
 				encodeABI: () => encodeMethodABI(abi, params),
 			} as unknown as NonPayableMethodObject<
 				ContractMethod<T>['Inputs'],
@@ -330,68 +343,56 @@ export class Contract<Abi extends ContractAbi>
 		options?: Options,
 		block?: BlockNumberOrTag,
 	) {
-		return decodeMethodReturn(
+		const tx = getEthTxCallParams({
 			abi,
-			await this.requestManager.send({
-				method: 'eth_call',
-				params: [
-					getEthTxCallParams({
-						abi,
-						params,
-						options,
-						contractOptions: this.options,
-					}),
-					block ?? BlockTags.LATEST,
-				],
-			}),
-		);
+			params,
+			options,
+			contractOptions: this.options,
+		});
+
+		return decodeMethodReturn(abi, await call(this, tx, block));
 	}
 
-	private async _contractMethodSend<Options extends PayableCallOptions | NonPayableCallOptions>(
+	private _contractMethodSend<Options extends PayableCallOptions | NonPayableCallOptions>(
 		abi: AbiFunctionFragment,
 		params: unknown[],
 		options?: Options,
 		contractOptions?: ContractOptions,
 	) {
-		return decodeMethodReturn(
+		const tx = getSendTxParams({
 			abi,
-			await this.requestManager.send({
-				method: 'eth_sendTransaction',
-				params: [
-					getSendTxParams({
-						abi,
-						params,
-						options,
-						contractOptions: contractOptions ?? this.options,
-					}),
-				],
-			}),
-		);
+			params,
+			options,
+			contractOptions: contractOptions ?? this.options,
+		});
+
+		return sendTransaction(this, tx);
 	}
 
 	private async _contractMethodEstimateGas<
 		Options extends PayableCallOptions | NonPayableCallOptions,
-	>(
-		abi: AbiFunctionFragment,
-		params: unknown[],
-		options?: Options,
-		block?: BlockNumberOrTag,
-		contractOptions?: ContractOptions,
-	) {
-		return hexToNumber(
-			await this.requestManager.send({
-				method: 'eth_estimateGas',
-				params: [
-					getEstimateGasParams({
-						abi,
-						params,
-						options,
-						contractOptions: contractOptions ?? this.options,
-					}),
-					block ?? BlockTags.LATEST,
-				],
-			}),
-		);
+		ReturnType extends ValidTypes = ValidTypes.HexString,
+	>({
+		abi,
+		params,
+		returnType,
+		options,
+		contractOptions,
+	}: {
+		abi: AbiFunctionFragment;
+		params: unknown[];
+		returnType?: ReturnType;
+		options?: Options;
+		contractOptions?: ContractOptions;
+	}) {
+		const tx = getEstimateGasParams({
+			abi,
+			params,
+			options,
+			contractOptions: contractOptions ?? this.options,
+		});
+
+		return estimateGas(this, tx, BlockTags.LATEST, returnType);
 	}
 
 	// eslint-disable-next-line class-methods-use-this