ox 0.9.16 → 0.10.0

package/core/{TransactionEnvelopeEip4844.ts → TxEnvelopeEip4844.ts}

@@ -12,10 +12,10 @@ import type {
 import * as Kzg from './Kzg.js'
 import * as Rlp from './Rlp.js'
 import * as Signature from './Signature.js'
-import * as TransactionEnvelope from './TransactionEnvelope.js'
-import * as TransactionEnvelopeEip1559 from './TransactionEnvelopeEip1559.js'
+import * as TransactionEnvelope from './TxEnvelope.js'
+import * as TxEnvelopeEip1559 from './TxEnvelopeEip1559.js'
 
-export type TransactionEnvelopeEip4844<
+export type TxEnvelopeEip4844<
   signed extends boolean = boolean,
   bigintType = bigint,
   numberType = number,
@@ -37,7 +37,7 @@ export type TransactionEnvelopeEip4844<
   }
 >
 
-export type Rpc<signed extends boolean = boolean> = TransactionEnvelopeEip4844<
+export type Rpc<signed extends boolean = boolean> = TxEnvelopeEip4844<
   signed,
   Hex.Hex,
   Hex.Hex,
@@ -49,19 +49,19 @@ export type Serialized = `${SerializedType}${string}`
 export const serializedType = '0x03' as const
 export type SerializedType = typeof serializedType
 
-export type Signed = TransactionEnvelopeEip4844<true>
+export type Signed = TxEnvelopeEip4844<true>
 
 export const type = 'eip4844' as const
 export type Type = 'eip4844'
 
 /**
- * Asserts a {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844} is valid.
+ * Asserts a {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844} is valid.
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeEip4844, Value } from 'ox'
+ * import { TxEnvelopeEip4844, Value } from 'ox'
  *
- * TransactionEnvelopeEip4844.assert({
+ * TxEnvelopeEip4844.assert({
  *   blobVersionedHashes: [],
  *   chainId: 1,
  *   to: '0x0000000000000000000000000000000000000000',
@@ -72,9 +72,7 @@ export type Type = 'eip4844'
  *
  * @param envelope - The transaction envelope to assert.
  */
-export function assert(
-  envelope: PartialBy<TransactionEnvelopeEip4844, 'type'>,
-) {
+export function assert(envelope: PartialBy<TxEnvelopeEip4844, 'type'>) {
   const { blobVersionedHashes } = envelope
   if (blobVersionedHashes) {
     if (blobVersionedHashes.length === 0)
@@ -91,14 +89,14 @@ export function assert(
         })
     }
   }
-  TransactionEnvelopeEip1559.assert(
-    envelope as {} as TransactionEnvelopeEip1559.TransactionEnvelopeEip1559,
+  TxEnvelopeEip1559.assert(
+    envelope as {} as TxEnvelopeEip1559.TxEnvelopeEip1559,
   )
 }
 
 export declare namespace assert {
   type ErrorType =
-    | TransactionEnvelopeEip1559.assert.ErrorType
+    | TxEnvelopeEip1559.assert.ErrorType
     | Hex.size.ErrorType
     | Hex.toNumber.ErrorType
     | Hex.slice.ErrorType
@@ -109,13 +107,13 @@ export declare namespace assert {
 }
 
 /**
- * Deserializes a {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844} from its serialized form.
+ * Deserializes a {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844} from its serialized form.
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeEip4844 } from 'ox'
+ * import { TxEnvelopeEip4844 } from 'ox'
  *
- * const envelope = TransactionEnvelopeEip4844.deserialize('0x03ef0182031184773594008477359400809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c0')
+ * const envelope = TxEnvelopeEip4844.deserialize('0x03ef0182031184773594008477359400809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c0')
  * // @log: {
  * // @log:   blobVersionedHashes: [...],
  * // @log:   type: 'eip4844',
@@ -132,7 +130,7 @@ export declare namespace assert {
  */
 export function deserialize(
   serialized: Serialized,
-): Compute<TransactionEnvelopeEip4844> {
+): Compute<TxEnvelopeEip4844> {
   const transactionOrWrapperArray = Rlp.toHex(Hex.slice(serialized, 1))
 
   const hasNetworkWrapper = transactionOrWrapperArray.length === 4
@@ -190,7 +188,7 @@ export function deserialize(
     blobVersionedHashes: blobVersionedHashes as Hex.Hex[],
     chainId: Number(chainId),
     type,
-  } as TransactionEnvelopeEip4844
+  } as TxEnvelopeEip4844
   if (Hex.validate(to) && to !== '0x') transaction.to = to
   if (Hex.validate(gas) && gas !== '0x') transaction.gas = BigInt(gas)
   if (Hex.validate(data) && data !== '0x') transaction.data = data
@@ -219,7 +217,7 @@ export function deserialize(
     transaction = {
       ...transaction,
       ...signature,
-    } as TransactionEnvelopeEip4844
+    } as TxEnvelopeEip4844
 
   assert(transaction)
 
@@ -236,13 +234,13 @@ export declare namespace deserialize {
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, TransactionEnvelopeEip4844, Value } from 'ox'
+ * import { Blobs, TxEnvelopeEip4844, Value } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, { kzg })
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   chainId: 1,
  *   blobVersionedHashes,
  *   maxFeePerBlobGas: Value.fromGwei('3'),
