---
# System prepended metadata

title: 'Cairo felt252 Scalar Handling in Garaga MSM Integration: Technical Deep Dive'

---

# Cairo felt252 Scalar Handling in Garaga MSM Integration: Technical Deep Dive

## Executive Summary

This document provides production-ready debugging insights for Cairo developers integrating elliptic curve Multi-Scalar Multiplication (MSM) operations, specifically addressing felt252 scalar handling with Garaga's MSM implementation. The core issue: Cairo's felt252 represents field elements modulo the Stark field prime (p ≈ 2^251), while cryptographic curve scalars must operate modulo the curve order (n ≈ 2^252 for BN254).

## Problem Statement

When building the Monero-Starknet atomic swap protocol, scalars derived from Monero's Ed25519 operations must be used in BN254 MSM computations. Direct felt252 usage creates mathematical inconsistencies:

- **Stark field**: p = 0x800000000000011000000000000000000000000000000000000000000000001
- **BN254 curve order**: n = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001

Using felt252 values directly as scalars causes silent modular reduction errors, producing incorrect MSM results.

## Root Cause Analysis

### The felt252 Type Constraint

Cairo's felt252 is fundamentally a Stark field element. When you write:

```cairo
let scalar: felt252 = 0x1234...;
```

Cairo automatically reduces this modulo p (Stark prime), not n (BN254 curve order). This creates a mismatch.

### Garaga MSM Requirements

Garaga's `msm_g1` expects scalars as byte arrays representing integers modulo the curve order:

```cairo
fn msm_g1(
    scalars_digits_decompositions: Span<(Span<felt252>, Span<felt252>)>,
    hint: MSMHint,
    derive_point_from_x_hint: Span<DerivePointFromXHint>,
    points: Span<G1Point>,
    curve_index: usize
) -> G1Point
```

The function signature accepts felt252 spans, but internally requires proper curve scalar representation.

## Solution Architecture

### 1. Scalar Representation Strategy

Instead of using felt252 directly, represent scalars as u256:

```cairo
use core::integer::u256;

// Correct approach
let scalar_u256: u256 = u256 {
    low: 0x1234567890abcdef1234567890abcdef_u128,
    high: 0xfedcba0987654321fedcba0987654321_u128
};
```

This ensures no automatic modular reduction.

### 2. Conversion Pipeline

Implement explicit conversion from u256 to Garaga-compatible format:

```cairo
use garaga::definitions::{G1Point, get_BN254_modulus};
use garaga::utils::u256_ops::u256_mod;

fn prepare_scalar_for_msm(scalar: u256) -> Span<felt252> {
    // Get BN254 curve order
    let curve_order = get_BN254_modulus();
    
    // Reduce modulo curve order
    let reduced_scalar = u256_mod(scalar, curve_order);
    
    // Convert to felt252 array (Garaga expects low/high limbs)
    let mut result = ArrayTrait::new();
    result.append(reduced_scalar.low.into());
    result.append(reduced_scalar.high.into());
    
    result.span()
}
```

### 3. Digit Decomposition

Garaga requires scalars in digit-decomposed form for efficient MSM computation:

```cairo
use garaga::pairing_check::{get_field_nz};
use garaga::basic_field_ops::fr_from_u256;

fn decompose_scalar(scalar: u256) -> (Span<felt252>, Span<felt252>) {
    let field = get_field_nz();
    let fr = fr_from_u256(scalar, field);
    
    // Decompose into base digits for GLV optimization
    // Returns (positive_digits, negative_digits)
    fr.decompose_glv()
}
```

## Implementation Example

### Complete MSM Integration

```cairo
use garaga::definitions::{G1Point, MSMHint, DerivePointFromXHint};
use garaga::ec_ops::msm_g1;

fn perform_msm_with_monero_scalars(
    monero_scalars: Span<u256>,  // Scalars from Monero operations
    points: Span<G1Point>,
    msm_hint: MSMHint,
    derive_hints: Span<DerivePointFromXHint>
) -> G1Point {
    // Step 1: Decompose all scalars
    let mut scalar_decompositions = ArrayTrait::new();
    let mut i = 0;
    loop {
        if i >= monero_scalars.len() {
            break;
        }
        let scalar = *monero_scalars.at(i);
        let (pos_digits, neg_digits) = decompose_scalar(scalar);
        scalar_decompositions.append((pos_digits, neg_digits));
        i += 1;
    };
    
    // Step 2: Execute MSM
    msm_g1(
        scalar_decompositions.span(),
        msm_hint,
        derive_hints,
        points,
        0  // BN254 curve index
    )
}
```

## Testing and Validation

### Unit Test Pattern

```cairo
#[test]
fn test_scalar_conversion() {
    // Known test vector
    let test_scalar = u256 {
        low: 0x0000000000000001_u128,
        high: 0x0000000000000000_u128
    };
    
    let (pos, neg) = decompose_scalar(test_scalar);
    
    // Verify decomposition maintains scalar value
    assert(pos.len() > 0, 'Invalid decomposition');
}
```

### Integration Test with Known Values

