Benchmarks

Performance characteristics of Keystone operations measured with Criterion.

Arithmetic Operations

Rounding Operations

Financial Calculations

Risk Metrics

precision-core vs rust_decimal

Measured with Criterion.rs on identical hardware. precision-core wraps rust_decimal with checked arithmetic, overflow detection, and formal verification boundaries.

The wrapper overhead ranges from 1-13% for individual operations and 6-21% for compound operations. This cost buys:

• Checked arithmetic that returns Option instead of panicking
• Formal verification via Kani proof harnesses
• Consistent error types (ArithmeticError)
• DeFi-specific operations (health factor, swap math)

Run the comparison benchmark:

cargo bench --package precision-core --bench comparison

Running Benchmarks

cd keystone
cargo bench

Specific Benchmark

cargo bench --bench arithmetic
cargo bench --bench financial
cargo bench --bench risk

With Baseline Comparison

# Save baseline
cargo bench -- --save-baseline main

# Compare to baseline
cargo bench -- --baseline main

Benchmark Code

Located in crates/precision-core/benches/:

#![allow(unused)]
fn main() {
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use precision_core::Decimal;

fn bench_addition(c: &mut Criterion) {
    let a = Decimal::from(12345i64);
    let b = Decimal::from(67890i64);

    c.bench_function("decimal_add", |bencher| {
        bencher.iter(|| black_box(a).checked_add(black_box(b)))
    });
}

criterion_group!(benches, bench_addition);
criterion_main!(benches);
}

Stylus Gas Benchmarks

Keystone Stylus contracts deployed on Arbitrum One.

Deployed Contracts

Measured Gas Usage (Arbitrum One)

Gas Comparison: Stylus vs Solidity (Measured)

Solidity benchmark contract: 0x41d4f095Da18Fd25c28CDbE0532a6fb730bbB9CF

Key Insight

Simple arithmetic: Solidity wins due to lower base overhead.

Loop-heavy computation: Stylus wins significantly. As iterations increase, Stylus becomes more efficient because WASM opcodes cost ~100x less than EVM opcodes.

When to Use Stylus

Use Keystone + Stylus when:

• Calculations involve many iterations (compound interest, Monte Carlo)
• 28-digit precision is required (vs Solidity’s 18-digit practical limit)
• Cross-platform determinism matters (same results everywhere)

Use Solidity when:

• Simple arithmetic only
• Gas optimization is critical for single operations
• Existing Solidity codebase

Break-Even Analysis

Based on measured data, Stylus becomes cheaper at approximately 100+ loop iterations per call.

Why Stylus is Cheaper

1. WASM Execution: WASM opcodes cost ~1/100th of EVM opcodes
2. No Storage Overhead: Pure computation functions avoid SLOAD/SSTORE
3. Efficient Loops: Iteration-heavy calculations (compound interest) benefit most
4. Native Integer Ops: 128-bit arithmetic is native in WASM

Running Gas Benchmarks

Install Foundry:

curl -L https://foundry.paradigm.xyz | bash
foundryup

Estimate gas for a call:

cast estimate 0x4dff9348275ac3c24e2d3abf54af61d3ebee1585 \
  "calculateHealthFactor(uint256,uint256)(uint256)" \
  10000000000000000000000 5000000000000000000000 \
  --rpc-url https://arb1.arbitrum.io/rpc

Activation Costs

One-time costs paid at deployment:

After activation, calls use standard Arbitrum gas pricing.

WASM Performance

WASM operations include JS-WASM boundary overhead:

WASM Binary Size

Optimization Settings

From Cargo.toml:

[profile.release]
opt-level = "z"      # Optimize for size
lto = "fat"          # Full link-time optimization
codegen-units = 1    # Better optimization
panic = "abort"      # Smaller binary
strip = true         # Remove symbols
overflow-checks = true  # Keep overflow checking

Memory Usage

Stack-only allocation for all operations.

Comparison with Alternatives

vs JavaScript Number

// JavaScript floating-point
0.1 + 0.2  // 0.30000000000000004

// Keystone
keystone.add("0.1", "0.2")  // "0.3"

Keystone is slower but guarantees correctness for financial calculations.

vs BigInt

JavaScript BigInt handles integers only. Keystone provides:

• Decimal precision up to 28 digits
• Native rounding modes
• Financial functions

vs decimal.js

Similar precision, but Keystone provides:

• Deterministic cross-platform results
• Smaller WASM bundle
• ZK-proof compatibility
• Rust native performance

Profiling

CPU Profiling

cargo bench --bench arithmetic -- --profile-time 10

Memory Profiling

cargo bench --bench arithmetic -- --plotting-backend disabled

CI Benchmarks

Benchmarks run on every PR to detect regressions:

- name: Run benchmarks
  run: cargo bench -- --noplot

- name: Compare with main
  run: |
    cargo bench -- --save-baseline pr
    git checkout main
    cargo bench -- --baseline pr