wb3-eth 0.0.1-security → 4.10.0

package/lib/types/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAahC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAK5B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CAUlC,CAAC;AAEF,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,eAAO,MAAM,cAAc;;;CAmB1B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAa7B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2E7B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEjC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;CAgB7B,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqGvB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiG7B,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCrB,CAAC;AACF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;CAmBtB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDpC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;CAsBjC,CAAC;AACF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B5B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;CAgB9B,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BzB,CAAC"}

package/lib/types/types.d.ts

@@ -0,0 +1,51 @@
+import { ContractExecutionError, TransactionRevertedWithoutReasonError, TransactionRevertInstructionError, TransactionRevertWithCustomError, InvalidResponseError, TransactionPollingTimeoutError } from 'web3-errors';
+import { FormatType, ETH_DATA_FORMAT, DataFormat, Bytes, ContractAbi, HexString, Numbers, Transaction, TransactionReceipt, TransactionWithFromAndToLocalWalletIndex, TransactionWithFromLocalWalletIndex, TransactionWithToLocalWalletIndex } from 'web3-types';
+import { Schema } from 'web3-validator';
+export declare type InternalTransaction = FormatType<Transaction, typeof ETH_DATA_FORMAT>;
+export declare type SendTransactionEventsBase<ReturnFormat extends DataFormat, TxType> = {
+    sending: FormatType<TxType, typeof ETH_DATA_FORMAT>;
+    sent: FormatType<TxType, typeof ETH_DATA_FORMAT>;
+    transactionHash: FormatType<Bytes, ReturnFormat>;
+    receipt: FormatType<TransactionReceipt, ReturnFormat>;
+    confirmation: {
+        confirmations: FormatType<Numbers, ReturnFormat>;
+        receipt: FormatType<TransactionReceipt, ReturnFormat>;
+        latestBlockHash: FormatType<Bytes, ReturnFormat>;
+    };
+    error: TransactionRevertedWithoutReasonError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionPollingTimeoutError | InvalidResponseError | ContractExecutionError;
+};
+export declare type SendTransactionEvents<ReturnFormat extends DataFormat> = SendTransactionEventsBase<ReturnFormat, Transaction>;
+export declare type SendSignedTransactionEvents<ReturnFormat extends DataFormat> = SendTransactionEventsBase<ReturnFormat, Bytes>;
+export interface SendTransactionOptions<ResolveType = TransactionReceipt> {
+    ignoreGasPricing?: boolean;
+    transactionResolver?: (receipt: TransactionReceipt) => ResolveType;
+    contractAbi?: ContractAbi;
+    checkRevertBeforeSending?: boolean;
+    ignoreFillingGasLimit?: boolean;
+}
+export interface SendSignedTransactionOptions<ResolveType = TransactionReceipt> {
+    transactionResolver?: (receipt: TransactionReceipt) => ResolveType;
+    contractAbi?: ContractAbi;
+    checkRevertBeforeSending?: boolean;
+}
+export interface RevertReason {
+    reason: string;
+    signature?: HexString;
+    data?: HexString;
+}
+export interface RevertReasonWithCustomError extends RevertReason {
+    customErrorName: string;
+    customErrorDecodedSignature: string;
+    customErrorArguments: Record<string, unknown>;
+}
+export declare type TransactionMiddlewareData = Transaction | TransactionWithFromLocalWalletIndex | TransactionWithToLocalWalletIndex | TransactionWithFromAndToLocalWalletIndex;
+export interface TransactionMiddleware {
+    processTransaction(transaction: TransactionMiddlewareData, options?: {
+        [key: string]: unknown;
+    }): Promise<TransactionMiddlewareData>;
+}
+export declare type CustomTransactionSchema = {
+    type: string;
+    properties: Record<string, Schema>;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/lib/types/utils/decode_signed_transaction.d.ts

@@ -0,0 +1,14 @@
+import { DataFormat, HexStringBytes, SignedTransactionInfoAPI } from 'web3-types';
+import { type CustomTransactionSchema } from '../types.js';
+/**
+ * Decodes an [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/#top) encoded transaction.
+ *
+ * @param encodedSignedTransaction The RLP encoded transaction.
+ * @param returnFormat ({@link DataFormat} Specifies how the return data should be formatted.
+ * @returns {@link SignedTransactionInfoAPI}, an object containing the RLP encoded signed transaction (accessed via the `raw` property) and the signed transaction object (accessed via the `tx` property).
+ */
+export declare function decodeSignedTransaction<ReturnFormat extends DataFormat>(encodedSignedTransaction: HexStringBytes, returnFormat: ReturnFormat, options?: {
+    fillInputAndData?: boolean;
+    transactionSchema?: CustomTransactionSchema;
+}): SignedTransactionInfoAPI;
+//# sourceMappingURL=decode_signed_transaction.d.ts.map

package/lib/types/utils/decode_signed_transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_signed_transaction.d.ts","sourceRoot":"","sources":["../../../src/utils/decode_signed_transaction.ts"],"names":[],"mappings":"AAgBA,OAAO,EACN,UAAU,EACV,cAAc,EACd,wBAAwB,EAExB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,SAAS,UAAU,EACtE,wBAAwB,EAAE,cAAc,EACxC,YAAY,EAAE,YAAY,EAC1B,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAA;CAEjF,GACC,wBAAwB,CAkB1B"}

package/lib/types/utils/decoding.d.ts

@@ -0,0 +1,5 @@
+import { AbiEventFragment, LogsInput, DataFormat, EventLog, ContractAbiWithSignature } from 'web3-types';
+export declare const decodeEventABI: (event: AbiEventFragment & {
+    signature: string;
+}, data: LogsInput, jsonInterface: ContractAbiWithSignature, returnFormat?: DataFormat) => EventLog;
+//# sourceMappingURL=decoding.d.ts.map

package/lib/types/utils/decoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoding.d.ts","sourceRoot":"","sources":["../../../src/utils/decoding.ts"],"names":[],"mappings":"AAmBA,OAAO,EACN,gBAAgB,EAChB,SAAS,EACT,UAAU,EAEV,QAAQ,EACR,wBAAwB,EACxB,MAAM,YAAY,CAAC;AAOpB,eAAO,MAAM,cAAc,UACnB,gBAAgB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,QACzC,SAAS,0DAED,UAAU,KACtB,QAwDF,CAAC"}

package/lib/types/utils/detect_transaction_type.d.ts

@@ -0,0 +1,7 @@
+import { TransactionTypeParser, Web3Context } from 'web3-core';
+import { EthExecutionAPI } from 'web3-types';
+import { InternalTransaction } from '../types.js';
+export declare const defaultTransactionTypeParser: TransactionTypeParser;
+export declare const detectTransactionType: (transaction: InternalTransaction, web3Context?: Web3Context<EthExecutionAPI>) => string | undefined;
+export declare const detectRawTransactionType: (transaction: Uint8Array) => string;
+//# sourceMappingURL=detect_transaction_type.d.ts.map

package/lib/types/utils/detect_transaction_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect_transaction_type.d.ts","sourceRoot":"","sources":["../../../src/utils/detect_transaction_type.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAkD,MAAM,YAAY,CAAC;AAI7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAsDlD,eAAO,MAAM,4BAA4B,EAAE,qBAuD1C,CAAC;AAEF,eAAO,MAAM,qBAAqB,gBACpB,mBAAmB,gBAClB,YAAY,eAAe,CAAC,uBAIzC,CAAC;AAEH,eAAO,MAAM,wBAAwB,gBAAiB,UAAU,WACV,CAAC"}

package/lib/types/utils/format_transaction.d.ts

@@ -0,0 +1,8 @@
+import { Transaction, DataFormat, DEFAULT_RETURN_FORMAT, FormatType } from 'web3-types';
+import { ValidationSchemaInput } from 'web3-validator';
+import { type CustomTransactionSchema } from '../types.js';
+export declare function formatTransaction<ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT, TransactionType extends Transaction = Transaction>(transaction: TransactionType, returnFormat?: ReturnFormat, options?: {
+    transactionSchema?: ValidationSchemaInput | CustomTransactionSchema | undefined;
+    fillInputAndData?: boolean;
+}): FormatType<TransactionType, ReturnFormat>;
+//# sourceMappingURL=format_transaction.d.ts.map

package/lib/types/utils/format_transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format_transaction.d.ts","sourceRoot":"","sources":["../../../src/utils/format_transaction.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxF,OAAO,EAAa,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAKlE,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,wBAAgB,iBAAiB,CAChC,YAAY,SAAS,UAAU,GAAG,OAAO,qBAAqB,EAC9D,eAAe,SAAS,WAAW,GAAG,WAAW,EAEjD,WAAW,EAAE,eAAe,EAC5B,YAAY,GAAE,YAAoD,EAClE,OAAO,GAAE;IACR,iBAAiB,CAAC,EAAE,qBAAqB,GAAG,uBAAuB,GAAG,SAAS,CAAC;IAChF,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAI3B,GACC,UAAU,CAAC,eAAe,EAAE,YAAY,CAAC,CAsC3C"}

package/lib/types/utils/get_revert_reason.d.ts

@@ -0,0 +1,13 @@
+import { Web3Context } from 'web3-core';
+import { ContractAbi, DataFormat, DEFAULT_RETURN_FORMAT, EthExecutionAPI, TransactionCall } from 'web3-types';
+import { RevertReason, RevertReasonWithCustomError } from '../types.js';
+export declare const parseTransactionError: (error: unknown, contractAbi?: ContractAbi) => string | RevertReason;
+/**
+ *	Returns the revert reason generated by the EVM if the transaction were to be executed.
+ *
+ * @param web3Context - ({@link Web3Context}) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
+ * @param transaction - A transaction object where all properties are optional except `to`, however it's recommended to include the `from` property or it may default to `0x0000000000000000000000000000000000000000` depending on your node or provider.
+ * @returns `undefined` if no revert reason was given, a revert reason object, a revert reason string, or an `unknown` error
+ */
+export declare function getRevertReason<ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT>(web3Context: Web3Context<EthExecutionAPI>, transaction: TransactionCall, contractAbi?: ContractAbi, returnFormat?: ReturnFormat): Promise<undefined | RevertReason | RevertReasonWithCustomError | string>;
+//# sourceMappingURL=get_revert_reason.d.ts.map

package/lib/types/utils/get_revert_reason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_revert_reason.d.ts","sourceRoot":"","sources":["../../../src/utils/get_revert_reason.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAQxC,OAAO,EAEN,WAAW,EACX,UAAU,EACV,qBAAqB,EACrB,eAAe,EACf,eAAe,EACf,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,YAAY,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAExE,eAAO,MAAM,qBAAqB,UAAW,OAAO,gBAAgB,WAAW,0BAkC9E,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,eAAe,CACpC,YAAY,SAAS,UAAU,GAAG,OAAO,qBAAqB,EAE9D,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,WAAW,EAAE,eAAe,EAC5B,WAAW,CAAC,EAAE,WAAW,EACzB,YAAY,GAAE,YAA8D,GAC1E,OAAO,CAAC,SAAS,GAAG,YAAY,GAAG,2BAA2B,GAAG,MAAM,CAAC,CAO1E"}

package/lib/types/utils/get_transaction_error.d.ts

@@ -0,0 +1,153 @@
+import { Web3Context } from 'web3-core';
+import { TransactionRevertedWithoutReasonError, TransactionRevertInstructionError, TransactionRevertWithCustomError } from 'web3-errors';
+import { DataFormat, FormatType, ContractAbi, TransactionCall, TransactionReceipt } from 'web3-types';
+import { RevertReason, RevertReasonWithCustomError } from '../types.js';
+export declare function getTransactionError<ReturnFormat extends DataFormat>(web3Context: Web3Context, transactionFormatted?: TransactionCall, transactionReceiptFormatted?: FormatType<TransactionReceipt, ReturnFormat>, receivedError?: unknown, contractAbi?: ContractAbi, knownReason?: string | RevertReason | RevertReasonWithCustomError): Promise<TransactionRevertedWithoutReasonError<{
+    readonly transactionHash: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly transactionIndex: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly blockHash: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly blockNumber: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly from: string;
+    readonly to: string;
+    readonly cumulativeGasUsed: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly gasUsed: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly effectiveGasPrice?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+    readonly contractAddress?: string | undefined;
+    readonly logs: {
+        readonly id?: string | undefined;
+        readonly removed?: boolean | undefined;
+        readonly logIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly transactionIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly transactionHash?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly blockHash?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly blockNumber?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly address?: string | undefined;
+        readonly data?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly topics?: import("web3-types").ByteTypes[ReturnFormat["bytes"]][] | undefined;
+    }[];
+    readonly logsBloom: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly root: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly status: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly type?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+    events?: {
+        [x: string]: {
+            readonly event: string;
+            readonly id?: string | undefined;
+            readonly logIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly transactionIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly transactionHash?: string | undefined;
+            readonly blockHash?: string | undefined;
+            readonly blockNumber?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly address: string;
+            readonly topics: string[];
+            readonly data: string;
+            readonly raw?: {
+                data: string;
+                topics: unknown[];
+            } | undefined;
+            readonly returnValues: {
+                [x: string]: unknown;
+            };
+            readonly signature?: string | undefined;
+        };
+    } | undefined;
+}> | TransactionRevertInstructionError<{
+    readonly transactionHash: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly transactionIndex: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly blockHash: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly blockNumber: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly from: string;
+    readonly to: string;
+    readonly cumulativeGasUsed: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly gasUsed: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly effectiveGasPrice?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+    readonly contractAddress?: string | undefined;
+    readonly logs: {
+        readonly id?: string | undefined;
+        readonly removed?: boolean | undefined;
+        readonly logIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly transactionIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly transactionHash?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly blockHash?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly blockNumber?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly address?: string | undefined;
+        readonly data?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly topics?: import("web3-types").ByteTypes[ReturnFormat["bytes"]][] | undefined;
+    }[];
+    readonly logsBloom: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly root: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly status: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly type?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+    events?: {
+        [x: string]: {
+            readonly event: string;
+            readonly id?: string | undefined;
+            readonly logIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly transactionIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly transactionHash?: string | undefined;
+            readonly blockHash?: string | undefined;
+            readonly blockNumber?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly address: string;
+            readonly topics: string[];
+            readonly data: string;
+            readonly raw?: {
+                data: string;
+                topics: unknown[];
+            } | undefined;
+            readonly returnValues: {
+                [x: string]: unknown;
+            };
+            readonly signature?: string | undefined;
+        };
+    } | undefined;
+}> | TransactionRevertWithCustomError<{
+    readonly transactionHash: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly transactionIndex: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly blockHash: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly blockNumber: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly from: string;
+    readonly to: string;
+    readonly cumulativeGasUsed: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly gasUsed: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly effectiveGasPrice?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+    readonly contractAddress?: string | undefined;
+    readonly logs: {
+        readonly id?: string | undefined;
+        readonly removed?: boolean | undefined;
+        readonly logIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly transactionIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly transactionHash?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly blockHash?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly blockNumber?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+        readonly address?: string | undefined;
+        readonly data?: import("web3-types").ByteTypes[ReturnFormat["bytes"]] | undefined;
+        readonly topics?: import("web3-types").ByteTypes[ReturnFormat["bytes"]][] | undefined;
+    }[];
+    readonly logsBloom: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly root: import("web3-types").ByteTypes[ReturnFormat["bytes"]];
+    readonly status: import("web3-types").NumberTypes[ReturnFormat["number"]];
+    readonly type?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+    events?: {
+        [x: string]: {
+            readonly event: string;
+            readonly id?: string | undefined;
+            readonly logIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly transactionIndex?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly transactionHash?: string | undefined;
+            readonly blockHash?: string | undefined;
+            readonly blockNumber?: import("web3-types").NumberTypes[ReturnFormat["number"]] | undefined;
+            readonly address: string;
+            readonly topics: string[];
+            readonly data: string;
+            readonly raw?: {
+                data: string;
+                topics: unknown[];
+            } | undefined;
+            readonly returnValues: {
+                [x: string]: unknown;
+            };
+            readonly signature?: string | undefined;
+        };
+    } | undefined;
+}>>;
+//# sourceMappingURL=get_transaction_error.d.ts.map

package/lib/types/utils/get_transaction_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_transaction_error.d.ts","sourceRoot":"","sources":["../../../src/utils/get_transaction_error.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EACN,qCAAqC,EACrC,iCAAiC,EACjC,gCAAgC,EAChC,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,UAAU,EACV,UAAU,EACV,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAIxE,wBAAsB,mBAAmB,CAAC,YAAY,SAAS,UAAU,EACxE,WAAW,EAAE,WAAW,EACxB,oBAAoB,CAAC,EAAE,eAAe,EACtC,2BAA2B,CAAC,EAAE,UAAU,CAAC,kBAAkB,EAAE,YAAY,CAAC,EAC1E,aAAa,CAAC,EAAE,OAAO,EACvB,WAAW,CAAC,EAAE,WAAW,EACzB,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoDjE"}

package/lib/types/utils/get_transaction_gas_pricing.d.ts

@@ -0,0 +1,9 @@
+import { Web3Context } from 'web3-core';
+import { EthExecutionAPI, Numbers, DataFormat, FormatType } from 'web3-types';
+import { InternalTransaction } from '../types.js';
+export declare function getTransactionGasPricing<ReturnFormat extends DataFormat>(transaction: InternalTransaction, web3Context: Web3Context<EthExecutionAPI>, returnFormat: ReturnFormat): Promise<FormatType<{
+    gasPrice?: Numbers;
+    maxPriorityFeePerGas?: Numbers;
+    maxFeePerGas?: Numbers;
+}, ReturnFormat> | undefined>;
+//# sourceMappingURL=get_transaction_gas_pricing.d.ts.map

package/lib/types/utils/get_transaction_gas_pricing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_transaction_gas_pricing.d.ts","sourceRoot":"","sources":["../../../src/utils/get_transaction_gas_pricing.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EACN,eAAe,EACf,OAAO,EAEP,UAAU,EACV,UAAU,EAEV,MAAM,YAAY,CAAC;AAMpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AA8ClD,wBAAsB,wBAAwB,CAAC,YAAY,SAAS,UAAU,EAC7E,WAAW,EAAE,mBAAmB,EAChC,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,YAAY,EAAE,YAAY,GACxB,OAAO,CACP,UAAU,CACV;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,EAC9E,YAAY,CACX,GACD,SAAS,CACX,CA6BA"}

package/lib/types/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './detect_transaction_type.js';
+export * from './format_transaction.js';
+export * from './prepare_transaction_for_signing.js';
+export * from './transaction_builder.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAiBA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,0BAA0B,CAAC"}

package/lib/types/utils/prepare_transaction_for_signing.d.ts

@@ -0,0 +1,4 @@
+import { EthExecutionAPI, HexString, Transaction } from 'web3-types';
+import { Web3Context } from 'web3-core';
+export declare const prepareTransactionForSigning: (transaction: Transaction, web3Context: Web3Context<EthExecutionAPI>, privateKey?: HexString | Uint8Array, fillGasPrice?: boolean, fillGasLimit?: boolean) => Promise<import("web3-eth-accounts").TypedTransaction>;
+//# sourceMappingURL=prepare_transaction_for_signing.d.ts.map

package/lib/types/utils/prepare_transaction_for_signing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare_transaction_for_signing.d.ts","sourceRoot":"","sources":["../../../src/utils/prepare_transaction_for_signing.ts"],"names":[],"mappings":"AAiBA,OAAO,EACN,eAAe,EACf,SAAS,EAIT,WAAW,EAIX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AA+FxC,eAAO,MAAM,4BAA4B,gBAC3B,WAAW,eACX,YAAY,eAAe,CAAC,eAC5B,SAAS,GAAG,UAAU,0GA2BnC,CAAC"}

package/lib/types/utils/reject_if_block_timeout.d.ts

@@ -0,0 +1,7 @@
+import { EthExecutionAPI, Bytes } from 'web3-types';
+import { Web3Context } from 'web3-core';
+export interface ResourceCleaner {
+    clean: () => void;
+}
+export declare function rejectIfBlockTimeout(web3Context: Web3Context<EthExecutionAPI>, transactionHash?: Bytes): Promise<[Promise<never>, ResourceCleaner]>;
+//# sourceMappingURL=reject_if_block_timeout.d.ts.map

package/lib/types/utils/reject_if_block_timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject_if_block_timeout.d.ts","sourceRoot":"","sources":["../../../src/utils/reject_if_block_timeout.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,eAAe,EAAE,KAAK,EAAuC,MAAM,YAAY,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AASxC,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,IAAI,CAAC;CAClB;AAkID,wBAAsB,oBAAoB,CACzC,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,eAAe,CAAC,EAAE,KAAK,GACrB,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC,CAAC,CAc5C"}

package/lib/types/utils/send_tx_helper.d.ts

@@ -0,0 +1,44 @@
+import { FormatType, DataFormat, EthExecutionAPI, Web3BaseWalletAccount, HexString, TransactionReceipt, Transaction, TransactionCall, TransactionWithFromLocalWalletIndex, TransactionWithToLocalWalletIndex, TransactionWithFromAndToLocalWalletIndex, TransactionHash } from 'web3-types';
+import { Web3Context, Web3PromiEvent } from 'web3-core';
+import { JsonSchema } from 'web3-validator';
+import { SendSignedTransactionEvents, SendTransactionEvents, SendTransactionOptions } from '../types.js';
+export declare class SendTxHelper<ReturnFormat extends DataFormat, ResolveType = FormatType<TransactionReceipt, ReturnFormat>, TxType = Transaction | TransactionWithFromLocalWalletIndex | TransactionWithToLocalWalletIndex | TransactionWithFromAndToLocalWalletIndex> {
+    private readonly web3Context;
+    private readonly promiEvent;
+    private readonly options;
+    private readonly returnFormat;
+    constructor({ options, web3Context, promiEvent, returnFormat, }: {
+        web3Context: Web3Context<EthExecutionAPI>;
+        options: SendTransactionOptions<ResolveType>;
+        promiEvent: Web3PromiEvent<ResolveType, SendSignedTransactionEvents<ReturnFormat> | SendTransactionEvents<ReturnFormat>>;
+        returnFormat: ReturnFormat;
+    });
+    getReceiptWithEvents(data: TransactionReceipt): ResolveType;
+    checkRevertBeforeSending(tx: TransactionCall): Promise<void>;
+    emitSending(tx: TxType | HexString): void;
+    populateGasPrice({ transactionFormatted, transaction, }: {
+        transactionFormatted: TxType;
+        transaction: TxType;
+    }): Promise<TxType>;
+    signAndSend({ wallet, tx, }: {
+        wallet: Web3BaseWalletAccount | undefined;
+        tx: TxType;
+    }): Promise<string>;
+    emitSent(tx: TxType | HexString): void;
+    emitTransactionHash(hash: string & Uint8Array): void;
+    emitReceipt(receipt: ResolveType): void;
+    handleError({ error, tx }: {
+        error: unknown;
+        tx: TransactionCall;
+    }): Promise<unknown>;
+    emitConfirmation({ receipt, transactionHash, customTransactionReceiptSchema, }: {
+        receipt: ResolveType;
+        transactionHash: TransactionHash;
+        customTransactionReceiptSchema?: JsonSchema;
+    }): void;
+    handleResolve({ receipt, tx }: {
+        receipt: ResolveType;
+        tx: TransactionCall;
+    }): Promise<ResolveType>;
+}
+//# sourceMappingURL=send_tx_helper.d.ts.map

package/lib/types/utils/send_tx_helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send_tx_helper.d.ts","sourceRoot":"","sources":["../../../src/utils/send_tx_helper.ts"],"names":[],"mappings":"AAgBA,OAAO,EAEN,UAAU,EACV,UAAU,EACV,eAAe,EAEf,qBAAqB,EACrB,SAAS,EACT,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,mCAAmC,EACnC,iCAAiC,EACjC,wCAAwC,EAExC,eAAe,EAEf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAoB,cAAc,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EAAa,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAWvD,OAAO,EACN,2BAA2B,EAC3B,qBAAqB,EACrB,sBAAsB,EACtB,MAAM,aAAa,CAAC;AAcrB,qBAAa,YAAY,CACxB,YAAY,SAAS,UAAU,EAC/B,WAAW,GAAG,UAAU,CAAC,kBAAkB,EAAE,YAAY,CAAC,EAC1D,MAAM,GACH,WAAW,GACX,mCAAmC,GACnC,iCAAiC,GACjC,wCAAwC;IAE3C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAGzB;IACF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEtB;IACF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;gBACzB,EAClB,OAAO,EACP,WAAW,EACX,UAAU,EACV,YAAY,GACZ,EAAE;QACF,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC;QAC1C,OAAO,EAAE,sBAAsB,CAAC,WAAW,CAAC,CAAC;QAC7C,UAAU,EAAE,cAAc,CACzB,WAAW,EACX,2BAA2B,CAAC,YAAY,CAAC,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAC/E,CAAC;QACF,YAAY,EAAE,YAAY,CAAC;KAC3B;IAOM,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW;IAoBrD,wBAAwB,CAAC,EAAE,EAAE,eAAe;IA4BlD,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS;IAM5B,gBAAgB,CAAC,EAC7B,oBAAoB,EACpB,WAAW,GACX,EAAE;QACF,oBAAoB,EAAE,MAAM,CAAC;QAC7B,WAAW,EAAE,MAAM,CAAC;KACpB,GAAG,OAAO,CAAC,MAAM,CAAC;IAwBN,WAAW,CAAC,EACxB,MAAM,EACN,EAAE,GACF,EAAE;QACF,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;QAC1C,EAAE,EAAE,MAAM,CAAC;KACX;IAwBM,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS;IAK/B,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM7C,WAAW,CAAC,OAAO,EAAE,WAAW;IAc1B,WAAW,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,EAAE,EAAE,eAAe,CAAA;KAAE;IA4BxE,gBAAgB,CAAC,EACvB,OAAO,EACP,eAAe,EACf,8BAA8B,GAC9B,EAAE;QACF,OAAO,EAAE,WAAW,CAAC;QACrB,eAAe,EAAE,eAAe,CAAC;QACjC,8BAA8B,CAAC,EAAE,UAAU,CAAC;KAC5C;IAiBY,aAAa,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE;QAAE,OAAO,EAAE,WAAW,CAAC;QAAC,EAAE,EAAE,eAAe,CAAA;KAAE;CAsBzF"}

package/lib/types/utils/transaction_builder.d.ts

@@ -0,0 +1,20 @@
+import { EthExecutionAPI, Address, HexString, Transaction, TransactionWithFromLocalWalletIndex, TransactionWithToLocalWalletIndex, TransactionWithFromAndToLocalWalletIndex, Web3NetAPI, DataFormat, FormatType, ETH_DATA_FORMAT } from 'web3-types';
+import { Web3Context } from 'web3-core';
+export declare const getTransactionFromOrToAttr: (attr: 'from' | 'to', web3Context: Web3Context<EthExecutionAPI>, transaction?: Transaction | TransactionWithFromLocalWalletIndex | TransactionWithToLocalWalletIndex | TransactionWithFromAndToLocalWalletIndex, privateKey?: HexString | Uint8Array) => Address | undefined;
+export declare const getTransactionNonce: <ReturnFormat extends DataFormat>(web3Context: Web3Context<EthExecutionAPI>, address?: Address, returnFormat?: ReturnFormat) => Promise<import("web3-types").NumberTypes[ReturnFormat["number"]]>;
+export declare const getTransactionType: (transaction: FormatType<Transaction, typeof ETH_DATA_FORMAT>, web3Context: Web3Context<EthExecutionAPI>) => string | undefined;
+export declare function defaultTransactionBuilder<ReturnType = Transaction>(options: {
+    transaction: Transaction;
+    web3Context: Web3Context<EthExecutionAPI & Web3NetAPI>;
+    privateKey?: HexString | Uint8Array;
+    fillGasPrice?: boolean;
+    fillGasLimit?: boolean;
+}): Promise<ReturnType>;
+export declare const transactionBuilder: <ReturnType_1 = Transaction>(options: {
+    transaction: Transaction;
+    web3Context: Web3Context<EthExecutionAPI>;
+    privateKey?: HexString | Uint8Array;
+    fillGasPrice?: boolean;
+    fillGasLimit?: boolean;
+}) => Promise<ReturnType_1>;
+//# sourceMappingURL=transaction_builder.d.ts.map

package/lib/types/utils/transaction_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction_builder.d.ts","sourceRoot":"","sources":["../../../src/utils/transaction_builder.ts"],"names":[],"mappings":"AAiBA,OAAO,EACN,eAAe,EACf,OAAO,EACP,SAAS,EAGT,WAAW,EACX,mCAAmC,EACnC,iCAAiC,EACjC,wCAAwC,EAExC,UAAU,EAEV,UAAU,EACV,UAAU,EACV,eAAe,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAqBxC,eAAO,MAAM,0BAA0B,SAChC,MAAM,GAAG,IAAI,eACN,YAAY,eAAe,CAAC,gBAEtC,WAAW,GACX,mCAAmC,GACnC,iCAAiC,GACjC,wCAAwC,eAC9B,SAAS,GAAG,UAAU,KACjC,OAAO,GAAG,SA+BZ,CAAC;AAEF,eAAO,MAAM,mBAAmB,iDAClB,YAAY,eAAe,CAAC,YAC/B,OAAO,mGASjB,CAAC;AAEF,eAAO,MAAM,kBAAkB,gBACjB,WAAW,WAAW,EAAE,sBAAsB,CAAC,eAC/C,YAAY,eAAe,CAAC,uBAQzC,CAAC;AAIF,wBAAsB,yBAAyB,CAAC,UAAU,GAAG,WAAW,EAAE,OAAO,EAAE;IAClF,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,WAAW,CAAC,eAAe,GAAG,UAAU,CAAC,CAAC;IACvD,UAAU,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,UAAU,CAAC,CAsHtB;AAED,eAAO,MAAM,kBAAkB,wCACrB;IACR,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,YAAY,eAAe,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB,0BAM0B,CAAC"}

package/lib/types/utils/try_send_transaction.d.ts

@@ -0,0 +1,12 @@
+import { Web3Context } from 'web3-core';
+import { EthExecutionAPI, Bytes } from 'web3-types';
+import { AsyncFunction } from 'web3-utils';
+/**
+ * An internal function to send a transaction or throws if sending did not finish during the timeout during the blocks-timeout.
+ * @param web3Context - the context to read the configurations from
+ * @param sendTransactionFunc - the function that will send the transaction (could be sendTransaction or sendRawTransaction)
+ * @param transactionHash - to be used inside the exception message if there will be any exceptions.
+ * @returns the Promise<string> returned by the `sendTransactionFunc`.
+ */
+export declare function trySendTransaction(web3Context: Web3Context<EthExecutionAPI>, sendTransactionFunc: AsyncFunction<string>, transactionHash?: Bytes): Promise<string>;
+//# sourceMappingURL=try_send_transaction.d.ts.map

package/lib/types/utils/try_send_transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"try_send_transaction.d.ts","sourceRoot":"","sources":["../../../src/utils/try_send_transaction.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,aAAa,EAAmB,MAAM,YAAY,CAAC;AAM5D;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACvC,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,mBAAmB,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1C,eAAe,CAAC,EAAE,KAAK,GACrB,OAAO,CAAC,MAAM,CAAC,CAyBjB"}

package/lib/types/utils/wait_for_transaction_receipt.d.ts

@@ -0,0 +1,4 @@
+import { Web3Context } from 'web3-core';
+import { EthExecutionAPI, Bytes, TransactionReceipt, DataFormat } from 'web3-types';
+export declare function waitForTransactionReceipt<ReturnFormat extends DataFormat>(web3Context: Web3Context<EthExecutionAPI>, transactionHash: Bytes, returnFormat: ReturnFormat, customGetTransactionReceipt?: (web3Context: Web3Context<EthExecutionAPI>, transactionHash: Bytes, returnFormat: ReturnFormat) => Promise<TransactionReceipt>): Promise<TransactionReceipt>;
+//# sourceMappingURL=wait_for_transaction_receipt.d.ts.map

package/lib/types/utils/wait_for_transaction_receipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait_for_transaction_receipt.d.ts","sourceRoot":"","sources":["../../../src/utils/wait_for_transaction_receipt.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AASpF,wBAAsB,yBAAyB,CAAC,YAAY,SAAS,UAAU,EAC9E,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,eAAe,EAAE,KAAK,EACtB,YAAY,EAAE,YAAY,EAC1B,2BAA2B,CAAC,EAAE,CAC7B,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,eAAe,EAAE,KAAK,EACtB,YAAY,EAAE,YAAY,KACtB,OAAO,CAAC,kBAAkB,CAAC,GAC9B,OAAO,CAAC,kBAAkB,CAAC,CA6C7B"}

package/lib/types/utils/watch_transaction_by_polling.d.ts

@@ -0,0 +1,20 @@
+import { EthExecutionAPI, TransactionReceipt } from 'web3-types';
+import { Web3Context, Web3PromiEvent } from 'web3-core';
+import { DataFormat } from 'web3-types';
+import { JsonSchema } from 'web3-validator';
+import { SendSignedTransactionEvents, SendTransactionEvents } from '../types.js';
+export declare type Web3PromiEventEventTypeBase<ReturnFormat extends DataFormat> = SendTransactionEvents<ReturnFormat> | SendSignedTransactionEvents<ReturnFormat>;
+export declare type WaitProps<ReturnFormat extends DataFormat, ResolveType = TransactionReceipt> = {
+    web3Context: Web3Context<EthExecutionAPI>;
+    transactionReceipt: TransactionReceipt;
+    customTransactionReceiptSchema?: JsonSchema;
+    transactionPromiEvent: Web3PromiEvent<ResolveType, Web3PromiEventEventTypeBase<ReturnFormat>>;
+    returnFormat: ReturnFormat;
+};
+/**
+ * This function watches a Transaction by subscribing to new heads.
+ * It is used by `watchTransactionForConfirmations`, in case the provider does not support subscription.
+ * And it is also used by `watchTransactionBySubscription`, as a fallback, if the subscription failed for any reason.
+ */
+export declare const watchTransactionByPolling: <ReturnFormat extends DataFormat, ResolveType = TransactionReceipt>({ web3Context, transactionReceipt, transactionPromiEvent, customTransactionReceiptSchema, returnFormat, }: WaitProps<ReturnFormat, ResolveType>) => void;
+//# sourceMappingURL=watch_transaction_by_polling.d.ts.map

package/lib/types/utils/watch_transaction_by_polling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch_transaction_by_polling.d.ts","sourceRoot":"","sources":["../../../src/utils/watch_transaction_by_polling.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAS,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAIxD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,2BAA2B,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGjF,oBAAY,2BAA2B,CAAC,YAAY,SAAS,UAAU,IACpE,qBAAqB,CAAC,YAAY,CAAC,GACnC,2BAA2B,CAAC,YAAY,CAAC,CAAC;AAE7C,oBAAY,SAAS,CAAC,YAAY,SAAS,UAAU,EAAE,WAAW,GAAG,kBAAkB,IAAI;IAC1F,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC;IAC1C,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,8BAA8B,CAAC,EAAE,UAAU,CAAC;IAC5C,qBAAqB,EAAE,cAAc,CAAC,WAAW,EAAE,2BAA2B,CAAC,YAAY,CAAC,CAAC,CAAC;IAC9F,YAAY,EAAE,YAAY,CAAC;CAC3B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,8NA6CrC,CAAC"}

package/lib/types/utils/watch_transaction_by_subscription.d.ts

@@ -0,0 +1,9 @@
+import { TransactionReceipt } from 'web3-types';
+import { DataFormat } from 'web3-types';
+import { WaitProps } from './watch_transaction_by_polling.js';
+/**
+ * This function watches a Transaction by subscribing to new heads.
+ * It is used by `watchTransactionForConfirmations`, in case the provider supports subscription.
+ */
+export declare const watchTransactionBySubscription: <ReturnFormat extends DataFormat, ResolveType = TransactionReceipt>({ web3Context, transactionReceipt, transactionPromiEvent, customTransactionReceiptSchema, returnFormat, }: WaitProps<ReturnFormat, ResolveType>) => void;
+//# sourceMappingURL=watch_transaction_by_subscription.d.ts.map

package/lib/types/utils/watch_transaction_by_subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch_transaction_by_subscription.d.ts","sourceRoot":"","sources":["../../../src/utils/watch_transaction_by_subscription.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAqC,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGnF,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxC,OAAO,EAAE,SAAS,EAA6B,MAAM,mCAAmC,CAAC;AACzF;;;GAGG;AACH,eAAO,MAAM,8BAA8B,8NA4F1C,CAAC"}

package/lib/types/utils/watch_transaction_for_confirmations.d.ts

@@ -0,0 +1,7 @@
+import { Bytes, EthExecutionAPI, TransactionReceipt } from 'web3-types';
+import { Web3Context, Web3PromiEvent } from 'web3-core';
+import { JsonSchema } from 'web3-validator';
+import { DataFormat } from 'web3-types';
+import { Web3PromiEventEventTypeBase } from './watch_transaction_by_polling.js';
+export declare function watchTransactionForConfirmations<ReturnFormat extends DataFormat, Web3PromiEventEventType extends Web3PromiEventEventTypeBase<ReturnFormat>, ResolveType = TransactionReceipt>(web3Context: Web3Context<EthExecutionAPI>, transactionPromiEvent: Web3PromiEvent<ResolveType, Web3PromiEventEventType>, transactionReceipt: TransactionReceipt, transactionHash: Bytes, returnFormat: ReturnFormat, customTransactionReceiptSchema?: JsonSchema): void;
+//# sourceMappingURL=watch_transaction_for_confirmations.d.ts.map

package/lib/types/utils/watch_transaction_for_confirmations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch_transaction_for_confirmations.d.ts","sourceRoot":"","sources":["../../../src/utils/watch_transaction_for_confirmations.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,EAAE,eAAe,EAAoB,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAAa,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAMvD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAEN,2BAA2B,EAC3B,MAAM,mCAAmC,CAAC;AAG3C,wBAAgB,gCAAgC,CAC/C,YAAY,SAAS,UAAU,EAC/B,uBAAuB,SAAS,2BAA2B,CAAC,YAAY,CAAC,EACzE,WAAW,GAAG,kBAAkB,EAEhC,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,EACzC,qBAAqB,EAAE,cAAc,CAAC,WAAW,EAAE,uBAAuB,CAAC,EAC3E,kBAAkB,EAAE,kBAAkB,EACtC,eAAe,EAAE,KAAK,EACtB,YAAY,EAAE,YAAY,EAC1B,8BAA8B,CAAC,EAAE,UAAU,QA0C3C"}

package/lib/types/validation.d.ts

@@ -0,0 +1,27 @@
+import { AccessList, AccessListEntry, BaseTransactionAPI, Transaction1559UnsignedAPI, Transaction2930UnsignedAPI, TransactionCall, TransactionLegacyUnsignedAPI, TransactionWithSenderAPI } from 'web3-types';
+import { CustomTransactionSchema, InternalTransaction } from './types.js';
+export declare function isBaseTransaction(value: BaseTransactionAPI): boolean;
+export declare function isAccessListEntry(value: AccessListEntry): boolean;
+export declare function isAccessList(value: AccessList): boolean;
+export declare function isTransaction1559Unsigned(value: Transaction1559UnsignedAPI): boolean;
+export declare function isTransaction2930Unsigned(value: Transaction2930UnsignedAPI): boolean;
+export declare function isTransactionLegacyUnsigned(value: TransactionLegacyUnsignedAPI): boolean;
+export declare function isTransactionWithSender(value: TransactionWithSenderAPI): boolean;
+export declare function validateTransactionWithSender(value: TransactionWithSenderAPI): void;
+export declare function isTransactionCall(value: TransactionCall): boolean;
+export declare function validateTransactionCall(value: TransactionCall): void;
+export declare const validateCustomChainInfo: (transaction: InternalTransaction) => void;
+export declare const validateChainInfo: (transaction: InternalTransaction) => void;
+export declare const validateBaseChain: (transaction: InternalTransaction) => void;
+export declare const validateHardfork: (transaction: InternalTransaction) => void;
+export declare const validateLegacyGas: (transaction: InternalTransaction) => void;
+export declare const validateFeeMarketGas: (transaction: InternalTransaction) => void;
+/**
+ * This method checks if all required gas properties are present for either
+ * legacy gas (type 0x0 and 0x1) OR fee market transactions (0x2)
+ */
+export declare const validateGas: (transaction: InternalTransaction) => void;
+export declare const validateTransactionForSigning: (transaction: InternalTransaction, overrideMethod?: ((transaction: InternalTransaction) => void) | undefined, options?: {
+    transactionSchema?: CustomTransactionSchema;
+}) => void;
+//# sourceMappingURL=validation.d.ts.map

package/lib/types/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/validation.ts"],"names":[],"mappings":"AAiBA,OAAO,EACN,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,0BAA0B,EAC1B,0BAA0B,EAC1B,eAAe,EACf,4BAA4B,EAE5B,wBAAwB,EAExB,MAAM,YAAY,CAAC;AAsBpB,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE1E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAUpE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CASjE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAQvD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAOpF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAMpF;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAKxF;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAWhF;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,wBAAwB,QAE5E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAajE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,eAAe,QAE7D;AAED,eAAO,MAAM,uBAAuB,gBAAiB,mBAAmB,SAcvE,CAAC;AACF,eAAO,MAAM,iBAAiB,gBAAiB,mBAAmB,SAgBjE,CAAC;AACF,eAAO,MAAM,iBAAiB,gBAAiB,mBAAmB,SAYjE,CAAC;AACF,eAAO,MAAM,gBAAgB,gBAAiB,mBAAmB,SAYhE,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBAAiB,mBAAmB,SAiBjE,CAAC;AAEF,eAAO,MAAM,oBAAoB,gBAAiB,mBAAmB,SAsBpE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,gBAAiB,mBAAmB,SA4B3D,CAAC;AAEF,eAAO,MAAM,6BAA6B,gBAC5B,mBAAmB,kCACD,mBAAmB,KAAK,IAAI,yBAClD;IACR,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;CAC5C,SA8BD,CAAC"}