```cairo
#[test]
fn test_msm_scalar_consistency() {
    // Use generator point
    let generator = get_bn254_g1_generator();
    let points = array![generator].span();
    
    // Scalar = 2
    let scalar = u256 { low: 2_u128, high: 0_u128 };
    let scalars = array![scalar].span();
    
    // Expected result: 2 * G
    let expected = g1_double(generator);
    
    // Compute via MSM
    let result = perform_msm_with_monero_scalars(
        scalars,
        points,
        get_test_msm_hint(),
        get_test_derive_hints()
    );
    
    assert(result.x == expected.x, 'X coordinate mismatch');
    assert(result.y == expected.y, 'Y coordinate mismatch');
}
```

## Common Pitfalls

### Pitfall 1: Direct felt252 Usage

❌ **Incorrect**:
```cairo
let scalar: felt252 = 0x123456789abcdef;
let points = array![point].span();
let result = msm_g1(scalar, ...);  // Wrong!
```

✅ **Correct**:
```cairo
let scalar: u256 = u256 { low: 0x123456789abcdef_u128, high: 0_u128 };
let decomposed = decompose_scalar(scalar);
let result = msm_g1(array![decomposed].span(), ...);
```

### Pitfall 2: Ignoring Curve Order

❌ **Incorrect**:
```cairo
// Assuming felt252 arithmetic matches curve scalar arithmetic
let combined_scalar: felt252 = scalar1 + scalar2;
```

✅ **Correct**:
```cairo
use garaga::utils::u256_ops::u256_add_mod;
let curve_order = get_BN254_modulus();
let combined_scalar = u256_add_mod(scalar1, scalar2, curve_order);
```

### Pitfall 3: Hint Generation

MSM hints must be pre-computed off-chain and provided as witness data:

```cairo
// Generate hints using Garaga's Python tools
// from garaga.hints import msm_hint_generator
// hint = msm_hint_generator.generate_msm_hint(scalars, points)
```

Don't attempt to compute hints in Cairo - they require expensive operations unsuitable for on-chain execution.

## Performance Considerations

### Gas Optimization

1. **Batch MSM Operations**: Combine multiple scalar multiplications into single MSM call
2. **Precompute Decompositions**: If scalars are known in advance, provide pre-decomposed values
3. **Minimize Conversions**: Structure code to avoid repeated u256 ↔ felt252 conversions

### Computational Complexity

- Single scalar multiplication: ~30,000 Cairo steps
- MSM with n scalars: ~10,000 + n * 5,000 steps (amortized)
- Scalar decomposition: ~2,000 steps per scalar

## Cross-Chain Integration Patterns

### Monero → Starknet Data Flow

```
Monero DLSAG Signature
    ↓
Extract scalar (Ed25519 curve order)
    ↓
Convert to u256 representation
    ↓
Map to BN254 scalar space
    ↓
Decompose for Garaga MSM
    ↓
Verify via MSM computation
```

### Ethereum ↔ Starknet Verification

For cross-L1/L2 verification:

```cairo
// Verify Ethereum signature on Starknet
fn verify_ethereum_ecdsa(
    message_hash: u256,
    r: u256,
    s: u256,
    public_key: G1Point
) -> bool {
    // Compute u1 = hash / s, u2 = r / s
    let (u1, u2) = compute_ecdsa_scalars(message_hash, r, s);
    
    // MSM: u1 * G + u2 * PubKey
    let scalars = array![u1, u2].span();
    let points = array![get_bn254_g1_generator(), public_key].span();
    
    let result = perform_msm_with_monero_scalars(
        scalars,
        points,
        get_ecdsa_msm_hint(),
        get_ecdsa_derive_hints()
    );
    
    // Check if x-coordinate matches r
    result.x.low == r.low && result.x.high == r.high
}
```

## Production Checklist

- [ ] All scalars represented as u256, never bare felt252
- [ ] Explicit modular reduction using curve order (n), not Stark prime (p)
- [ ] Scalar decomposition properly implemented with GLV optimization
- [ ] MSM hints generated off-chain and provided as witness data
- [ ] Unit tests cover known test vectors
- [ ] Integration tests verify cross-chain scalar compatibility
- [ ] Gas benchmarks measured for target transaction volume
- [ ] Error handling for invalid scalar values (>= curve order)

## References

- [Garaga Documentation](https://github.com/keep-starknet-strange/garaga)
- [BN254 Curve Specification](https://hackmd.io/@zkteam/bn254)
- [Cairo Book: Felt Type](https://book.cairo-lang.org/ch02-02-data-types.html#felt-type)
- [MSM Algorithms and Optimizations](https://eprint.iacr.org/2022/1400)

## Conclusion

Proper scalar handling is critical for cryptographic correctness in Cairo. The felt252 type's automatic modular reduction relative to the Stark prime creates subtle bugs when working with elliptic curve scalars. By using u256 representation, explicit curve order reduction, and proper Garaga integration patterns, developers can build robust cross-chain cryptographic protocols.

For the Monero-Starknet atomic swap specifically, this approach enables trustless DLSAG signature verification on Starknet, unlocking true privacy-preserving cross-chain swaps.

---

**Author**: Omar Espejel (@espejelomar)  
**GitHub**: https://github.com/omarespejel/monero-starknet-atomic-swap  
**Date**: January 2025  
**License**: MIT