@aztec-labs/ethereum 6.0.0-rc.3 → 6.0.0

package/src/l1_tx_utils/send_cost.ts

@@ -0,0 +1,21 @@
+import { GAS_PER_BLOB } from './constants.js';
+import type { FeesPerGas } from './types.js';
+
+/** Gas limit and blob count of an L1 send, used to bound the ETH a sender must hold to submit it. */
+export type SendCostRequirement = {
+  /** Gas limit the tx will be sent with. */
+  gasLimit: bigint;
+  /** Number of blobs attached to the tx. */
+  blobCount: number;
+};
+
+/**
+ * Upper bound on the ETH a send needs up front: `gasLimit * maxFeePerGas + blobCount * GAS_PER_BLOB * maxFeePerBlobGas`.
+ * This is what the node checks against the sender balance before accepting the tx, so a sender holding less than this
+ * gets the tx rejected with an insufficient funds error.
+ */
+export function computeSendCost(fees: FeesPerGas, req: SendCostRequirement): bigint {
+  const executionCost = req.gasLimit * fees.maxFeePerGas;
+  const blobCost = BigInt(req.blobCount) * GAS_PER_BLOB * (fees.maxFeePerBlobGas ?? 0n);
+  return executionCost + blobCost;
+}

package/src/l1_tx_utils/signer.ts

@@ -1,7 +1,8 @@
 import { EthAddress } from '@aztec-labs/foundation/eth-address';
 import type { ViemTransactionSignature } from '@aztec-labs/foundation/eth-signature';
-import { type TransactionSerializable, type WalletClient, parseTransaction } from 'viem';
+import type { TransactionSerializable, WalletClient } from 'viem';
 
+import { parseSignedTransaction } from '../blob_tx.js';
 import type { SigningCallback } from './types.js';
 
 export function createViemSigner(client: WalletClient) {
@@ -11,7 +12,7 @@ export function createViemSigner(client: WalletClient) {
   ): Promise<ViemTransactionSignature> => {
     const signedTx = await client.signTransaction(tx as any);
 
-    const parsed = parseTransaction(signedTx);
+    const parsed = parseSignedTransaction(signedTx);
 
     if (!parsed.r || !parsed.s || (parsed.yParity !== 0 && parsed.yParity !== 1)) {
       throw new Error('Failed to extract signature from viem signed transaction');

package/src/l1_tx_utils/tx_delayer.ts

@@ -1,22 +1,11 @@
 import { omit } from '@aztec-labs/foundation/collection';
+import { inspect } from '@aztec-labs/foundation/inspect';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec-labs/foundation/log';
 import { retryUntil } from '@aztec-labs/foundation/retry';
 import type { DateProvider } from '@aztec-labs/foundation/timer';
-import { inspect } from 'util';
-import {
-  type Client,
-  type Hex,
-  type PublicClient,
-  type TransactionSerializableEIP4844,
-  type TransactionSerialized,
-  keccak256,
-  parseTransaction,
-  publicActions,
-  recoverTransactionAddress,
-  serializeTransaction,
-  walletActions,
-} from 'viem';
+import { type Client, type Hex, type PublicClient, publicActions, walletActions } from 'viem';
 
+import { computeSignedTransactionHash, parseSignedTransaction, recoverSignedTransactionAddress } from '../blob_tx.js';
 import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
 
 const MAX_WAIT_TIME_SECONDS = 180;
@@ -152,9 +141,7 @@ export function createDelayer(
 /** Tries to recover the sender address from a serialized signed transaction. */
 async function tryRecoverSender(serializedTransaction: Hex): Promise<string | undefined> {
   try {
-    return await recoverTransactionAddress({
-      serializedTransaction: serializedTransaction as TransactionSerialized,
-    });
+    return await recoverSignedTransactionAddress(serializedTransaction);
   } catch {
     return undefined;
   }
@@ -189,7 +176,7 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
           delayer.nextWait = undefined;
 
           // Compute the tx hash manually so we emulate sendRawTransaction response
-          txHash = computeTxHash(serializedTransaction);
+          txHash = computeSignedTransactionHash(serializedTransaction);
 
           // Cancel tx outright if instructed
           if ('indefinitely' in waitUntil && waitUntil.indefinitely) {
@@ -214,7 +201,7 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
           logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
             sender,
             argsLen: args.length,
-            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+            ...omit(parseSignedTransaction(serializedTransaction), 'data', 'sidecars'),
           });
         } else if (delayer.maxInclusionTimeIntoSlot !== undefined) {
           // Check if we need to delay txs sent too close to the end of the slot.
@@ -222,10 +209,10 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
           const { timestamp: lastBlockTimestamp, number } = currentBlock;
           const now = delayer.dateProvider.now();
 
-          txHash = computeTxHash(serializedTransaction);
+          txHash = computeSignedTransactionHash(serializedTransaction);
           const logData = {
             sender,
-            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+            ...omit(parseSignedTransaction(serializedTransaction), 'data', 'sidecars'),
             lastBlockTimestamp,
             now,
             maxInclusionTimeIntoSlot: delayer.maxInclusionTimeIntoSlot,
@@ -284,19 +271,3 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
 
   return extended as T;
 }
-
-/**
- * Compute the tx hash given the serialized tx. Note that if this is a blob tx, we need to
- * exclude the blobs, commitments, and proofs from the hash.
- */
-function computeTxHash(serializedTransaction: Hex) {
-  if (serializedTransaction.startsWith('0x03')) {
-    const parsed = parseTransaction(serializedTransaction);
-    if (parsed.blobs || parsed.sidecars) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { blobs, sidecars, ...rest } = parsed;
-      return keccak256(serializeTransaction({ type: 'eip4844', ...rest } as TransactionSerializableEIP4844));
-    }
-  }
-  return keccak256(serializedTransaction);
-}