Update web3-eth-contract to use web3-eth methods

CHANGELOG.md

@@ -357,6 +357,7 @@ 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.
 
 #### web3-net
 
@@ -368,3 +369,4 @@ Released with 1.0.0-beta.37 code base.
 2. `setContent` is not supported in web3-eth-ens 4.x as its deprecated in ENS public resolver (https://github.com/ensdomains/resolvers/blob/master/contracts/PublicResolver.sol)
 3. `getContent` is not supported in web3-eth-ens 4.x as its deprecated in ENS public resolver.
 4. `getMultihash` is not supported in web3-eth-ens 4.x as its deprecated in ENS public resolver.
+

packages/web3-common/src/web3_event_emitter.ts

@@ -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();
+	}
 }

packages/web3-eth-contract/package.json

@@ -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",

packages/web3-eth-contract/src/contract.ts

@@ -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';
@@ -164,47 +165,38 @@ export class Contract<Abi extends ContractAbi>
 
 		return {
 			arguments: args,
-			// TODO: Use `web3-eth-tx` package to return `PromiEvent` instead.
 			send: async (options?: PayableCallOptions) => {
 				const modifiedOptions = { ...options };
 				delete modifiedOptions.to;
 
-				const txHash = await this._contractMethodSend(
+				const promiEvent = this._contractMethodSend(
 					abi as AbiFunctionFragment,
 					args,
 					modifiedOptions,
 					contractOptions,
 				);
 
-				return txHash;
-
-				// TODO: Use eth-tx functions to
-				//
-				// 1. Get the transaction receipt from the above txHash
-				// 2. Extract the contract address from the receipt
-				// 3. Get the code from eth_getCode for the contract address
-				// 4. Return the contract instance with the new address and the code
-				//
-				// return new Contract<Abi>(this._jsonInterface, contractAddress as HexString, {
-				// 	gas: this.options.gas,
-				// 	gasPrice: this.options.gasPrice,
-				// 	gasLimit: this.options.gasLimit,
-				// 	from: this.options.from,
-				// 	data: this.options.data,
-				// 	provider: this.currentProvider,
-				// });
+				// eslint-disable-next-line no-void
+				void promiEvent.then(res => {
+					this._address = res.contractAddress;
+				});
+
+				return promiEvent;
 			},
-			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),
 		};
@@ -296,11 +288,12 @@ export class Contract<Abi extends ContractAbi>
 					arguments: params,
 					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 +305,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 +325,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

packages/web3-eth-contract/src/types.ts

@@ -1,7 +1,8 @@
-import { EthExecutionAPI, PromiEvent, ReceiptInfo } from 'web3-common';
+import { EthExecutionAPI, ReceiptInfo } from 'web3-common';
 import { SupportedProviders } from 'web3-core';
 import { ContractAbi } from 'web3-eth-abi';
-import { Address, BlockNumberOrTag, Bytes, Filter, HexString, Numbers, Uint } from 'web3-utils';
+import { sendTransaction } from 'web3-eth/src/rpc_method_wrappers';
+import { Address, BlockNumberOrTag, Bytes, Filter, HexString, Uint, ValidTypes } from 'web3-utils';
 
 export interface EventLog {
 	event: string;
@@ -43,14 +44,14 @@ export interface ContractInitOptions {
 export type TransactionReceipt = ReceiptInfo;
 
 export interface NonPayableCallOptions {
-	nonce?: Numbers;
-	chainId?: Numbers;
+	nonce?: HexString;
+	chainId?: HexString;
 	from?: Address;
 	to?: Address;
 	data?: HexString;
 	gas?: string;
-	maxPriorityFeePerGas?: Numbers;
-	maxFeePerGas?: Numbers;
+	maxPriorityFeePerGas?: HexString;
+	maxFeePerGas?: HexString;
 	gasPrice?: string;
 }
 
@@ -61,43 +62,21 @@ export interface PayableCallOptions extends NonPayableCallOptions {
 export interface NonPayableMethodObject<Inputs = unknown[], Outputs = unknown[]> {
 	arguments: Inputs;
 	call(tx?: NonPayableCallOptions, block?: BlockNumberOrTag): Promise<Outputs>;
-	send(tx?: NonPayableCallOptions): PromiEvent<
-		TransactionReceipt,
-		{
-			sending: object;
-			sent: object;
-			transactionHash: string;
-			receipt: TransactionReceipt;
-			confirmation: {
-				confirmations: number;
-				receipt: TransactionReceipt;
-				latestBlockHash: HexString;
-			};
-			error: Error;
-		}
-	>;
-	estimateGas(tx?: NonPayableCallOptions): Promise<number>;
+	send(tx?: NonPayableCallOptions): ReturnType<typeof sendTransaction>;
+	estimateGas<ReturnType extends ValidTypes = ValidTypes.HexString>(
+		options?: NonPayableCallOptions,
+		returnType?: ReturnType,
+	): Promise<ReturnType>;
 	encodeABI(): string;
 }
 
 export interface PayableMethodObject<Inputs = unknown[], Outputs = unknown[]> {
 	arguments: Inputs;
 	call(tx?: PayableCallOptions, block?: BlockNumberOrTag): Promise<Outputs>;
-	send(tx?: PayableCallOptions): PromiEvent<
-		TransactionReceipt,
-		{
-			sending: object;
-			sent: object;
-			transactionHash: string;
-			receipt: TransactionReceipt;
-			confirmation: {
-				confirmations: number;
-				receipt: TransactionReceipt;
-				latestBlockHash: HexString;
-			};
-			error: Error;
-		}
-	>;
-	estimateGas(tx?: PayableCallOptions): Promise<number>;
+	send(tx?: PayableCallOptions): ReturnType<typeof sendTransaction>;
+	estimateGas<ReturnType extends ValidTypes = ValidTypes.HexString>(
+		options?: PayableCallOptions,
+		returnType?: ReturnType,
+	): Promise<ReturnType>;
 	encodeABI(): HexString;
 }

packages/web3-eth-contract/src/utils.ts

@@ -1,6 +1,7 @@
-import { TransactionCall, TransactionWithSender } from 'web3-common';
+import { TransactionWithSender } from 'web3-common';
 import { AbiFunctionFragment } from 'web3-eth-abi';
 import { mergeDeep } from 'web3-utils';
+import { TransactionCall } from 'web3-eth/src/types';
 import { encodeMethodABI } from './encoding';
 import { Web3ContractError } from './errors';
 import { NonPayableCallOptions, PayableCallOptions, ContractOptions } from './types';
@@ -15,7 +16,7 @@ export const getSendTxParams = ({
 	params: unknown[];
 	options?: PayableCallOptions | NonPayableCallOptions;
 	contractOptions: ContractOptions;
-}): TransactionWithSender & { data: string } => {
+}): TransactionCall => {
 	if (!options?.to && !contractOptions.address) {
 		throw new Web3ContractError('Contract address not specified');
 	}
@@ -33,7 +34,7 @@ export const getSendTxParams = ({
 			data: contractOptions.data,
 		},
 		options as unknown as Record<string, unknown>,
-	) as unknown as TransactionWithSender & { data: string };
+	) as unknown as TransactionCall;
 
 	if (!txParams.data) {
 		txParams = {
@@ -114,5 +115,5 @@ export const getEstimateGasParams = ({
 		};
 	}
 
-	return txParams;
+	return txParams as TransactionWithSender;
 };