fix(consensus): faithful UnparsedErgoTree — preserve bytes + eval-error

[arkadianet]

What

Makes a soft-fork-wrapped ErgoTree — Scala's Left(UnparsedErgoTree(bytes, error)) —
behave faithfully on the two axes the node previously got wrong.

1. Eval must hard-ERROR, not reduce to true.
Scala's Interpreter.propositionFromErgoTree returns TrueSigmaProp only when
isSoftFork(error) holds, and isSoftFork defaults false (true only for a rule the
active block's validation settings have replaced/changed via voting). This node models no
such soft-fork activation, so an unparsed tree must error on evaluation. Reducing it to
true was a spend-path accept-invalid.

2. It must re-serialize BYTE-IDENTICALLY.
Scala preserves the wrapped tree's propositionBytes verbatim. The node was substituting a
synthetic Const(SBoolean, true) placeholder body, so re-emission diverged from the wire
bytes — the SANTA wire round-trip divergences.

How

• New Expr::Unparsed(Vec<u8>) whole-tree body holds the full original tree bytes
  (header + size + body). read_ergo_tree_tracking_wrap captures
  data_slice(tree_start, tree_end) at every wrap site; write_ergo_tree emits them
  verbatim; eval_expr returns the new EvalError::UnparsedErgoTree.
• Group elements collected before the wrap are still forwarded for the tx-chokepoint
  curve-check, matching Scala curve-checking GEs as it deserializes (before producing the
  UnparsedErgoTree).
• CheckDeserializedScriptIsSigmaProp parity widened: the non-SigmaProp-root wrap check now
  also resolves a ConstPlaceholder root against the segregated constants table (as Scala's
  ConstantPlaceholderSerializer.parse types it), so a placeholder root pointing at a
  non-SigmaProp constant wraps like an inline non-SigmaProp constant.
• Test fixtures that built a size-delimited tree from a non-SigmaProp root
  (Const(SBoolean, true) + has_size, or a ConstPlaceholder → non-SigmaProp constant) now
  correctly wrap to Expr::Unparsed on re-read — such a root is genuinely unspendable.
  Migrated to a SigmaProp root. The REST submit reject now keys on the Expr::Unparsed
  body directly instead of the obsolete placeholder heuristic.

Review

Reviewed source-level against the Scala oracle (reference/ergo-core) before opening. The core
was confirmed correct: isSoftFork default-false → eval-error is right; wrapped bytes match
Scala's UnparsedErgoTree(bytes) path; GE forwarding correct; every new Expr::Unparsed
match arm hard-errors/rejects. The ConstPlaceholder root completeness above was addressed
per that review.

A closely-related divergence in the same read_ergo_tree_tracking_wrap path — group-element
ordering past a v6 method (a size-delimited pre-v3 tree wrapping at the method, where group
elements after it must not be curve-checked) — is fixed in the follow-up #119.

Known pre-existing follow-ups (NOT introduced here; out of scope for this PR)

The wrap-trigger classification (which the byte/eval representation here does not change)
has two pre-existing gaps worth a focused follow-up:

• version > MAX_SUPPORTED_TREE_VERSION is activation-unaware. The node always wraps a
  future-version size-delimited tree opaquely; Scala only skip-accepts when
  activatedScriptVersion is beyond the supported max, else VersionContext.withVersions
  raises and deserializeErgoTree hard-rejects (not wraps).
• The has-size wrap catches more than Scala's ValidationException. Non-validation
  failures (e.g. a ConstantPlaceholder index overflow → ReadError::ValueTooLarge, a Scala
  SerializerException) are wrapped here but hard-rejected by Scala at tx parse.

Both are pre-existing on main and need a careful Scala exception-class / version-activation
audit; tracked separately.

Test plan

cargo fmt --all -- --check
cargo clippy --workspace --all-targets --all-features -- -D warnings
cargo test --workspace      # 4391 passed

New/updated tests: size_flagged_non_sigmaprop_root_wraps_as_unparsed (now asserts
Expr::Unparsed + byte-identity), size_flagged_const_placeholder_non_sigmaprop_root_wraps_as_unparsed,
unparsed_ergo_tree_body_eval_errors_not_true, plus the fixture migrations.

🤖 Generated with Claude Code

[coderabbitai]

📝 Walkthrough

Walkthrough

Introduces Expr::Unparsed(Vec<u8>) as a new ErgoTree AST variant that stores the full original bytes of an unparseable or soft-fork-wrapped tree body. The ErgoTree reader is updated to capture and preserve these bytes; the writer emits them verbatim. All evaluator walkers, the REST submit validator, and cross-crate test helpers are updated to handle this new variant.

Changes

Expr::Unparsed Byte-Preserving Soft-Fork Wrapping

Layer / File(s)	Summary
Expr::Unparsed variant, write guard, and register guard ergo-ser/src/opcode/types.rs, ergo-ser/src/opcode/write.rs, ergo-ser/src/register.rs	Adds Expr::Unparsed(Vec<u8>) to the expression AST; find_v3_only_method short-circuits for it; write_expr returns WriteError::InvalidData; expr_to_register_value returns ReadError::InvalidData.
ErgoTree read: byte capture, determinable_root_type, unparsed_soft_fork_tree redefinition ergo-ser/src/ergo_tree.rs	Records tree_start before parsing, slices full_tree_bytes, adds determinable_root_type to resolve ConstPlaceholder roots, and redefines unparsed_soft_fork_tree to store Expr::Unparsed(full_tree_bytes) instead of a synthetic boolean constant across all three wrapping paths.
write_ergo_tree: Expr::Unparsed fast-path ergo-ser/src/ergo_tree.rs	Detects Expr::Unparsed(raw) and writes the preserved bytes verbatim, enabling byte-identical round-trips.
Evaluator guards for Expr::Unparsed ergo-sigma/src/evaluator/types.rs, ergo-sigma/src/evaluator/dispatch.rs, ergo-sigma/src/evaluator/helpers.rs, ergo-sigma/src/evaluator/opcodes/binding.rs, ergo-sigma/src/evaluator/opcodes/method_call.rs, ergo-sigma/src/evaluator/tests.rs	Documents EvalError::UnparsedErgoTree; adds match arms that immediately error in eval_expr, eval_block_value, and expr_put_value_cost; short-circuits expr_has_deserialize, inline_placeholders, and infer_expr_type; adds a regression test asserting the error is not true.
REST submit validation and api_bridge test ergo-rest-json/src/decode.rs, ergo-node/src/api_bridge/tests.rs	Replaces the re-serialization roundtrip check in Submit mode with a direct body == Expr::Unparsed(_) test returning NON_CANONICAL; removes write_ergo_tree and sigma-type imports; updates the api_bridge test comment to reflect the new rejection path.
ergo_tree.rs fixture helpers and oracle-parity tests ergo-ser/src/ergo_tree.rs	Introduces sigma_prop_body(), updates existing size-delimited tests to use SSigmaProp roots, reworks oracle-parity tests to assert Expr::Unparsed byte-preservation, and adds unparsed_soft_fork_tree_roundtrips_byte_identical.
SSigmaProp root propagation in cross-crate test helpers ergo-ser/src/ergo_box.rs, ergo-ser/src/block_transactions.rs, ergo-ser/src/transaction.rs, ergo-indexer/src/ser/boxes.rs, ergo-mining/src/candidate_selection.rs, ergo-validation/tests/trace_emission_700000.rs	Updates size_delimited_tree / trivial_tree helpers to use SSigmaProp/TrivialProp(true) roots, removes Body/simple_body() dependencies; trace helpers gain Expr::Unparsed match arms.

Sequence Diagram(s)

sequenceDiagram
    participant Caller
    participant read_ergo_tree_tracking_wrap
    participant determinable_root_type
    participant unparsed_soft_fork_tree
    participant write_ergo_tree

    Caller->>read_ergo_tree_tracking_wrap: parse bytes
    read_ergo_tree_tracking_wrap->>read_ergo_tree_tracking_wrap: record tree_start, capture full_tree_bytes
    alt version > MAX or parse Err
        read_ergo_tree_tracking_wrap->>unparsed_soft_fork_tree: full_tree_bytes
        unparsed_soft_fork_tree-->>read_ergo_tree_tracking_wrap: ErgoTree { body: Expr::Unparsed(full_tree_bytes) }
    else parse Ok
        read_ergo_tree_tracking_wrap->>determinable_root_type: resolve root SigmaType
        alt non-SSigmaProp root
            read_ergo_tree_tracking_wrap->>unparsed_soft_fork_tree: full_tree_bytes
            unparsed_soft_fork_tree-->>read_ergo_tree_tracking_wrap: ErgoTree { body: Expr::Unparsed(full_tree_bytes) }
        else SSigmaProp or unresolvable
            read_ergo_tree_tracking_wrap-->>Caller: parsed ErgoTree
        end
    end
    read_ergo_tree_tracking_wrap-->>Caller: ErgoTree
    Caller->>write_ergo_tree: re-serialize
    alt body == Expr::Unparsed(raw)
        write_ergo_tree-->>Caller: write raw bytes verbatim
    else normal body
        write_ergo_tree-->>Caller: serialize AST
    end

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

• arkadianet/ergo#83: Modifies the same has_size parsing path in read_ergo_tree_tracking_wrap to handle parse failures, directly preceding the soft-fork wrapping logic changed here.
• arkadianet/ergo#116: Introduced find_v3_only_method in ergo-ser/src/opcode/types.rs; this PR adds the Expr::Unparsed(_) early-return to that same walker.
• arkadianet/ergo#117: Modifies the same size-delimited deserialization and soft-fork wrapping logic in ergo-ser/src/ergo_tree.rs at the identical code layer.

Poem

🐇 Soft-fork bytes once vanished, replaced with a lie,
A boolean true standing in for the sky.
Now Unparsed arrives with its raw bytes intact—
Re-serialized verbatim, no fiction, just fact!
The evaluator rejects it, the writer stands firm,
Round-trips byte-identical—that's a very good term! 🥕

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title accurately describes the main changeset: introducing a faithful UnparsedErgoTree implementation that preserves original bytes and returns an evaluation error instead of true.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/unparsed-ergotree-eval-and-bytes

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}