← demo0xb63616…6359Partialblock 101
Engine loading — 18 MB128 / 1315
FetchingOpeningPositioning
noir
Narrow session: Code, Call Trace and Values only, read-only. The event log and stepping need a wider viewport.
Code
Loopiterate_asteroidsline 4Iteration 1 of 8Iteration 2 of 8Iteration 3 of 8Iteration 4 of 8Iteration 5 of 8Iteration 6 of 8Iteration 7 of 8Iteration 8 of 812345678
1 [package]
2 name = "zk_shields"
3 type = "bin"
4 authors = [""]
5 compiler_version = ">=0.29.0"
6 version = "1.0.0"
7
8 [dependencies]
9
10 [tool.NodeGuardians]
11 part_1 = "Shield Calculations"
12 part_2 = "Survival Proof"
1 initial_shield = "10000"
2
3 shield_regen_percentage = "10"
4
5 asteroid_masses_positive = [
6 "100",
7 "2000",
8 "200",
9 "100",
10 "100",
11 "50",
12 "50",
13 "14",
14 ]
15
16 asteroid_masses_negative = ["2000", "300", "200", "20", "15", "20", "1", "1"]
1 mod shield;
2
3 // We are on a space ship, moving near light speed towards a distant planet
4 // We are about to pass trough an asteroid field, changing the course is very expensive at this speed
5 // We have to proove to everyone that we can survive the collisions
6
7 // We need to have at least 1 unit of shields left in order to survive the cosmic radiation.
8
9 // We can not reveal how much shields we have will have in the end so that the space pirates won't know if it is safe to atack us
10 // The space pirates can track our course but our shield technology remains a well guarded secret
11
12·fn main(initial_shield: Field, shield_regen_percentage: Field, asteroid_masses_positive: pub [Field; 8], asteroid_masses_negative: pub [Field; 8]) -> pub bool {
13· println("Positive Test Case");
14
15· let did_survive_positive = shield::iterate_asteroids(initial_shield, shield_regen_percentage , asteroid_masses_positive);
16 if(did_survive_positive){
17 println("shields will hold as expected")
18 }
19 else{
20 println("shields will not hold but where expected to hold")
21 }
22
23 println("------------------");
24 println("Negative Test Case");
25 println("------------------");
26
27 let did_survive_negative = shield::iterate_asteroids(initial_shield, shield_regen_percentage, asteroid_masses_negative);
28 if(did_survive_negative){
29 println("shields will hold, but where expected to fail")
30 }
31 else{
32 println("shields will not hold as expected")
33 }
34
35 assert(did_survive_positive == true);
36 assert(did_survive_negative == false);
37 did_survive_positive & !did_survive_negative
38 }
Showing from line 26 — the session's position is below, and the lines above it are not in this window.
26· let shield_pct = calculate_remaining_shield_pct(initial_shield, remaining_shield);+3+3+3
+3+3+3
27· let mut damage = 0;damage=0damage=0damage=0
+1+1+1
28· if(shield_pct == 100){shield_pct=100shield_pct=100shield_pct=90
+1+1+1
29·⊘⊙ damage = mass * 1;damage:0→100mass=100damage:0→2000mass=2000+2+2
+2+2
30 }
31· else{
32▶⊘⊙ damage = mass * (100 - shield_pct);damage:0→2000mass=200shield_pct=90+3+2+1
+3
33 }
34· if(damage as u32 > remaining_shield as u32){damage=100remaining_shield=10000damage=2000remaining_shield=10000→100→2000+2+2+1+1
+3+3
35 damage = remaining_shield;
36 }
37· damage as Field
38 }
39
40·fn calculate_shield_regeneration(initial_shield:Field, remaining_shield:Field, shield_regen_percentage: Field) -> Field{
+3+3
41 // shields regain a percentage of the maxium capacity after each hit
42· let mut regen = (initial_shield * shield_regen_percentage) / 100;regen=1000regen=1000+2+2
+3+3
43· if((remaining_shield + regen) as u32 > initial_shield as u32){remaining_shield=9900regen=1000remaining_shield=8000→1000+3+3+1+2
+3+4
44·⊘⊙ regen = initial_shield - remaining_shield;regen=1000initial_shield=10000→100+3+2+1
+4
45 }
46· regen as Field
47 }
48·fn calculate_remaining_shield_pct(initial_shield: Field, remaining_shield: Field) -> Field {+2+3+2
+2+3+2
49· let result = (remaining_shield * 100) as u32 / initial_shield as u32;result=100result=100result=90result=90+2+4+2+2+3+2
+3+5+3
50· result as Fieldresult=100result=100result=90result=90→100→100→90→90+2
+2+4+2
51 }
52
53·fn status_report(iteration: u32 ,initial_shield: Field, remaining_shield: Field, damage: Field, regenerated_shield: Field){
+5+5
54· println(f"----- iteration {iteration} -----");iteration=0iteration=1+1+1
+1+1
55
56 // in noir, fields can't be printed directly so we convert them to an integer type first
57· let damage_as_u32 = damage as u32;damage_as_u32=100damage=100damage_as_u32=2000damage=2000+2+2+1+1
+2+2
58· println(f"Damage: {damage_as_u32}");damage_as_u32=100damage_as_u32=2000+1+1
+1+1
59
60· let regenerated_shield_as_u32 = regenerated_shield as u32;regenerated_shield_as_u32=100regenerated_shield_as_u32=1000+2+2+1+1
+2+2
61· println(f"Regenerated {regenerated_shield_as_u32} energy");regenerated_shield_as_u32=100regenerated_shield_as_u32=1000+1+1
+1+1
62
63· let remaining_shield_as_u32 = remaining_shield as u32;remaining_shield_as_u32=10000remaining_shield=10000remaining_shield_as_u32=9000remaining_shield=9000+2+2+1+1
+2+2
64· let remaining_shield_pct = calculate_remaining_shield_pct(initial_shield, remaining_shield);+3+3
+3+3
65· let remaining_shield_pct_as_u32 = remaining_shield_pct as u32;remaining_shield_pct_as_u32=100remaining_shield_pct_as_u32=90+2+2+1+1
+2+2
66· println(f"Shield status {remaining_shield_pct_as_u32}% {remaining_shield_as_u32}");+2+2
+2+2
67 }
Event Log
→call6iterate_asteroidsinitial_shield=10000, regen=10%
·output22----- iteration 0 -----stdout
◆write31shields[0]10000 → 9900
◇event58ShieldImpactiteration=0, damage=100
·output74Shield status 100% 10000stdout
◆write96shields[1]10000 → 8000
→call112calculate_damagemass=200
◇event121ShieldImpactiteration=2, damage=2000
Call Trace
FunctionCallsSelf ACIR opcodes
iterate_asteroidszk_shields · src/shield.nr1986
mainzk_shields · src/main.nr1107
calculate_damagezk_shields · src/shield.nr2104
status_reportzk_shields · src/shield.nr196
calculate_remaining_shield_pctzk_shields · src/shield.nr222
By function — self cost, callees excluded.Call order
FrameACIR opcodes
mainzk_shields · src/main.nr1,315
iterate_asteroidszk_shields · src/shield.nr1,208
calculate_damagezk_shields · src/shield.nr63
calculate_remaining_shield_pctzk_shields · src/shield.nr11
status_reportzk_shields · src/shield.nr96
calculate_damagezk_shields · src/shield.nr63
calculate_remaining_shield_pctzk_shields · src/shield.nr11
By call order.Self cost
Values
initial_shield10000Field
remaining_shield9000Field
shield_regen_percentage10Field
masses[100, 2000, 200, 100, 100, 50, 50, 14][Field; 8]
masses[2]200Field
mass200Field
shield_pct90Field
damage2000Field
regeneration1000Field
i2u32
Transaction
Partial0xb636167a…66d46359