@@ -260,14 +258,14 @@ export declare namespace deserialize {
  *
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, Secp256k1, TransactionEnvelopeEip4844, Value } from 'ox'
+ * import { Blobs, Secp256k1, TxEnvelopeEip4844, Value } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const sidecars = Blobs.toSidecars(blobs, { kzg })
  * const blobVersionedHashes = Blobs.sidecarsToVersionedHashes(sidecars)
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   blobVersionedHashes,
  *   chainId: 1,
  *   maxFeePerBlobGas: Value.fromGwei('3'),
@@ -278,11 +276,11 @@ export declare namespace deserialize {
  * })
  *
  * const signature = Secp256k1.sign({
- *   payload: TransactionEnvelopeEip4844.getSignPayload(envelope),
+ *   payload: TxEnvelopeEip4844.getSignPayload(envelope),
  *   privateKey: '0x...',
  * })
  *
- * const envelope_signed = TransactionEnvelopeEip4844.from(envelope, { // [!code focus]
+ * const envelope_signed = TxEnvelopeEip4844.from(envelope, { // [!code focus]
  *   sidecars, // [!code focus]
  *   signature, // [!code focus]
  * }) // [!code focus]
@@ -304,12 +302,12 @@ export declare namespace deserialize {
  * @example
  * ### From Serialized
  *
- * It is possible to instantiate an EIP-4844 Transaction Envelope from a {@link ox#TransactionEnvelopeEip4844.Serialized} value.
+ * It is possible to instantiate an EIP-4844 Transaction Envelope from a {@link ox#TxEnvelopeEip4844.Serialized} value.
  *
  * ```ts twoslash
- * import { TransactionEnvelopeEip4844 } from 'ox'
+ * import { TxEnvelopeEip4844 } from 'ox'
  *
- * const envelope = TransactionEnvelopeEip4844.from('0x03f858018203118502540be4008504a817c800809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c08477359400e1a001627c687261b0e7f8638af1112efa8a77e23656f6e7945275b19e9deed80261')
+ * const envelope = TxEnvelopeEip4844.from('0x03f858018203118502540be4008504a817c800809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c08477359400e1a001627c687261b0e7f8638af1112efa8a77e23656f6e7945275b19e9deed80261')
  * // @log: {
  * // @log:   blobVersionedHashes: [...],
  * // @log:   chainId: 1,
@@ -325,22 +323,17 @@ export declare namespace deserialize {
  * @returns An EIP-4844 Transaction Envelope.
  */
 export function from<
-  const envelope extends
-    | UnionPartialBy<TransactionEnvelopeEip4844, 'type'>
-    | Serialized,
+  const envelope extends UnionPartialBy<TxEnvelopeEip4844, 'type'> | Serialized,
   const signature extends Signature.Signature | undefined = undefined,
 >(
-  envelope:
-    | envelope
-    | UnionPartialBy<TransactionEnvelopeEip4844, 'type'>
-    | Serialized,
+  envelope: envelope | UnionPartialBy<TxEnvelopeEip4844, 'type'> | Serialized,
   options: from.Options<signature> = {},
 ): from.ReturnType<envelope, signature> {
   const { signature } = options
 
   const envelope_ = (
     typeof envelope === 'string' ? deserialize(envelope) : envelope
-  ) as TransactionEnvelopeEip4844
+  ) as TxEnvelopeEip4844
 
   assert(envelope_)
 
@@ -358,13 +351,13 @@ export declare namespace from {
     }
 
   type ReturnType<
-    envelope extends
-      | UnionPartialBy<TransactionEnvelopeEip4844, 'type'>
-      | Hex.Hex = TransactionEnvelopeEip4844 | Hex.Hex,
+    envelope extends UnionPartialBy<TxEnvelopeEip4844, 'type'> | Hex.Hex =
+      | TxEnvelopeEip4844
+      | Hex.Hex,
     signature extends Signature.Signature | undefined = undefined,
   > = Compute<
     envelope extends Hex.Hex
-      ? TransactionEnvelopeEip4844
+      ? TxEnvelopeEip4844
       : Assign<
           envelope,
           (signature extends Signature.Signature ? Readonly<signature> : {}) & {
@@ -380,7 +373,7 @@ export declare namespace from {
 }
 
 /**
- * Returns the payload to sign for a {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844}.
+ * Returns the payload to sign for a {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844}.
  *
  * @example
  * The example below demonstrates how to compute the sign payload which can be used
@@ -388,13 +381,13 @@ export declare namespace from {
  *
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, Secp256k1, TransactionEnvelopeEip4844 } from 'ox'
+ * import { Blobs, Secp256k1, TxEnvelopeEip4844 } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, { kzg })
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   blobVersionedHashes,
  *   chainId: 1,
  *   nonce: 0n,
@@ -404,7 +397,7 @@ export declare namespace from {
  *   value: 1000000000000000000n,
  * })
  *
- * const payload = TransactionEnvelopeEip4844.getSignPayload(envelope) // [!code focus]
+ * const payload = TxEnvelopeEip4844.getSignPayload(envelope) // [!code focus]
  * // @log: '0x...'
  *
  * const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
@@ -414,7 +407,7 @@ export declare namespace from {
  * @returns The sign payload.
  */
 export function getSignPayload(
-  envelope: TransactionEnvelopeEip4844,
+  envelope: TxEnvelopeEip4844,
 ): getSignPayload.ReturnType {
   return hash(envelope, { presign: true })
 }
@@ -426,18 +419,18 @@ export declare namespace getSignPayload {
 }
 
 /**
- * Hashes a {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844}. This is the "transaction hash".
+ * Hashes a {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844}. This is the "transaction hash".
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, TransactionEnvelopeEip4844 } from 'ox'
+ * import { Blobs, TxEnvelopeEip4844 } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, { kzg })
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   blobVersionedHashes,
  *   chainId: 1,
  *   nonce: 0n,
@@ -447,7 +440,7 @@ export declare namespace getSignPayload {
  *   value: 1000000000000000000n,
  * })
  *
- * const hash = TransactionEnvelopeEip4844.hash(envelope) // [!code focus]
+ * const hash = TxEnvelopeEip4844.hash(envelope) // [!code focus]
  * ```
  *
  * @param envelope - The EIP-4844 Transaction Envelope to hash.
@@ -455,7 +448,7 @@ export declare namespace getSignPayload {
  * @returns The hash of the transaction envelope.
  */
 export function hash<presign extends boolean = false>(
-  envelope: TransactionEnvelopeEip4844<presign extends true ? false : true>,
+  envelope: TxEnvelopeEip4844<presign extends true ? false : true>,
   options: hash.Options<presign> = {},
 ): hash.ReturnType {
   const { presign } = options
@@ -490,18 +483,18 @@ export declare namespace hash {
 }
 
 /**
- * Serializes a {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844}.
+ * Serializes a {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844}.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, TransactionEnvelopeEip4844 } from 'ox'
+ * import { Blobs, TxEnvelopeEip4844 } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, { kzg })
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   blobVersionedHashes,
  *   chainId: 1,
  *   maxFeePerGas: Value.fromGwei('10'),
@@ -509,7 +502,7 @@ export declare namespace hash {
  *   value: Value.fromEther('1'),
  * })
  *
- * const serialized = TransactionEnvelopeEip4844.serialize(envelope) // [!code focus]
+ * const serialized = TxEnvelopeEip4844.serialize(envelope) // [!code focus]
  * ```
  *
  * @example
@@ -519,14 +512,14 @@ export declare namespace hash {
  *
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, Secp256k1, TransactionEnvelopeEip4844, Value } from 'ox'
+ * import { Blobs, Secp256k1, TxEnvelopeEip4844, Value } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const sidecars = Blobs.toSidecars(blobs, { kzg })
  * const blobVersionedHashes = Blobs.sidecarsToVersionedHashes(blobs)
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   blobVersionedHashes,
  *   chainId: 1,
  *   maxFeePerBlobGas: Value.fromGwei('3'),
@@ -537,11 +530,11 @@ export declare namespace hash {
  * })
  *
  * const signature = Secp256k1.sign({
- *   payload: TransactionEnvelopeEip4844.getSignPayload(envelope),
+ *   payload: TxEnvelopeEip4844.getSignPayload(envelope),
  *   privateKey: '0x...',
  * })
  *
- * const serialized = TransactionEnvelopeEip4844.serialize(envelope, { // [!code focus]
+ * const serialized = TxEnvelopeEip4844.serialize(envelope, { // [!code focus]
  *   sidecars, // [!code focus]
  *   signature, // [!code focus]
  * }) // [!code focus]
@@ -554,7 +547,7 @@ export declare namespace hash {
  * @returns The serialized Transaction Envelope.
  */
 export function serialize(
-  envelope: PartialBy<TransactionEnvelopeEip4844, 'type'>,
+  envelope: PartialBy<TxEnvelopeEip4844, 'type'>,
   options: serialize.Options = {},
 ): Serialized {
   const {
@@ -632,18 +625,18 @@ export declare namespace serialize {
 }
 
 /**
- * Converts an {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844} to an {@link ox#TransactionEnvelopeEip4844.Rpc}.
+ * Converts an {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844} to an {@link ox#TxEnvelopeEip4844.Rpc}.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { Blobs, RpcRequest, TransactionEnvelopeEip4844, Value } from 'ox'
+ * import { Blobs, RpcRequest, TxEnvelopeEip4844, Value } from 'ox'
  * import { kzg } from './kzg'
  *
  * const blobs = Blobs.from('0xdeadbeef')
  * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, { kzg })
  *
- * const envelope = TransactionEnvelopeEip4844.from({
+ * const envelope = TxEnvelopeEip4844.from({
  *   blobVersionedHashes,
  *   chainId: 1,
  *   nonce: 0n,
@@ -653,7 +646,7 @@ export declare namespace serialize {
  *   value: Value.fromEther('1'),
  * })
  *
- * const envelope_rpc = TransactionEnvelopeEip4844.toRpc(envelope) // [!code focus]
+ * const envelope_rpc = TxEnvelopeEip4844.toRpc(envelope) // [!code focus]
  *
  * const request = RpcRequest.from({
  *   id: 0,
@@ -665,7 +658,7 @@ export declare namespace serialize {
  * @param envelope - The EIP-4844 transaction envelope to convert.
  * @returns An RPC-formatted EIP-4844 transaction envelope.
  */
-export function toRpc(envelope: Omit<TransactionEnvelopeEip4844, 'type'>): Rpc {
+export function toRpc(envelope: Omit<TxEnvelopeEip4844, 'type'>): Rpc {
   const signature = Signature.extract(envelope)
 
   return {
@@ -700,13 +693,13 @@ export declare namespace toRpc {
 }
 
 /**
- * Validates a {@link ox#TransactionEnvelopeEip4844.TransactionEnvelopeEip4844}. Returns `true` if the envelope is valid, `false` otherwise.
+ * Validates a {@link ox#TxEnvelopeEip4844.TxEnvelopeEip4844}. Returns `true` if the envelope is valid, `false` otherwise.
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeEip4844, Value } from 'ox'
+ * import { TxEnvelopeEip4844, Value } from 'ox'
  *
- * const valid = TransactionEnvelopeEip4844.assert({
+ * const valid = TxEnvelopeEip4844.assert({
  *   blobVersionedHashes: [],
  *   chainId: 1,
  *   to: '0x0000000000000000000000000000000000000000',
@@ -717,9 +710,7 @@ export declare namespace toRpc {
  *
  * @param envelope - The transaction envelope to validate.
  */
-export function validate(
-  envelope: PartialBy<TransactionEnvelopeEip4844, 'type'>,
-) {
+export function validate(envelope: PartialBy<TxEnvelopeEip4844, 'type'>) {
   try {
     assert(envelope)
     return true