Add support for state_header access in the SDK

Cargo.toml

@@ -21,7 +21,7 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
-pod2 = { git = "https://github.com/0xPARC/pod2", rev = "da6c08f3c3341a51aa8f7f0f863ec694bcb9d9a3", default-features = false, features = [
+pod2 = { git = "https://github.com/0xPARC/pod2", rev = "73810cbd5b57cd679e25dfad0c34968faec22767", default-features = false, features = [
     "backend_plonky2",
     "disk_cache",
     "zk",
@@ -63,3 +63,11 @@ time = { version = "0.3.44", features = ["formatting", "local-offset"] }
 rand = { version = "0.9.2", features = ["std_rng"] }
 thiserror = "2.0.18"
 wire-types = { path = "libs/wire-types" }
+
+# Uncomment to use a local pod2 dependency
+# [patch."https://github.com/0xPARC/pod2"]
+# pod2 = { path = "../pod2" }
+
+# Uncomment in order to enable debug information in the release builds.  This allows getting panic backtraces with a performance similar to regular release.
+# [profile.release]
+# debug = true

examples/craft-basics/manifest.toml

@@ -2,7 +2,7 @@
 name = "craft-basics"
 version = "0.1.0"
 # Rewritten by `cargo run -p pexe -- build examples/craft-basics`.
-module_hash = "9db3acf116e6c8d635da722b0a17e7988bbffee10590fffe8fc0161aa0be18d0"
+module_hash = "57631b51fb9a921588d391211f94c0bd8f777aff0a16755bc2dfefb52d6ff5b0"
 
 [[classes]]
 name = "Log"

examples/craft-rocket/manifest.toml

@@ -2,7 +2,7 @@
 name = "craft-rocket"
 version = "0.1.0"
 # Rewritten by `cargo run -p pexe -- build examples/craft-rocket`.
-module_hash = "ee913737d2541322c86d4e52c33bbf8bad872970e5e62e336553912b61285349"
+module_hash = "f838acbb5b8a196174ec1adb15b2dc19f60faa5ef76ab0ab60b6ee010f0f964f"
 
 # ── raw resources ────────────────────────────────────────────────────────────
 

libs/payload/src/test_state.rs

@@ -48,6 +48,12 @@ impl TestState {
         }
     }
 
+    pub fn next_block(&mut self, time_delta: u64) {
+        self.block_number += 1;
+        self.block_timestamp += time_delta as i64;
+        self.block_hash = Hash([F(0), F(0), F(0), F(self.block_number as u64)]);
+    }
+
     /// `(created_root, nullifiers_root, prior_state_history_root)`.
     pub fn roots(&self) -> (Hash, Hash, Hash) {
         (

libs/pod2utils/src/macros.rs

@@ -4,7 +4,7 @@ use pod2::{
     frontend::MultiPodBuilder,
     lang::Module,
     middleware::{
-        CustomPredicateRef, Statement, StrKey, Value,
+        CustomPredicateRef, OperationType, Statement, StrKey, Value,
         containers::{Dictionary, Set},
     },
 };
@@ -326,9 +326,16 @@ impl BuildContext {
         statements: Vec<Statement>,
     ) -> anyhow::Result<Statement> {
         for module in &self.modules {
-            if let Some(cpr) = module.predicate_ref_by_name(name) {
+            if module.predicate_ref_by_name(name).is_some() {
                 return module.apply_predicate_with(name, statements, public, |is_public, op| {
                     let mut wildcard_values: Vec<(usize, Value)> = Vec::new();
+                    // Get the CustomPredicateRef from the closure because this may be a chain in a
+                    // split predicate where the wildcard indices are different than the top level
+                    // predicate.
+                    let cpr = match &op.0 {
+                        OperationType::Custom(cpr) => cpr,
+                        _ => unreachable!(),
+                    };
                     for (i, name) in cpr.predicate().wildcard_names().iter().enumerate() {
                         if let Some(value) = wildcard_map.get(name) {
                             wildcard_values.push((i, value.clone()));

libs/sdk/README.md

@@ -164,154 +164,146 @@ use module 0xc2b96ca2c6970e4e950d09408011691c21b6c9c24610e74aec471ea53e0ace65 as
 use intro Vdf(count, input, output) from 0xab82223f501b5056f458f063eb2fc073f8ac01f2ea178a3a2303394fec6828a0
 use intro LtEqU256(lhs, rhs) from 0xe0595e5c75467e5a27bd30fa48a45e1dcc66a327076e5ce7c02ce33dfe357311
 
-record StateHeader = (block_number, created, nullifiers, prior_state_history)
-record FindLogOut = (log)
+record StateHeader = (block_number, block_timestamp, block_hash, created, nullifiers, prior_state_history)
+record FindLogIO = (out_log)
 record FindLogInitials = (log)
-record CraftWoodIn = (log)
-record CraftWoodOut = (wood)
-record CraftSticksIn = (wood)
-record CraftSticksOut = (stick_a, stick_b)
+record CraftWoodIO = (in_log, out_wood)
+record CraftSticksIO = (in_wood, out_stick_a, out_stick_b)
 record CraftSticksChain = (step_0, step_1)
 record CraftSticksInitials = (stick_a, stick_b)
-record CraftWoodPickIn = (wood, stick)
-record CraftWoodPickOut = (pick)
+record CraftWoodPickIO = (in_wood, in_stick, out_pick)
 record CraftWoodPickChain = (step_0, step_1)
 record CraftWoodPickInitials = (pick)
-record UseWoodPickIn = (wood_pick)
-record UseWoodPickOut = (wood_pick)
-record MineStoneWithWoodPickOut = (stone)
+record UseWoodPickIO = (in_wood_pick, out_wood_pick)
+record MineStoneWithWoodPickIO = (out_stone)
 record MineStoneWithWoodPickInitials = (stone)
 
 // Actions
 
-FindLog(out FindLogOut, chain0, chain, private: log0, work, initials FindLogInitials) = AND(
+FindLog(io FindLogIO, state_header StateHeader, chain0, chain, private: log0, work, initials FindLogInitials) = AND(
   Vdf(3, log0, work)
   DictUpdate(log0, "work", work, initials.log)
-  tx::TxInsert(chain0, chain, initials.log, out.log, @self_predicate(IsLog))
+  tx::TxInsert(chain0, chain, initials.log, io.out_log, @self_predicate(IsLog))
 )
 
-CraftWood(in CraftWoodIn, out CraftWoodOut, chain0, chain, private: chain1, wood0, wood1, key) = AND(
+CraftWood(io CraftWoodIO, state_header StateHeader, chain0, chain, private: chain1, wood0, wood1, key) = AND(
   DictUpdate(wood0, "key", key, wood1)
   LtEqU256(wood1, Raw(0x0020000000000000000000000000000000000000000000000000000000000000))
-  tx::TxDelete(chain0, chain1, in.log, @self_predicate(IsLog))
-  tx::TxInsert(chain1, chain, wood1, out.wood, @self_predicate(IsWood))
+  tx::TxDelete(chain0, chain1, io.in_log, @self_predicate(IsLog))
+  tx::TxInsert(chain1, chain, wood1, io.out_wood, @self_predicate(IsWood))
 )
 
-CraftSticks(in CraftSticksIn, out CraftSticksOut, chain0, chain, private: chain_steps CraftSticksChain, initials CraftSticksInitials
-) = AND(
-  tx::TxDelete(chain0, chain_steps.step_0, in.wood, @self_predicate(IsWood))
-  tx::TxInsert(chain_steps.step_0, chain_steps.step_1, initials.stick_a, out.stick_a, @self_predicate(IsStick))
-  tx::TxInsert(chain_steps.step_1, chain, initials.stick_b, out.stick_b, @self_predicate(IsStick))
+CraftSticks(io CraftSticksIO, state_header StateHeader, chain0, chain, private: chain_steps CraftSticksChain, initials CraftSticksInitials) = AND(
+  tx::TxDelete(chain0, chain_steps.step_0, io.in_wood, @self_predicate(IsWood))
+  tx::TxInsert(chain_steps.step_0, chain_steps.step_1, initials.stick_a, io.out_stick_a, @self_predicate(IsStick))
+  tx::TxInsert(chain_steps.step_1, chain, initials.stick_b, io.out_stick_b, @self_predicate(IsStick))
 )
 
-CraftWoodPick(in CraftWoodPickIn, out CraftWoodPickOut, chain0, chain, private: chain_steps CraftWoodPickChain, initials CraftWoodPi
-ckInitials) = AND(
+CraftWoodPick(io CraftWoodPickIO, state_header StateHeader, chain0, chain, private: chain_steps CraftWoodPickChain, initials CraftWoodPickInitials) = AND(
   DictContains(initials.pick, "durability", 100)
-  tx::TxDelete(chain0, chain_steps.step_0, in.wood, @self_predicate(IsWood))
-  tx::TxDelete(chain_steps.step_0, chain_steps.step_1, in.stick, @self_predicate(IsStick))
-  tx::TxInsert(chain_steps.step_1, chain, initials.pick, out.pick, @self_predicate(IsWoodPick))
+  tx::TxDelete(chain0, chain_steps.step_0, io.in_wood, @self_predicate(IsWood))
+  tx::TxDelete(chain_steps.step_0, chain_steps.step_1, io.in_stick, @self_predicate(IsStick))
+  tx::TxInsert(chain_steps.step_1, chain, initials.pick, io.out_pick, @self_predicate(IsWoodPick))
 )
 
-UseWoodPick(in UseWoodPickIn, out UseWoodPickOut, chain0, chain, private: wood_pick0, wood_pick1, wood_pick2, durability, key, work)
- = AND(
-  ArrayContains(in, UseWoodPickIn::wood_pick, wood_pick0)
+UseWoodPick(io UseWoodPickIO, state_header StateHeader, chain0, chain, private: wood_pick0, wood_pick1, wood_pick2, durability, key, work) = AND(
+  ArrayContains(io, UseWoodPickIO::in_wood_pick, wood_pick0)
   Gt(wood_pick0.durability, 0)
   Sum(durability, 1, wood_pick0.durability)
   DictUpdate(wood_pick0, "durability", durability, wood_pick1)
   DictUpdate(wood_pick1, "key", key, wood_pick2)
   Vdf(10, wood_pick2, work)
-  DictUpdate(wood_pick2, "work", work, out.wood_pick)
-  tx::TxMutate(chain0, chain, wood_pick0, out.wood_pick, @self_predicate(IsWoodPick))
+  DictUpdate(wood_pick2, "work", work, io.out_wood_pick)
+  tx::TxMutate(chain0, chain, wood_pick0, io.out_wood_pick, @self_predicate(IsWoodPick))
 )
 
-MineStoneWithWoodPick(out MineStoneWithWoodPickOut, chain0, chain, private: chain1, _UseWoodPick_in_0 UseWoodPickIn, _UseWoodPick_ou
-t_0 UseWoodPickOut, initials MineStoneWithWoodPickInitials) = AND(
-  UseWoodPick(_UseWoodPick_in_0, _UseWoodPick_out_0, chain0, chain1)
-  tx::TxInsert(chain1, chain, initials.stone, out.stone, @self_predicate(IsStone))
+MineStoneWithWoodPick(io MineStoneWithWoodPickIO, state_header StateHeader, chain0, chain, private: chain1, _UseWoodPick_io_0 UseWoodPickIO, initials MineStoneWithWoodPickInitials) = AND(
+  UseWoodPick(_UseWoodPick_io_0, state_header, chain0, chain1)
+  tx::TxInsert(chain1, chain, initials.stone, io.out_stone, @self_predicate(IsStone))
 )
 
 // Bridges
 
-IsLogFromFindLog(state, chain0, chain, private: out FindLogOut) = AND(
-  ArrayContains(out, FindLogOut::log, state)
-  FindLog(out, chain0, chain)
+IsLogFromFindLog(state, state_header, chain0, chain, private: io FindLogIO) = AND(
+  ArrayContains(io, FindLogIO::out_log, state)
+  FindLog(io, state_header, chain0, chain)
 )
 
-IsLogFromCraftWood(state, chain0, chain, private: in CraftWoodIn, out CraftWoodOut) = AND(
-  ArrayContains(in, CraftWoodIn::log, state)
-  CraftWood(in, out, chain0, chain)
+IsLogFromCraftWood(state, state_header, chain0, chain, private: io CraftWoodIO) = AND(
+  ArrayContains(io, CraftWoodIO::in_log, state)
+  CraftWood(io, state_header, chain0, chain)
 )
 
-IsWoodFromCraftWood(state, chain0, chain, private: in CraftWoodIn, out CraftWoodOut) = AND(
-  ArrayContains(out, CraftWoodOut::wood, state)
-  CraftWood(in, out, chain0, chain)
+IsWoodFromCraftWood(state, state_header, chain0, chain, private: io CraftWoodIO) = AND(
+  ArrayContains(io, CraftWoodIO::out_wood, state)
+  CraftWood(io, state_header, chain0, chain)
 )
 
-IsWoodFromCraftSticks(state, chain0, chain, private: in CraftSticksIn, out CraftSticksOut) = AND(
-  ArrayContains(in, CraftSticksIn::wood, state)
-  CraftSticks(in, out, chain0, chain)
+IsWoodFromCraftSticks(state, state_header, chain0, chain, private: io CraftSticksIO) = AND(
+  ArrayContains(io, CraftSticksIO::in_wood, state)
+  CraftSticks(io, state_header, chain0, chain)
 )
 
-IsStickFromCraftSticks_stick_a(state, chain0, chain, private: in CraftSticksIn, out CraftSticksOut) = AND(
-  ArrayContains(out, CraftSticksOut::stick_a, state)
-  CraftSticks(in, out, chain0, chain)
+IsStickFromCraftSticks_stick_a(state, state_header, chain0, chain, private: io CraftSticksIO) = AND(
+  ArrayContains(io, CraftSticksIO::out_stick_a, state)
+  CraftSticks(io, state_header, chain0, chain)
 )
 
-IsStickFromCraftSticks_stick_b(state, chain0, chain, private: in CraftSticksIn, out CraftSticksOut) = AND(
-  ArrayContains(out, CraftSticksOut::stick_b, state)
-  CraftSticks(in, out, chain0, chain)
+IsStickFromCraftSticks_stick_b(state, state_header, chain0, chain, private: io CraftSticksIO) = AND(
+  ArrayContains(io, CraftSticksIO::out_stick_b, state)
+  CraftSticks(io, state_header, chain0, chain)
 )
 
-IsWoodFromCraftWoodPick(state, chain0, chain, private: in CraftWoodPickIn, out CraftWoodPickOut) = AND(
-  ArrayContains(in, CraftWoodPickIn::wood, state)
-  CraftWoodPick(in, out, chain0, chain)
+IsWoodFromCraftWoodPick(state, state_header, chain0, chain, private: io CraftWoodPickIO) = AND(
+  ArrayContains(io, CraftWoodPickIO::in_wood, state)
+  CraftWoodPick(io, state_header, chain0, chain)
 )
 
-IsStickFromCraftWoodPick(state, chain0, chain, private: in CraftWoodPickIn, out CraftWoodPickOut) = AND(
-  ArrayContains(in, CraftWoodPickIn::stick, state)
-  CraftWoodPick(in, out, chain0, chain)
+IsStickFromCraftWoodPick(state, state_header, chain0, chain, private: io CraftWoodPickIO) = AND(
+  ArrayContains(io, CraftWoodPickIO::in_stick, state)
+  CraftWoodPick(io, state_header, chain0, chain)
 )
 
-IsWoodPickFromCraftWoodPick(state, chain0, chain, private: in CraftWoodPickIn, out CraftWoodPickOut) = AND(
-  ArrayContains(out, CraftWoodPickOut::pick, state)
-  CraftWoodPick(in, out, chain0, chain)
+IsWoodPickFromCraftWoodPick(state, state_header, chain0, chain, private: io CraftWoodPickIO) = AND(
+  ArrayContains(io, CraftWoodPickIO::out_pick, state)
+  CraftWoodPick(io, state_header, chain0, chain)
 )
 
-IsWoodPickFromUseWoodPick(state, chain0, chain, private: in UseWoodPickIn, out UseWoodPickOut) = AND(
-  ArrayContains(out, UseWoodPickOut::wood_pick, state)
-  UseWoodPick(in, out, chain0, chain)
+IsWoodPickFromUseWoodPick(state, state_header, chain0, chain, private: io UseWoodPickIO) = AND(
+  ArrayContains(io, UseWoodPickIO::out_wood_pick, state)
+  UseWoodPick(io, state_header, chain0, chain)
 )
 
-IsStoneFromMineStoneWithWoodPick(state, chain0, chain, private: out MineStoneWithWoodPickOut) = AND(
-  ArrayContains(out, MineStoneWithWoodPickOut::stone, state)
-  MineStoneWithWoodPick(out, chain0, chain)
+IsStoneFromMineStoneWithWoodPick(state, state_header, chain0, chain, private: io MineStoneWithWoodPickIO) = AND(
+  ArrayContains(io, MineStoneWithWoodPickIO::out_stone, state)
+  MineStoneWithWoodPick(io, state_header, chain0, chain)
 )
 
 // Classes
 
 IsLog(state, state_header StateHeader, chain0, chain) = OR(
-  IsLogFromFindLog(state, chain0, chain)
-  IsLogFromCraftWood(state, chain0, chain)
+  IsLogFromFindLog(state, state_header, chain0, chain)
+  IsLogFromCraftWood(state, state_header, chain0, chain)
 )
 
 IsWood(state, state_header StateHeader, chain0, chain) = OR(
-  IsWoodFromCraftWood(state, chain0, chain)
-  IsWoodFromCraftSticks(state, chain0, chain)
-  IsWoodFromCraftWoodPick(state, chain0, chain)
+  IsWoodFromCraftWood(state, state_header, chain0, chain)
+  IsWoodFromCraftSticks(state, state_header, chain0, chain)
+  IsWoodFromCraftWoodPick(state, state_header, chain0, chain)
 )
 
 IsStick(state, state_header StateHeader, chain0, chain) = OR(
-  IsStickFromCraftSticks_stick_a(state, chain0, chain)
-  IsStickFromCraftSticks_stick_b(state, chain0, chain)
-  IsStickFromCraftWoodPick(state, chain0, chain)
+  IsStickFromCraftSticks_stick_a(state, state_header, chain0, chain)
+  IsStickFromCraftSticks_stick_b(state, state_header, chain0, chain)
+  IsStickFromCraftWoodPick(state, state_header, chain0, chain)
 )
 
 IsWoodPick(state, state_header StateHeader, chain0, chain) = OR(
-  IsWoodPickFromCraftWoodPick(state, chain0, chain)
-  IsWoodPickFromUseWoodPick(state, chain0, chain)
+  IsWoodPickFromCraftWoodPick(state, state_header, chain0, chain)
+  IsWoodPickFromUseWoodPick(state, state_header, chain0, chain)
 )
 
 IsStone(state, state_header StateHeader, chain0, chain) = OR(
-  IsStoneFromMineStoneWithWoodPick(state, chain0, chain)
+  IsStoneFromMineStoneWithWoodPick(state, state_header, chain0, chain)
 )
 ```