bump to fulu and test with blob tx

Author: canercidam

commands/test.ts

@@ -7,8 +7,13 @@
 import { Command } from "jsr:@cliffy/command@^1.0.0-rc.7";
 import {
   type AddressLike,
+  concat,
+  decodeRlp,
+  encodeRlp,
   getBytes,
+  hexlify,
   keccak256,
+  sha256,
   toUtf8String,
   Transaction,
   Wallet,
@@ -20,9 +25,99 @@ const STATIC_PREFUNDED = [
   "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
 ];
 
+export type TxType = "legacy" | "blob";
+
 const DEFAULT_VALUE_WEI = 100_000_000_000_000_000n; // 0.1 ETH
 const DEFAULT_GAS_LIMIT = 21000n;
 const DEFAULT_GAS_PRICE = 1_000_000_000n; // 1 gwei
+// EIP-1559/blob fee fields (blob tx is type 3, so it can't use gasPrice).
+const DEFAULT_PRIORITY_FEE = 1_000_000_000n; // 1 gwei
+const DEFAULT_MAX_FEE = 10_000_000_000n; // 10 gwei — covers devnet base fee
+const DEFAULT_MAX_BLOB_FEE = 1_000_000_000n; // 1 gwei — well above the 1 wei min
+
+const BLOB_SIZE = 4096 * 32; // one EIP-4844 blob: 4096 field elements × 32 bytes
+
+// kzg-wasm, loaded lazily so the legacy path never pays for the WASM init. Its
+// trusted setup is network-agnostic, so the bundled mainnet setup is correct on
+// any devnet. v1 exposes the EIP-7594 cell-proof ops required post-Osaka.
+type KzgApi = {
+  blobToKZGCommitment: (blob: string) => string;
+  computeCellsAndProofs: (blob: string) => [string[], string[]];
+};
+let kzgLib: Promise<KzgApi> | null = null;
+function getKzg(): Promise<KzgApi> {
+  if (!kzgLib) {
+    kzgLib = import("npm:kzg-wasm@^1.0.0").then((m) => m.loadKZG() as Promise<KzgApi>);
+  }
+  return kzgLib;
+}
+
+const hx = (s: string): string => (s.startsWith("0x") ? s : `0x${s}`);
+
+// A single valid blob: a short marker in the first field element (leading byte
+// left 0 so the element stays below the BLS modulus), the rest zero-filled.
+function makeBlob(marker: string): Uint8Array {
+  const blob = new Uint8Array(BLOB_SIZE);
+  blob.set(new TextEncoder().encode(marker).subarray(0, 31), 1);
+  return blob;
+}
+
+// versioned hash = 0x01 ‖ sha256(commitment)[1:]  (VERSIONED_HASH_VERSION_KZG)
+function blobVersionedHash(commitment: string): string {
+  const h = getBytes(sha256(hx(commitment)));
+  h[0] = 0x01;
+  return hexlify(h);
+}
+
+// Build a post-Osaka (EIP-7594/PeerDAS) blob tx. ethers only serializes the
+// legacy EIP-4844 sidecar, so we let it produce the signed canonical tx
+// (0x03 ‖ rlp(body)) and re-wrap it as the cell-proof network form it can't
+// emit:  0x03 ‖ rlp([body, wrapper_version=1, blobs, commitments, cell_proofs])
+async function signBlobTx(wallet: Wallet, to: string, nonce: number, cid: bigint): Promise<string> {
+  const kzg = await getKzg();
+  const blob = hexlify(makeBlob("decker blob tx"));
+  const commitment = hx(kzg.blobToKZGCommitment(blob));
+  const cellProofs = kzg.computeCellsAndProofs(blob)[1].map(hx); // 128 proofs per blob
+
+  const tx = new Transaction();
+  tx.type = 3;
+  tx.to = to;
+  tx.value = DEFAULT_VALUE_WEI;
+  tx.nonce = nonce;
+  tx.chainId = cid;
+  tx.gasLimit = DEFAULT_GAS_LIMIT;
+  tx.maxPriorityFeePerGas = DEFAULT_PRIORITY_FEE;
+  tx.maxFeePerGas = DEFAULT_MAX_FEE;
+  tx.maxFeePerBlobGas = DEFAULT_MAX_BLOB_FEE;
+  tx.blobVersionedHashes = [blobVersionedHash(commitment)];
+  // Sign the instance directly so we keep the canonical (sidecar-free) signed tx.
+  tx.signature = wallet.signingKey.sign(tx.unsignedHash);
+
+  const body = decodeRlp(hx(tx.serialized.slice(4))); // strip 0x03, decode rlp(body)
+  const wrapper = encodeRlp([body, "0x01", [blob], [commitment], cellProofs]);
+  return concat(["0x03", wrapper]);
+}
+
+async function signTx(
+  type: TxType,
+  wallet: Wallet,
+  to: string,
+  nonce: number,
+  cid: bigint,
+): Promise<string> {
+  if (type === "blob") return await signBlobTx(wallet, to, nonce, cid);
+  const tx = Transaction.from({
+    type: 0,
+    to,
+    value: DEFAULT_VALUE_WEI,
+    gasLimit: DEFAULT_GAS_LIMIT,
+    gasPrice: DEFAULT_GAS_PRICE,
+    nonce,
+    chainId: cid,
+    data: "0x",
+  });
+  return await wallet.signTransaction(tx);
+}
 
 function hhmmss(d: Date): string {
   const pad = (n: number) => String(n).padStart(2, "0");
@@ -102,6 +197,7 @@ export type TestOpts = {
   retries: number; // 0 = retry forever
   insecure: boolean;
   expectedExtraData?: string;
+  type: TxType;
 };
 
 export async function runTest(opts: TestOpts): Promise<number> {
@@ -120,19 +216,10 @@ export async function runTest(opts: TestOpts): Promise<number> {
   const nonce = await pendingNonce(el, wallet.address);
   console.log(`${dim("Nonce:")}    ${accent(String(nonce))}`);
 
-  const tx = Transaction.from({
-    type: 0,
-    to: toAddress,
-    value: DEFAULT_VALUE_WEI,
-    gasLimit: DEFAULT_GAS_LIMIT,
-    gasPrice: DEFAULT_GAS_PRICE,
-    nonce,
-    chainId: cid,
-    data: "0x",
-  });
-  const signed = await wallet.signTransaction(tx);
+  const signed = await signTx(opts.type, wallet, toAddress, nonce, cid);
 
-  console.log(`${dim("Sending transaction at")} ${accent(hhmmss(new Date()))}`);
+  const label = opts.type === "blob" ? "blob transaction" : "transaction";
+  console.log(`${dim(`Sending ${label} at`)} ${accent(hhmmss(new Date()))}`);
   const txHash = await sendRawTx(target, signed);
   console.log(`${dim("TX Hash:")}  ${accent(txHash)}`);
 
@@ -205,14 +292,22 @@ export const command = new Command()
   .option("--expected-extra-data <s:string>", "Verify block extra data matches this string", {
     default: "",
   })
+  .option("--type <type:string>", "Transaction type to send: legacy or blob", {
+    default: "legacy",
+  })
   .action(async (opts) => {
+    if (opts.type !== "legacy" && opts.type !== "blob") {
+      console.error(err(`unknown --type ${JSON.stringify(opts.type)} (expected: legacy, blob)`));
+      Deno.exit(2);
+    }
     Deno.exit(await runTest({
       rpc: opts.rpc,
       elRpc: opts.elRpc,
       timeoutMs: parseDuration(opts.timeout),
       retries: opts.retries,
       insecure: opts.insecure,
       expectedExtraData: opts.expectedExtraData,
+      type: opts.type,
     }));
   });
 

recipes/rbuilder-reth2.ts

@@ -8,7 +8,7 @@ import { relayWarmup } from "../scripts/relay-warmup.ts";
 // (see containers/reth-rbuilder.ts and utils/binary-build.ts). The first run
 // triggers a full cargo build; the binary is then cached under cache/bins/.
 export const recipe: Recipe = {
-  artifacts: { generator: "l1", fork: "electra" },
+  artifacts: { generator: "l1", fork: "fulu" },
   scripts: [
     relayWarmup({
       relays: [{ container: "mev-boost-relay-1" }],