0xb636167a05b9de55bde67756bdaed6e766d46359

Status reason: private-part-succeeded-public-part-succeeded

Data
Synthetic demo data

Every block, transaction, address and hash on this chain is generated from a fixed seed. None of them exists on any network, and none of these values can be looked up anywhere else. The execution trace is real — it is a recorded Noir program — but it is not the execution of the transaction it is published under.

Block
Type
private + public
Age
No timestamp published
Canonical
Yes
Finality
Safe
Fee payer
0x01c8f081e2abedf0184953e2a272b5e430d5d932
Target
0x1b31c04d5920b0b5936f12e6fe8f17a59161624c
Cost · Mana
88000 / 200000 mana (FeeJuice)
Executions
privateNot observableAztec private functions execute client-side; only proofs, nullifiers and commitments are published, so there is no call structure to trace.
publicTrace ready
Decoded input
Selector
—
Raw
—

BlockTracer holds no call data for this transaction, so there is nothing here for an ABI to decode. Whether none was published or the body was pruned before it was captured is not something this section can tell; where that is known, it is stated above.

Raw (chain-native)
{
  "aztec": {
    "kind": "private+public",
    "contract": "0x1b31c04d5920b0b5936f12e6fe8f17a59161624c",
    "privateFunctions": [
      "transfer"
    ],
    "publicCall": "settle"
  }
}