Synthetic demo datademo

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.

Home/demo/0x7786…f011/code

Verified source

0x7786…f011

0x7786e8534393d0edc5f7bbbefacc4c960b28f011

Verification

Code hash: 0x1b553b6102b2054e7efcea7e135b1161c2e10965
Status: full match
Provider: demo-vendored
Compiler: nargo 1.0.0-beta.26
Language: noir
Bundle: sha1:468159733e407c34a4628e8e56f0b1912d0f3e1d

Sources

Nargo.toml Prover.toml src/main.nr

Nargo.toml7 lines

[package]
name = "tour_events"
type = "bin"
authors = ["BlockTracer capability tour"]
[dependencies]

Prover.toml3 lines

threshold = "300"
orders = "4"

src/main.nr75 lines

// TOUR: program output and the event log
//
// The subject is the event log — the stream of things the execution SAID, as
// distinct from the values it held. In this language that stream is `print`,
// `println` and format strings, and it is the only pane whose content a
// program author writes directly.
//
// The entries are deliberately varied: bare text, a single interpolated value,
// several values in one line, output from inside a loop, and output from a
// nested frame — so the log is a sequence a reader can follow rather than the
// same sentence repeated.
struct Order {
    id: u32,
    qty: u32,
    unit_price: u32,
}
unconstrained fn line_total(o: Order) -> u32 {
    let total = o.qty * o.unit_price;
    // A format string interpolates BINDINGS, not expressions — `{o.qty}` is a
    // compile error in this language, so the fields are bound first. The
    // locals that exist only to be printed are worth seeing: they are what
    // the event log's text is built from.
    let id = o.id;
    let qty = o.qty;
    let price = o.unit_price;
    // Output from a nested frame: this entry is written while the call trace
    // is one frame deeper than the entries around it.
    println(f"  line {id}: {qty} x {price} = {total}");
    total
}
unconstrained fn apply_discount(total: u32, threshold: u32) -> u32 {
    if total >= threshold {
        let discounted = total - (total / 10);
        println(f"  discount applied at threshold {threshold}: {total} -> {discounted}");
        discounted
    } else {
        println(f"  no discount: {total} is below {threshold}");
        total
    }
}
unconstrained fn main(threshold: u32, orders: pub u32) -> pub u32 {
    // A bare string with no interpolation at all.
    println("=== invoice ===");
    let mut running: u32 = 0;
    // Output from inside a loop: one entry per iteration, each carrying the
    // iteration's own values, so the log and the loop rail line up rung for
    // rung.
    for i in 0..orders {
        let line_no = i + 1;
        let o = Order { id: line_no, qty: i + 2, unit_price: 10 + i };
        let t = line_total(o);
        running = running + t;
        println(f"  running total after line {line_no}: {running}");
    }
    // `print` without a newline, then `println` completing the same line —
    // two events that a reader sees as one sentence.
    print("subtotal: ");
    println(running);
    let final_total = apply_discount(running, threshold);
    // Several values interpolated into one entry.
    println(f"orders={orders} threshold={threshold} subtotal={running} total={final_total}");
    println("=== end ===");
    final_total
}

This is a circuit, not a contract. It declares no ABI and no storage layout, so there is no interface list and no slot mapping to show. The source above is the whole of what it publishes.

Deployments

This code is deployed at one address. Any other address running the same bytecode would appear here too, already verified.