gnidan · Oct 7, 2026 · Oct 7, 2026
diff --git a/packages/bugc-react/CHANGELOG.md b/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`
+  ([#363]).
+
 ## 0.1.0-preview.1 — 2026-10-03
 
 Updated `@ethdebug/bugc` to `0.1.0-preview.1`.
@@ -34,3 +39,4 @@ First publication.
 
 [#299]: https://github.com/ethdebug/format/pull/299
 [#300]: https://github.com/ethdebug/format/pull/300
+[#363]: https://github.com/ethdebug/format/pull/363
diff --git a/packages/bugc-react/src/components/CfgView.tsx b/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}`;
         }

diff --git a/packages/bugc/CHANGELOG.md b/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`) ([#363]).
 - 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]).
@@ -290,3 +292,4 @@ First publication.
 [#349]: https://github.com/ethdebug/format/pull/349
 [#351]: https://github.com/ethdebug/format/pull/351
 [#352]: https://github.com/ethdebug/format/pull/352
+[#363]: https://github.com/ethdebug/format/pull/363
diff --git a/packages/bugc/src/ast/spec.ts b/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,
+      };
+    }
   }
 }
 

diff --git a/packages/bugc/src/ast/visitor.ts b/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:

diff --git a/packages/bugc/src/evmgen/behavioral.test.ts b/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;
 

diff --git a/packages/bugc/src/evmgen/generation/instructions/env.ts b/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>()

diff --git a/packages/bugc/src/ir/analysis/validator.ts b/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}'`);

diff --git a/packages/bugc/src/ir/spec/instruction.ts b/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;
   }

diff --git a/packages/bugc/src/irgen/generate/expressions/expression.ts b/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);

diff --git a/packages/bugc/src/irgen/generate/expressions/special.ts b/packages/bugc/src/irgen/generate/expressions/special.ts
@@ -44,6 +44,9 @@ export function* buildSpecial(expr: Ast.Expression.Special): Process<Ir.Value> {
     case "expression:special:block.number":
       op = "block_number";
       break;
+    case "expression:special:block.prevrandao":
+      op = "block_prevrandao";
+      break;
     default:
       assertExhausted(expr);
   }

diff --git a/packages/bugc/src/irgen/generator.test.ts b/packages/bugc/src/irgen/generator.test.ts
@@ -417,6 +417,7 @@ describe("generateModule", () => {
         code {
           let num = block.number;
           let time = block.timestamp;
+          let randao = block.prevrandao;
         }
       `;
 
@@ -430,8 +431,13 @@ describe("generateModule", () => {
         (i) => i.kind === "env" && i.op === "block_timestamp",
       );
 
+      const prevrandaoInst = entry.instructions.find(
+        (i) => i.kind === "env" && i.op === "block_prevrandao",
+      );
+
       expect(numberInst).toBeDefined();
       expect(timestampInst).toBeDefined();
+      expect(prevrandaoInst).toBeDefined();
     });
   });
 

diff --git a/packages/bugc/src/parser/parser.ts b/packages/bugc/src/parser/parser.ts
@@ -535,18 +535,25 @@ const msgExpression = located(
   }),
 );
 
-// block.timestamp and block.number as special expressions
+// block.timestamp, block.number and block.prevrandao as special
+// expressions
 const blockExpression = located(
   P.seq(
     Lang.keyword("block"),
     Lang.dot,
-    P.alt(Lang.keyword("timestamp"), Lang.keyword("number")),
+    P.alt(
+      Lang.keyword("timestamp"),
+      Lang.keyword("number"),
+      Lang.keyword("prevrandao"),
+    ),
   ).map(([_, __, property]) => {
-    const kind = property === "timestamp" ? "block.timestamp" : "block.number";
-    if (kind === "block.timestamp") {
-      return Ast.Expression.Special.blockTimestamp(PENDING_ID);
-    } else {
-      return Ast.Expression.Special.blockNumber(PENDING_ID);
+    switch (property) {
+      case "timestamp":
+        return Ast.Expression.Special.blockTimestamp(PENDING_ID);
+      case "number":
+        return Ast.Expression.Special.blockNumber(PENDING_ID);
+      default:
+        return Ast.Expression.Special.blockPrevrandao(PENDING_ID);
     }
   }),
 );

diff --git a/packages/bugc/src/typechecker/expressions.ts b/packages/bugc/src/typechecker/expressions.ts
@@ -1037,6 +1037,9 @@ export const expressionChecker: Pick<Visitor<Report, Context>, "expression"> = {
         case "expression:special:block.number":
           type = Type.Elementary.uint(256);
           break;
+        case "expression:special:block.prevrandao":
+          type = Type.Elementary.uint(256);
+          break;
       }
 
       const nodeTypes = new Map(context.nodeTypes);