bugc: add block.prevrandao

Author: gnidan

packages/bugc-react/CHANGELOG.md

@@ -7,6 +7,11 @@ specification itself are tracked in the root
 
 ## Unreleased
 
+### Added
+
+- The CFG view shows a `block.prevrandao` read as `block.prevrandao`
+  ([#PR]).
+
 ## 0.1.0-preview.1 — 2026-10-03
 
 Updated `@ethdebug/bugc` to `0.1.0-preview.1`.

packages/bugc-react/src/components/CfgView.tsx

@@ -349,6 +349,8 @@ function CfgViewContent({ ir }: CfgViewProps): JSX.Element {
             return `${envInst.dest} = block.timestamp`;
           case "block_number":
             return `${envInst.dest} = block.number`;
+          case "block_prevrandao":
+            return `${envInst.dest} = block.prevrandao`;
           default:
             return `${envInst.dest} = ${envInst.op}`;
         }

packages/bugc/CHANGELOG.md

@@ -9,6 +9,8 @@ support. Changes to the specification itself are tracked in the root
 
 ### Added
 
+- `block.prevrandao`, the previous block's RANDAO value (EIP-4399), as a
+  `uint256`. It compiles to the EVM's `PREVRANDAO` (`0x44`) ([#PR]).
 - The `%` operator, with the precedence of `*` and `/`. It compiles to
   the EVM's `MOD` (`SMOD` for signed operands), so `x % 0` is `0`, as
   `x / 0` is ([#321]).

packages/bugc/src/ast/spec.ts

@@ -1439,7 +1439,8 @@ export namespace Expression {
     | Expression.Special.MsgValue
     | Expression.Special.MsgData
     | Expression.Special.BlockTimestamp
-    | Expression.Special.BlockNumber;
+    | Expression.Special.BlockNumber
+    | Expression.Special.BlockPrevrandao;
 
   export const isSpecial = (
     expression: Expression.Base,
@@ -1451,6 +1452,7 @@ export namespace Expression {
       Expression.Special.isMsgSender,
       Expression.Special.isBlockNumber,
       Expression.Special.isBlockTimestamp,
+      Expression.Special.isBlockPrevrandao,
     ].some((guard) => guard(expression));
 
   export namespace Special {
@@ -1532,6 +1534,26 @@ export namespace Expression {
     export function blockNumber(id: Id, loc?: SourceLocation): BlockNumber {
       return { id, kind: "expression:special:block.number", loc: loc ?? null };
     }
+
+    export interface BlockPrevrandao extends Base {
+      kind: "expression:special:block.prevrandao";
+    }
+
+    export const isBlockPrevrandao = (
+      expression: Expression.Base,
+    ): expression is BlockPrevrandao =>
+      expression.kind === "expression:special:block.prevrandao";
+
+    export function blockPrevrandao(
+      id: Id,
+      loc?: SourceLocation,
+    ): BlockPrevrandao {
+      return {
+        id,
+        kind: "expression:special:block.prevrandao",
+        loc: loc ?? null,
+      };
+    }
   }
 }
 

packages/bugc/src/ast/visitor.ts

@@ -201,6 +201,7 @@ export function visitDetailed<N extends Ast.Node, T, C = never>(
     case "expression:special:msg.data":
     case "expression:special:block.timestamp":
     case "expression:special:block.number":
+    case "expression:special:block.prevrandao":
       return visitor.expressionSpecial(node as Ast.Expression.Special, context);
 
     default:

packages/bugc/src/evmgen/behavioral.test.ts

@@ -3,6 +3,7 @@ import { describe, it, expect } from "vitest";
 import { keccak256 } from "ethereum-cryptography/keccak";
 import { bytesToHex } from "ethereum-cryptography/utils";
 
+import { compile } from "#compiler";
 import { executeProgram } from "#test/evm/behavioral";
 
 describe("behavioral tests", () => {
@@ -1289,6 +1290,38 @@ code {
     }
   });
 
+  describe("block.prevrandao", () => {
+    const source = `name Randao;
+storage { [0] out: uint256; }
+code {
+  out = block.prevrandao + 1;
+}`;
+
+    for (const level of [0, 1, 2, 3] as const) {
+      it(`should read PREVRANDAO (level ${level})`, async () => {
+        const compiled = await compile({
+          to: "bytecode",
+          source,
+          optimizer: { level },
+        });
+        if (!compiled.success) throw new Error("compile failed");
+        const mnemonics =
+          compiled.value.bytecode.runtimeProgram.instructions.map(
+            (instruction) => instruction.operation?.mnemonic,
+          );
+        expect(mnemonics).toContain("PREVRANDAO");
+
+        // @ethdebug/evm runs each call in a block whose prevrandao is 0
+        const result = await executeProgram(source, {
+          calldata: "",
+          optimizationLevel: level,
+        });
+        expect(result.callSuccess).toBe(true);
+        expect(await result.getStorage(0n)).toBe(1n);
+      });
+    }
+  });
+
   describe("modulo", () => {
     const program = (expr: string) => `name Modulo;
 

packages/bugc/src/evmgen/generation/instructions/env.ts

@@ -6,7 +6,7 @@ import { type Transition, pipe, operations } from "#evmgen/operations";
 
 import { storeValueIfNeeded } from "../values/index.js";
 
-const { CALLER, CALLVALUE, PUSH0, TIMESTAMP, NUMBER } = operations;
+const { CALLER, CALLVALUE, PUSH0, TIMESTAMP, NUMBER, PREVRANDAO } = operations;
 
 /**
  * Generate code for environment operations
@@ -26,6 +26,7 @@ export function generateEnvOp<S extends Stack>(
     msg_data: PUSH0({ debug }), // Returns calldata offset (0)
     block_timestamp: TIMESTAMP({ debug }),
     block_number: NUMBER({ debug }),
+    block_prevrandao: PREVRANDAO({ debug }),
   };
 
   return pipe<S>()

packages/bugc/src/ir/analysis/validator.ts

@@ -212,6 +212,7 @@ export class Validator {
       "msg_value",
       "block_number",
       "block_timestamp",
+      "block_prevrandao",
     ];
     if (!validOps.includes(inst.op)) {
       this.error(`Invalid env operation '${inst.op}'`);

packages/bugc/src/ir/spec/instruction.ts

@@ -383,7 +383,8 @@ export namespace Instruction {
       | "msg_value"
       | "msg_data"
       | "block_number"
-      | "block_timestamp";
+      | "block_timestamp"
+      | "block_prevrandao";
 
     dest: string;
   }

packages/bugc/src/irgen/generate/expressions/expression.ts

@@ -50,6 +50,7 @@ export function* buildExpression(
     case "expression:special:msg.data":
     case "expression:special:block.timestamp":
     case "expression:special:block.number":
+    case "expression:special:block.prevrandao":
       return yield* buildSpecial(expr as Ast.Expression.Special);
     case "expression:array":
       return yield* buildArray(expr as Ast.Expression.Array, context);