fix(ergo-sigma): BigInt 256-bit bound + modulus, byteArrayToBigInt bounds, Byte/Short wrap parity

[arkadianet]

Aligns arithmetic.rs evaluation with Scala ExactIntegral / CBigInt
semantics. All consensus-critical; independently verified against
sigmastate-interpreter (@ v6.0.4) source + LanguageSpecificationV5 vectors.

Changes

• BigInt +/-/* and unary negation: enforce the signed 256-bit bound, UNCONDITIONALLY. Scala dispatch is ArithOp.{Plus,Minus,Multiply}.eval -> impl.i.{plus,..} (BigIntIsExactIntegral) -> BigIntIsIntegral.{plus,..} = x.add(y), where x: sigma.BigInt, so x.add is a virtual call to CBigInt.add = wrappedValue.add(..).toSignedBigIntValueExact, throwing "BigInteger out of 256 bit range" when bitLength() > 255. toSignedBigIntValueExact is not version-gated (the v3-gated check is the separate CBigInt constructor guard). Valid signed range is exactly [-2^255, 2^255-1] — checked by value range, since num_bigint::BigInt::bits() would mis-handle -2^255.
• BigInt %: reject a non-positive modulus (b <= 0, incl. 0), matching java.math.BigInteger.mod ("modulus not positive"); for b > 0 keep the non-negative floored remainder in [0, b). / and % have no 256-bit check.
• byteArrayToBigInt (0x7B): reject empty input (java BigInteger ctor "Zero length BigInteger") and a value outside the signed 256-bit range (toSignedBigIntValueExact). Signed big-endian decode; boundary -2^255 / 2^255-1 accepted.
• Byte/Short /,% of MIN by -1, and unary negation of MIN, now WRAP instead of throwing — Scala's ExactIntegral does not override quot/divisionRemainder, and ExactNumeric.negate is not exact, so all route through plain Numeric (two's-complement wrap). Sibling of the Int/Long div/mod fix in fix(ergo-sigma): Int/Long arithmetic overflow + div/mod parity with Scala ExactIntegral #17. Corrects the now-false comment and the existing test that asserted the throw.

Conformance

• Corpus coal: 319 → 306 (-13), zero regressions (2195 nice = 2182 + 13).
• Closes: bigint-mod-negative-modulus-and-256bit (9), bytearraytobigint-no-empty-or-256bit-check (2), byte-short-negation-uses-checked-neg (2). The Byte/Short div/mod MIN/-1 wrap is harness-invisible (error-variant only) but a real consensus divergence.
• Note: this corrects an earlier triage guardrail that wrongly assumed the BigInt 256-bit arith bound was not enforced — it is (and unconditionally so).

Tests

New: bigint_arith_256bit_bound, bigint_negate_256bit_bound, bigint_modulo_nonpositive_modulus_rejects, bytearraytobigint_empty_and_oversize_reject, byte_short_div_mod_negation_wrap_parity. byte_short_overflow_rejects trimmed to the genuinely-throwing +/- cases. Full ergo-sigma suite green (316), cargo fmt/clippy clean.

codex review: clean (no correctness issues).

🤖 Generated with Claude Code

Summary by CodeRabbit

• Bug Fixes
  • Fixed arithmetic operation overflow handling to enforce consistent signed 256-bit range constraints
  • Improved divide-by-zero error handling for integer division and modulo operations
  • Corrected BigInt modulo behavior to validate modulus values and ensure non-negative results
  • Updated integer negation to use wrapping semantics for certain integer types

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 4e7b768b-cfa8-43da-adea-0238ace39dfc

📥 Commits

Reviewing files that changed from the base of the PR and between 1e40e0e and e06566a.

📒 Files selected for processing (2)

• ergo-sigma/src/evaluator/opcodes/arithmetic.rs
• ergo-sigma/src/evaluator/tests.rs

---

📝 Walkthrough

Walkthrough

This PR updates arithmetic opcode implementations to enforce consistent signed-256-bit BigInt range validation and align fixed-width integer overflow behavior with Java/Scala semantics. Key changes include a new fits_in_256_bits helper, explicit divide-by-zero runtime exceptions, wrapping division/modulo for fixed-width types, and reworked BigInt modulo with positive-modulus constraints. Tests narrow overflow assertions to plus/minus only and add dedicated wrap-parity verification.

Changes

Arithmetic Opcode Semantics: 256-bit Range and Wrapping Behavior

Layer / File(s)	Summary
Helper infrastructure and module documentation ergo-sigma/src/evaluator/opcodes/arithmetic.rs	Module-level documentation revised to reflect updated overflow/range behavior, and new fits_in_256_bits helper added to check signed 256-bit two's-complement bounds.
BigInt arithmetic operations with 256-bit range validation ergo-sigma/src/evaluator/opcodes/arithmetic.rs	Plus, Minus, and Multiply BigInt arms now compute results and validate against signed-256-bit bounds, returning runtime errors on out-of-range results.
Division with divide-by-zero handling and wrapping behavior ergo-sigma/src/evaluator/opcodes/arithmetic.rs	Byte/Short division now uses explicit divide-by-zero runtime exception branches and wrapping_div for non-zero divisors, removing prior checked overflow handling.
Modulo with wrapping and BigInt positive-modulus semantics ergo-sigma/src/evaluator/opcodes/arithmetic.rs	Byte/Short modulo implemented via explicit divide-by-zero errors and wrapping_rem; BigInt modulo enforces positive-modulus constraint and adjusts negative remainders to be non-negative.
Negation with wrapping and 256-bit range validation ergo-sigma/src/evaluator/opcodes/arithmetic.rs	Byte/Short negation changed to wrapping instead of checked negation; BigInt negation enforces signed-256-bit range validation with runtime error on out-of-range.
ByteArrayToBigInt validation and range enforcement ergo-sigma/src/evaluator/opcodes/arithmetic.rs	Byte-array-to-BigInt conversion now rejects empty arrays and validates decoded signed BigInt against 256-bit bounds, returning runtime errors on validation failure.
Test refinement and wrap-parity assertions ergo-sigma/src/evaluator/tests.rs	Byte/Short overflow test scope narrowed to plus/minus only; old division/modulo/negation overflow assertions removed; new byte_short_div_mod_negation_wrap_parity test pins wrapping results and divide-by-zero exceptions.

---

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

---

Possibly related PRs

• arkadianet/ergo#17: Both PRs modify ergo-sigma/src/evaluator/opcodes/arithmetic.rs to realign fixed-width arithmetic/division semantics with Scala/JVM behavior—main PR for Byte/Short (and related BigInt modulo/range), retrieved PR for Int/Long using the same eval_* overflow/div-mod opcode rewrites (divide-by-zero → RuntimeException, non-zero div/mod → wrapping_div/wrapping_rem).

---

Poem

🐰 Bounds we check with rabbit care,
256 bits, no overflow flare!
Division wraps with grace so true,
Modulo's positive, shiny new!
Java's math now runs right here.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately and specifically summarizes the three main changes: BigInt 256-bit bound enforcement, modulus constraints, byteArrayToBigInt bounds, and Byte/Short wrapping behavior.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
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.

_{✏️ 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/santa-bigint-arith-domain-guards

---

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.}