ox 0.0.1 → 0.1.0

package/_types/TransactionEnvelopeLegacy.d.ts

@@ -0,0 +1,358 @@
+import * as Address from './Address.js';
+import type * as Errors from './Errors.js';
+import * as Hash from './Hash.js';
+import * as Hex from './Hex.js';
+import * as Rlp from './Rlp.js';
+import * as Signature from './Signature.js';
+import * as TransactionEnvelope from './TransactionEnvelope.js';
+import type { Assign, Branded, Compute, PartialBy, UnionPartialBy } from './internal/types.js';
+export type TransactionEnvelopeLegacy<signed extends boolean = boolean, bigintType = bigint, numberType = number, type extends string = Type> = Compute<PartialBy<TransactionEnvelope.Base<type, signed, bigintType, numberType>, 'chainId'> & {
+    /** Base fee per gas. */
+    gasPrice?: bigintType | undefined;
+}>;
+export type Rpc<signed extends boolean = boolean> = TransactionEnvelopeLegacy<signed, Hex.Hex, Hex.Hex, '0x0'>;
+export type Serialized = Branded<`0x${string}`, 'legacy'>;
+export type Signed = TransactionEnvelopeLegacy<true>;
+export declare const type = "legacy";
+export type Type = typeof type;
+/**
+ * Asserts a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy} is valid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionEnvelopeLegacy, Value } from 'ox'
+ *
+ * TransactionEnvelopeLegacy.assert({
+ *   gasPrice: 2n ** 256n - 1n + 1n,
+ *   chainId: 1,
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ * // @error: GasPriceTooHighError:
+ * // @error: The gas price (`gasPrice` = 115792089237316195423570985008687907853269984665640564039457584007913 gwei) cannot be
+ * // @error: higher than the maximum allowed value (2^256-1).
+ * ```
+ *
+ * @param envelope - The transaction envelope to assert.
+ */
+export declare function assert(envelope: PartialBy<TransactionEnvelopeLegacy, 'type'>): void;
+export declare namespace assert {
+    var parseError: (error: unknown) => assert.ErrorType;
+}
+export declare namespace assert {
+    type ErrorType = Address.assert.ErrorType | TransactionEnvelope.InvalidChainIdError | TransactionEnvelope.GasPriceTooHighError | Errors.GlobalErrorType;
+}
+/**
+ * Deserializes a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy} from its serialized form.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.deserialize('0x01ef0182031184773594008477359400809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c0')
+ * // @log: {
+ * // @log:   type: 'legacy',
+ * // @log:   nonce: 785n,
+ * // @log:   gasPrice: 2000000000n,
+ * // @log:   gas: 1000000n,
+ * // @log:   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ * // @log:   value: 1000000000000000000n,
+ * // @log: }
+ * ```
+ *
+ * @param serialized - The serialized transaction.
+ * @returns Deserialized Transaction Envelope.
+ */
+export declare function deserialize(serialized: Hex.Hex): Compute<TransactionEnvelopeLegacy>;
+export declare namespace deserialize {
+    var parseError: (error: unknown) => deserialize.ErrorType;
+}
+export declare namespace deserialize {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Converts an arbitrary transaction object into a legacy Transaction Envelope.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures
+ *
+ * It is possible to attach a `signature` to the transaction envelope.
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TransactionEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TransactionEnvelopeLegacy.getSignPayload(envelope),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const envelope_signed = TransactionEnvelopeLegacy.from(envelope, { // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ * // @log: {
+ * // @log:   authorizationList: [...],
+ * // @log:   chainId: 1,
+ * // @log:   gasPrice: 10000000000n,
+ * // @log:   to: '0x0000000000000000000000000000000000000000',
+ * // @log:   type: 'eip7702',
+ * // @log:   value: 1000000000000000000n,
+ * // @log:   r: 125...n,
+ * // @log:   s: 642...n,
+ * // @log:   yParity: 0,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### From Serialized
+ *
+ * It is possible to instantiate an legacy Transaction Envelope from a {@link ox#TransactionEnvelopeLegacy.Serialized} value.
+ *
+ * ```ts twoslash
+ * import { TransactionEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from('0xf858018203118502540be4008504a817c800809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c08477359400e1a001627c687261b0e7f8638af1112efa8a77e23656f6e7945275b19e9deed80261')
+ * // @log: {
+ * // @log:   chainId: 1,
+ * // @log:   gasPrice: 10000000000n,
+ * // @log:   to: '0x0000000000000000000000000000000000000000',
+ * // @log:   type: 'legacy',
+ * // @log:   value: 1000000000000000000n,
+ * // @log: }
+ * ```
+ *
+ * @param envelope - The transaction object to convert.
+ * @param options - Options.
+ * @returns A legacy Transaction Envelope.
+ */
+export declare function from<const envelope extends UnionPartialBy<TransactionEnvelopeLegacy, 'type'> | Hex.Hex, const signature extends Signature.Signature | undefined = undefined>(envelope: envelope | UnionPartialBy<TransactionEnvelopeLegacy, 'type'> | Hex.Hex, options?: from.Options<signature>): from.ReturnType<envelope, signature>;
+export declare namespace from {
+    var parseError: (error: unknown) => from.ErrorType;
+}
+export declare namespace from {
+    type Options<signature extends Signature.Signature | undefined = undefined> = {
+        signature?: signature | Signature.Signature | undefined;
+    };
+    type ReturnType<envelope extends UnionPartialBy<TransactionEnvelopeLegacy, 'type'> | Hex.Hex = TransactionEnvelopeLegacy | Hex.Hex, signature extends Signature.Signature | undefined = undefined> = Compute<envelope extends Hex.Hex ? TransactionEnvelopeLegacy : Assign<envelope, (signature extends Signature.Signature ? Readonly<signature & {
+        v: signature['yParity'] extends 0 ? 27 : 28;
+    }> : {}) & {
+        readonly type: 'legacy';
+    }>>;
+    type ErrorType = deserialize.ErrorType | assert.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Returns the payload to sign for a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}.
+ *
+ * @example
+ * The example below demonstrates how to compute the sign payload which can be used
+ * with ECDSA signing utilities like {@link ox#Secp256k1.(sign:function)}.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1, TransactionEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * const payload = TransactionEnvelopeLegacy.getSignPayload(envelope) // [!code focus]
+ * // @log: '0x...'
+ *
+ * const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
+ * ```
+ *
+ * @param envelope - The transaction envelope to get the sign payload for.
+ * @returns The sign payload.
+ */
+export declare function getSignPayload(envelope: TransactionEnvelopeLegacy<false>): getSignPayload.ReturnType;
+export declare namespace getSignPayload {
+    var parseError: (error: unknown) => getSignPayload.ErrorType;
+}
+export declare namespace getSignPayload {
+    type ReturnType = Hex.Hex;
+    type ErrorType = hash.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Hashes a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}. This is the "transaction hash".
+ *
+ * @example
+ * ```ts twoslash
+ * import { Secp256k1, TransactionEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TransactionEnvelopeLegacy.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const envelope_signed = TransactionEnvelopeLegacy.from(envelope, { signature })
+ *
+ * const hash = TransactionEnvelopeLegacy.hash(envelope_signed) // [!code focus]
+ * ```
+ *
+ * @param envelope - The Legacy Transaction Envelope to hash.
+ * @param options - Options.
+ * @returns The hash of the transaction envelope.
+ */
+export declare function hash<presign extends boolean = false>(envelope: TransactionEnvelopeLegacy<presign extends true ? false : true>, options?: hash.Options<presign>): hash.ReturnType;
+export declare namespace hash {
+    var parseError: (error: unknown) => hash.ErrorType;
+}
+export declare namespace hash {
+    type Options<presign extends boolean = false> = {
+        /** Whether to hash this transaction for signing. @default false */
+        presign?: presign | boolean | undefined;
+    };
+    type ReturnType = Hex.Hex;
+    type ErrorType = Hash.keccak256.ErrorType | serialize.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Serializes a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { TransactionEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const serialized = TransactionEnvelopeLegacy.serialize(envelope) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures
+ *
+ * It is possible to attach a `signature` to the serialized Transaction Envelope.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1, TransactionEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TransactionEnvelopeLegacy.getSignPayload(envelope),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const serialized = TransactionEnvelopeLegacy.serialize(envelope, { // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ *
+ * // ... send `serialized` transaction to JSON-RPC `eth_sendRawTransaction`
+ * ```
+ *
+ * @param envelope - The Transaction Envelope to serialize.
+ * @param options - Options.
+ * @returns The serialized Transaction Envelope.
+ */
+export declare function serialize(envelope: PartialBy<TransactionEnvelopeLegacy, 'type'>, options?: serialize.Options): Serialized;
+export declare namespace serialize {
+    var parseError: (error: unknown) => serialize.ErrorType;
+}
+export declare namespace serialize {
+    type Options = {
+        /** Signature to append to the serialized Transaction Envelope. */
+        signature?: Signature.Signature | undefined;
+    };
+    type ErrorType = assert.ErrorType | Hex.fromNumber.ErrorType | Hex.trimLeft.ErrorType | Rlp.fromHex.ErrorType | Signature.InvalidVError | Errors.GlobalErrorType;
+}
+/**
+ * Converts an {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy} to an {@link ox#TransactionEnvelopeLegacy.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcRequest, TransactionEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TransactionEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const envelope_rpc = TransactionEnvelopeLegacy.toRpc(envelope) // [!code focus]
+ *
+ * const request = RpcRequest.from({
+ *   id: 0,
+ *   method: 'eth_sendTransaction',
+ *   params: [envelope_rpc],
+ * })
+ * ```
+ *
+ * @param envelope - The legacy transaction envelope to convert.
+ * @returns An RPC-formatted legacy transaction envelope.
+ */
+export declare function toRpc(envelope: Omit<TransactionEnvelopeLegacy, 'type'>): Rpc;
+export declare namespace toRpc {
+    var parseError: (error: unknown) => toRpc.ErrorType;
+}
+export declare namespace toRpc {
+    type ErrorType = Signature.extract.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Validates a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}. Returns `true` if the envelope is valid, `false` otherwise.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionEnvelopeLegacy, Value } from 'ox'
+ *
+ * const valid = TransactionEnvelopeLegacy.assert({
+ *   gasPrice: 2n ** 256n - 1n + 1n,
+ *   chainId: 1,
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ * // @log: false
+ * ```
+ *
+ * @param envelope - The transaction envelope to validate.
+ */
+export declare function validate(envelope: PartialBy<TransactionEnvelopeLegacy, 'type'>): boolean;
+export declare namespace validate {
+    var parseError: (error: unknown) => validate.ErrorType;
+}
+export declare namespace validate {
+    type ErrorType = Errors.GlobalErrorType;
+}
+//# sourceMappingURL=TransactionEnvelopeLegacy.d.ts.map

package/_types/TransactionEnvelopeLegacy.d.ts.map

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

package/_types/TransactionReceipt.d.ts

@@ -0,0 +1,271 @@
+import type * as Address from './Address.js';
+import type * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import * as Log from './Log.js';
+import type { Compute } from './internal/types.js';
+/** An Transaction Receipt as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/receipt.yaml). */
+export type TransactionReceipt<status = Status, type = Type, bigintType = bigint, numberType = number> = Compute<{
+    /** The actual value per gas deducted from the sender's account for blob gas. Only specified for blob transactions as defined by EIP-4844. */
+    blobGasPrice?: bigintType | undefined;
+    /** The amount of blob gas used. Only specified for blob transactions as defined by EIP-4844. */
+    blobGasUsed?: bigintType | undefined;
+    /** Hash of block containing this transaction */
+    blockHash: Hex.Hex;
+    /** Number of block containing this transaction */
+    blockNumber: bigintType;
+    /** Address of new contract or `null` if no contract was created */
+    contractAddress?: Address.Address | null | undefined;
+    /** Gas used by this and all preceding transactions in this block */
+    cumulativeGasUsed: bigintType;
+    /** Pre-London, it is equal to the transaction's gasPrice. Post-London, it is equal to the actual gas price paid for inclusion. */
+    effectiveGasPrice: bigintType;
+    /** Transaction sender */
+    from: Address.Address;
+    /** Gas used by this transaction */
+    gasUsed: bigintType;
+    /** List of log objects generated by this transaction */
+    logs: Log.Log<false, bigintType, numberType>[];
+    /** Logs bloom filter */
+    logsBloom: Hex.Hex;
+    /** The post-transaction state root. Only specified for transactions included before the Byzantium upgrade. */
+    root?: Hex.Hex | undefined;
+    /** `success` if this transaction was successful or `reverted` if it failed */
+    status: status;
+    /** Transaction recipient or `null` if deploying a contract */
+    to: Address.Address | null;
+    /** Hash of this transaction */
+    transactionHash: Hex.Hex;
+    /** Index of this transaction in the block */
+    transactionIndex: numberType;
+    /** Transaction type */
+    type: type;
+}>;
+/** An RPC Transaction Receipt as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/receipt.yaml). */
+export type Rpc = TransactionReceipt<RpcStatus, RpcType, Hex.Hex, Hex.Hex>;
+/**
+ * Union of Transaction Receipt statuses.
+ *
+ * - `success`
+ * - `reverted`
+ */
+export type Status = 'success' | 'reverted';
+/**
+ * Union of RPC Transaction Receipt statuses.
+ *
+ * - `0x0`
+ * - `0x1`
+ */
+export type RpcStatus = '0x0' | '0x1';
+/**
+ * Union of Transaction Receipt types.
+ *
+ * - `legacy`
+ * - `eip1559`
+ * - `eip2930`
+ * - `eip4844`
+ * - `eip7702`
+ * - any other string
+ */
+export type Type = 'legacy' | 'eip1559' | 'eip2930' | 'eip4844' | 'eip7702' | (string & {});
+/**
+ * Union of RPC Transaction Receipt types.
+ *
+ * - `0x0`: legacy transactions
+ * - `0x1`: EIP-1559 transactions
+ * - `0x2`: EIP-2930 transactions
+ * - `0x3`: EIP-4844 transactions
+ * - `0x4`: EIP-7702 transactions
+ * - any other string
+ */
+export type RpcType = '0x0' | '0x1' | '0x2' | '0x3' | '0x4' | (string & {});
+/** RPC status to status mapping. */
+export declare const fromRpcStatus: {
+    readonly '0x0': "reverted";
+    readonly '0x1': "success";
+};
+/** Status to RPC status mapping. */
+export declare const toRpcStatus: {
+    readonly reverted: "0x0";
+    readonly success: "0x1";
+};
+/** RPC type to type mapping. */
+export declare const fromRpcType: {
+    readonly '0x0': "legacy";
+    readonly '0x1': "eip2930";
+    readonly '0x2': "eip1559";
+    readonly '0x3': "eip4844";
+    readonly '0x4': "eip7702";
+};
+/** Type to RPC type mapping. */
+export declare const toRpcType: {
+    readonly legacy: "0x0";
+    readonly eip2930: "0x1";
+    readonly eip1559: "0x2";
+    readonly eip4844: "0x3";
+    readonly eip7702: "0x4";
+};
+/**
+ * Converts a {@link ox#TransactionReceipt.Rpc} to an {@link ox#TransactionReceipt.TransactionReceipt}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionReceipt } from 'ox'
+ *
+ * const receipt = TransactionReceipt.fromRpc({
+ *   blobGasPrice: '0x42069',
+ *   blobGasUsed: '0x1337',
+ *   blockHash:
+ *     '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+ *   blockNumber: '0x12f296f',
+ *   contractAddress: null,
+ *   cumulativeGasUsed: '0x82515',
+ *   effectiveGasPrice: '0x21c2f6c09',
+ *   from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+ *   gasUsed: '0x2abba',
+ *   logs: [],
+ *   logsBloom:
+ *     '0x00200000000000000000008080000000000000000040000000000000000000000000000000000000000000000000000022000000080000000000000000000000000000080000000000000008000000200000000000000000000200008020400000000000000000280000000000100000000000000000000000000010000000000000000000020000000000000020000000000001000000080000004000000000000000000000000000000000000000000000400000000000001000000000000000000002000000000000000020000000000000000000001000000000000000000000200000000000000000000000000000001000000000c00000000000000000',
+ *   status: '0x1',
+ *   to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+ *   transactionHash:
+ *     '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+ *   transactionIndex: '0x2',
+ *   type: '0x2',
+ * })
+ * // @log: {
+ * // @log:   blobGasPrice: 270441n,
+ * // @log:   blobGasUsed: 4919n,
+ * // @log:   blockHash: "0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b",
+ * // @log:   blockNumber: 19868015n,
+ * // @log:   contractAddress: null,
+ * // @log:   cumulativeGasUsed: 533781n,
+ * // @log:   effectiveGasPrice: 9062804489n,
+ * // @log:   from: "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
+ * // @log:   gasUsed: 175034n,
+ * // @log:   logs: [],
+ * // @log:   logsBloom: "0x00200000000000000000008080000000000000000040000000000000000000000000000000000000000000000000000022000000080000000000000000000000000000080000000000000008000000200000000000000000000200008020400000000000000000280000000000100000000000000000000000000010000000000000000000020000000000000020000000000001000000080000004000000000000000000000000000000000000000000000400000000000001000000000000000000002000000000000000020000000000000000000001000000000000000000000200000000000000000000000000000001000000000c00000000000000000",
+ * // @log:   root: undefined,
+ * // @log:   status: "success",
+ * // @log:   to: "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+ * // @log:   transactionHash: "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
+ * // @log:   transactionIndex: 2,
+ * // @log:   type: "eip1559",
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### End-to-end
+ *
+ * Below is an example of how to use the `TransactionReceipt.fromRpc` method to convert an RPC transaction receipt to a {@link ox#TransactionReceipt.TransactionReceipt} object.
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { TransactionReceipt } from 'ox'
+ *
+ * const receipt = await window.ethereum!
+ *   .request({
+ *     method: 'eth_getTransactionReceipt',
+ *     params: [
+ *       '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+ *     ],
+ *   })
+ *   .then(TransactionReceipt.fromRpc) // [!code hl]
+ * // @log: {
+ * // @log:   blobGasPrice: 270441n,
+ * // @log:   blobGasUsed: 4919n,
+ * // @log:   blockHash: "0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b",
+ * // @log:   blockNumber: 19868015n,
+ * // @log:   contractAddress: null,
+ * // @log:   cumulativeGasUsed: 533781n,
+ * // @log:   effectiveGasPrice: 9062804489n,
+ * // @log:   from: "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
+ * // @log:   gasUsed: 175034n,
+ * // @log:   logs: [],
+ * // @log:   logsBloom: "0x00200000000000000000008080000000000000000040000000000000000000000000000000000000000000000000000022000000080000000000000000000000000000080000000000000008000000200000000000000000000200008020400000000000000000280000000000100000000000000000000000000010000000000000000000020000000000000020000000000001000000080000004000000000000000000000000000000000000000000000400000000000001000000000000000000002000000000000000020000000000000000000001000000000000000000000200000000000000000000000000000001000000000c00000000000000000",
+ * // @log:   root: undefined,
+ * // @log:   status: "success",
+ * // @log:   to: "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+ * // @log:   transactionHash: "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
+ * // @log:   transactionIndex: 2,
+ * // @log:   type: "eip1559",
+ * // @log: }
+ * ```
+ *
+ * :::note
+ *
+ * For simplicity, the above example uses `window.ethereum.request`, but you can use any
+ * type of JSON-RPC interface.
+ *
+ * :::
+ *
+ * @param receipt - The RPC receipt to convert.
+ * @returns An instantiated {@link ox#TransactionReceipt.TransactionReceipt}.
+ */
+export declare function fromRpc<const receipt extends Rpc | null>(receipt: receipt | Rpc | null): receipt extends Rpc ? TransactionReceipt : null;
+export declare namespace fromRpc {
+    var parseError: (error: unknown) => fromRpc.ErrorType;
+}
+export declare namespace fromRpc {
+    type ErrorType = Log.fromRpc.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Converts a {@link ox#TransactionReceipt.TransactionReceipt} to a {@link ox#TransactionReceipt.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionReceipt } from 'ox'
+ *
+ * const receipt = TransactionReceipt.toRpc({
+ *   blobGasPrice: 270441n,
+ *   blobGasUsed: 4919n,
+ *   blockHash:
+ *     '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+ *   blockNumber: 19868015n,
+ *   contractAddress: null,
+ *   cumulativeGasUsed: 533781n,
+ *   effectiveGasPrice: 9062804489n,
+ *   from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+ *   gasUsed: 175034n,
+ *   logs: [],
+ *   logsBloom:
+ *     '0x00200000000000000000008080000000000000000040000000000000000000000000000000000000000000000000000022000000080000000000000000000000000000080000000000000008000000200000000000000000000200008020400000000000000000280000000000100000000000000000000000000010000000000000000000020000000000000020000000000001000000080000004000000000000000000000000000000000000000000000400000000000001000000000000000000002000000000000000020000000000000000000001000000000000000000000200000000000000000000000000000001000000000c00000000000000000',
+ *   root: undefined,
+ *   status: 'success',
+ *   to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+ *   transactionHash:
+ *     '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+ *   transactionIndex: 2,
+ *   type: 'eip1559',
+ * })
+ * // @log: {
+ * // @log:   blobGasPrice: "0x042069",
+ * // @log:   blobGasUsed: "0x1337",
+ * // @log:   blockHash: "0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b",
+ * // @log:   blockNumber: "0x012f296f",
+ * // @log:   contractAddress: null,
+ * // @log:   cumulativeGasUsed: "0x082515",
+ * // @log:   effectiveGasPrice: "0x021c2f6c09",
+ * // @log:   from: "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
+ * // @log:   gasUsed: "0x02abba",
+ * // @log:   logs: [],
+ * // @log:   logsBloom: "0x00200000000000000000008080000000000000000040000000000000000000000000000000000000000000000000000022000000080000000000000000000000000000080000000000000008000000200000000000000000000200008020400000000000000000280000000000100000000000000000000000000010000000000000000000020000000000000020000000000001000000080000004000000000000000000000000000000000000000000000400000000000001000000000000000000002000000000000000020000000000000000000001000000000000000000000200000000000000000000000000000001000000000c00000000000000000",
+ * // @log:   root: undefined,
+ * // @log:   status: "0x1",
+ * // @log:   to: "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+ * // @log:   transactionHash: "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
+ * // @log:   transactionIndex: "0x02",
+ * // @log:   type: "eip1559",
+ * // @log: }
+ * ```
+ *
+ * @param receipt - The receipt to convert.
+ * @returns An RPC receipt.
+ */
+export declare function toRpc(receipt: TransactionReceipt): Rpc;
+export declare namespace toRpc {
+    var parseError: (error: unknown) => toRpc.ErrorType;
+}
+export declare namespace toRpc {
+    type ErrorType = Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=TransactionReceipt.d.ts.map

package/_types/TransactionReceipt.d.ts.map

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