//! Main entrypoint for the Cairo core library.

pub mod traits;

use serde::Serde;

#[feature("deprecated-index-traits")]

#[feature("deprecated-op-assign-traits")]

#[allow(unused_imports)]

use traits::{

Add, AddEq, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivEq, DivRem, Drop,

Felt252DictValue, Index, IndexView, Into, Mul, MulEq, Neg, Not, PanicDestruct, PartialEq,

PartialOrd, Rem, RemEq, Sub, SubEq, TryInto,

};

/// `usize` is an alias for `u32` type.

pub type usize = u32;

/// `bool` enum representing either `false` or `true`.

#[derive(Copy, Drop, Default)]

pub enum bool {

#[default]

False,

True,

}

impl BoolSerde of Serde<bool> {

fn serialize(self: @bool, ref output: Array<felt252>) {

if *self {

1_felt252

} else {

0_felt252

}.serialize(ref output);

}

fn deserialize(ref serialized: Span<felt252>) -> Option<bool> {

Some(*serialized.pop_front()? != 0)

}

}

extern fn bool_and_impl(lhs: bool, rhs: bool) -> (bool,) implicits() nopanic;

impl BoolBitAnd of BitAnd<bool> {

#[inline]

fn bitand(lhs: bool, rhs: bool) -> bool {

let (r,) = bool_and_impl(lhs, rhs);

r

}

}

extern fn bool_or_impl(lhs: bool, rhs: bool) -> (bool,) implicits() nopanic;

impl BoolBitOr of BitOr<bool> {

#[inline]

fn bitor(lhs: bool, rhs: bool) -> bool {

let (r,) = bool_or_impl(lhs, rhs);

r

}

}

extern fn bool_not_impl(a: bool) -> (bool,) implicits() nopanic;

#[inline]

impl BoolNot of Not<bool> {

#[inline]

fn not(a: bool) -> bool implicits() nopanic {

let (r,) = bool_not_impl(a);

r

}

}

extern fn bool_xor_impl(lhs: bool, rhs: bool) -> (bool,) implicits() nopanic;

impl BoolBitXor of BitXor<bool> {

#[inline]

fn bitxor(lhs: bool, rhs: bool) -> bool {

let (r,) = bool_xor_impl(lhs, rhs);

r

}

}

impl BoolPartialEq of PartialEq<bool> {

#[inline]

fn eq(lhs: @bool, rhs: @bool) -> bool {

match lhs {

false => !*rhs,

true => *rhs,

}

}

#[inline]

fn ne(lhs: @bool, rhs: @bool) -> bool {

match lhs {

false => *rhs,

true => !*rhs,

}

}

}

impl BoolFelt252DictValue of Felt252DictValue<bool> {

#[inline]

fn zero_default() -> bool nopanic {

false

}

}

extern fn bool_to_felt252(a: bool) -> felt252 implicits() nopanic;

impl BoolIntoFelt252 of Into<bool, felt252> {

#[inline]

fn into(self: bool) -> felt252 implicits() nopanic {

bool_to_felt252(self)

}

}

pub mod boolean;

pub mod circuit;

/// General purpose implicits.

pub extern type RangeCheck;

pub extern type SegmentArena;

mod felt_252;

#[allow(unused_imports)]

use felt_252::{Felt252One, Felt252Zero};

/// `felt252` is the basic field element used in Cairo.

///

/// It corresponds to an integer in the range 0 ≤ x < P where P is

/// a very large prime number currently equal to 2^251 + 17⋅2^192 + 1.

///

/// Any operation that uses `felt252` will be computed modulo P.

pub extern type felt252;

impl felt252Copy of Copy<felt252>;

impl felt252Drop of Drop<felt252>;

extern fn felt252_const<const value: felt252>() -> felt252 nopanic;

impl Felt252Serde of Serde<felt252> {

fn serialize(self: @felt252, ref output: Array<felt252>) {

output.append(*self);

}

fn deserialize(ref serialized: Span<felt252>) -> Option<felt252> {

let mut snapshot = serialized.snapshot;

match crate::array::array_snapshot_pop_front(ref snapshot) {

Some(x) => {

serialized = Span { snapshot };

Some(*x.unbox())

},

None => {

serialized = Span { snapshot };

None

},

}

}

}

extern fn felt252_add(lhs: felt252, rhs: felt252) -> felt252 nopanic;

impl Felt252Add of Add<felt252> {

#[inline]

fn add(lhs: felt252, rhs: felt252) -> felt252 {

felt252_add(lhs, rhs)

}

}

impl Felt252AddEq of AddEq<felt252> {

#[inline]

fn add_eq(ref self: felt252, other: felt252) {

self = Add::add(self, other);

}

}

extern fn felt252_sub(lhs: felt252, rhs: felt252) -> felt252 nopanic;

impl Felt252Sub of Sub<felt252> {

#[inline]

fn sub(lhs: felt252, rhs: felt252) -> felt252 {

felt252_sub(lhs, rhs)

}

}

impl Felt252SubEq of SubEq<felt252> {

#[inline]

fn sub_eq(ref self: felt252, other: felt252) {

self = Sub::sub(self, other);

}

}

extern fn felt252_mul(lhs: felt252, rhs: felt252) -> felt252 nopanic;

impl Felt252Mul of Mul<felt252> {

#[inline]

fn mul(lhs: felt252, rhs: felt252) -> felt252 {

felt252_mul(lhs, rhs)

}

}

impl Felt252MulEq of MulEq<felt252> {

#[inline]

fn mul_eq(ref self: felt252, other: felt252) {

self = Mul::mul(self, other);

}

}

impl Felt252Neg of Neg<felt252> {

#[inline]

fn neg(a: felt252) -> felt252 {

a * -1

}

}

/// Performs division on `felt252` values in Cairo's finite field.

/// Unlike regular integer division, `felt252` division returns a field element n that satisfies

/// the equation: n * rhs ≡ lhs (mod P), where P is the `felt252` prime.

///

/// # Examples

///

/// ```

/// use core::felt252_div;

///

/// // Division with 0 remainder works the same way as integer division.

/// assert!(felt252_div(4, 2) == 2);

///

/// // Division with non 0 remainder returns a field element n where n * 3 ≡ 4 (mod P)

/// assert!(felt252_div(4, 3) ==

/// 1206167596222043737899107594365023368541035738443865566657697352045290673495);

///

/// ```

pub extern fn felt252_div(lhs: felt252, rhs: NonZero<felt252>) -> felt252 nopanic;

impl Felt252PartialEq of PartialEq<felt252> {

#[inline]

fn eq(lhs: @felt252, rhs: @felt252) -> bool {

match *lhs - *rhs {

0 => true,

_ => false,

}

}

}

extern const fn felt252_is_zero(lhs: felt252) -> zeroable::IsZeroResult<felt252> nopanic;

impl Felt252TryIntoNonZero of TryInto<felt252, NonZero<felt252>> {

const fn try_into(self: felt252) -> Option<NonZero<felt252>> {

match felt252_is_zero(self) {

zeroable::IsZeroResult::Zero => None,

zeroable::IsZeroResult::NonZero(x) => Some(x),

}

}

}

impl Felt252Default of Default<felt252> {

#[inline]

fn default() -> felt252 nopanic {

0

}

}

impl Felt252Felt252DictValue of Felt252DictValue<felt252> {

#[inline]

fn zero_default() -> felt252 nopanic {

0

}

}

pub mod blake;

pub mod box;

#[allow(unused_imports)]

use box::{Box, BoxTrait};

pub mod nullable;

#[allow(unused_imports)]

use nullable::{Nullable, NullableTrait, match_nullable, null, nullable_from_box};

pub mod array;

#[allow(unused_imports)]

use array::{Array, ArrayTrait, Span, SpanTrait};

pub mod dict;

#[allow(unused_imports)]

use dict::{

Felt252Dict, Felt252DictTrait, SquashedFelt252Dict, felt252_dict_new, felt252_dict_squash,

};

pub mod result;

#[allow(unused_imports)]

use result::{Result, ResultTrait};

pub mod option;

#[allow(unused_imports)]

use option::{Option, OptionTrait};

pub mod clone;

#[allow(unused_imports)]

use clone::Clone;

pub mod ec;

#[allow(unused_imports)]

use ec::{EcOp, EcPoint, EcState};

pub mod ecdsa;

#[feature("corelib-internal-use")]

pub mod integer;

#[allow(unused_imports)]

use integer::{

Bitwise, Felt252IntoU256, Felt252TryIntoU128, Felt252TryIntoU16, Felt252TryIntoU32,

Felt252TryIntoU64, Felt252TryIntoU8, I128IntoFelt252, I16IntoFelt252, I32IntoFelt252,

I64IntoFelt252, I8IntoFelt252, NumericLiteral, U128IntoFelt252, U16IntoFelt252, U32IntoFelt252,

U64IntoFelt252, U8IntoFelt252, i128, i16, i32, i64, i8, u128, u128_is_zero, u16, u256, u32, u64,

u8,

};

#[feature("corelib-internal-use")]

#[deprecated(feature: "corelib-internal-use", note: "Use `core::num::traits::Sqrt` instead")]

#[allow(unused_imports)]

use integer::{u128_sqrt, u256_sqrt};

pub mod cmp;

pub mod gas;

#[feature("corelib-internal-use")]

pub mod math;

pub mod num;

pub mod ops;

#[allow(unused_imports)]

use gas::{BuiltinCosts, GasBuiltin, get_builtin_costs};

pub mod panics;

#[allow(unused_imports)]

use panics::{Panic, PanicResult, panic};

pub enum never {}

/// Panics with the given `felt252` as error message.

///

/// # Examples

///

/// ```

/// use core::panic_with_felt252;

///

/// panic_with_felt252('error message');

/// ```

#[inline(never)]

pub fn panic_with_felt252(err_code: felt252) -> never {

panic(array![err_code])

}

/// Panics with the given const argument `felt252` as error message.

///

/// # Examples

///

/// ```

/// use core::panic_with_const_felt252;

///

/// panic_with_const_felt252::<'error message'>();

/// ```

#[inline(never)]

pub fn panic_with_const_felt252<const ERR_CODE: felt252>() -> never {

panic_with_felt252(ERR_CODE)

}

/// Panics if `cond` is false with the given `felt252` as error message.

///

/// # Examples

///

/// ```

/// assert(false, 'error message');

/// ```

#[inline]

pub const fn assert(cond: bool, err_code: felt252) {

if !cond {

panic_with_felt252(err_code)

}

}

pub mod hash;

pub mod keccak;

pub mod pedersen;

pub mod qm31;

pub mod serde;

pub mod sha256;

#[allow(unused_imports)]

use pedersen::Pedersen;

pub mod poseidon;

#[allow(unused_imports)]

use poseidon::Poseidon;

pub mod debug;

pub mod fmt;

#[feature("corelib-internal-use")]

#[deprecated(feature: "corelib-internal-use", note: "Use `starknet` directly")]

pub mod starknet;

#[allow(unused_imports)]

#[feature("corelib-internal-use")]

use starknet::System;

pub mod internal;

pub mod zeroable;

#[allow(unused_imports)]

use zeroable::{NonZero, Zeroable};

pub mod bytes_31;

#[allow(unused_imports)]

use bytes_31::{

Bytes31IndexView, Bytes31IntoFelt252, Bytes31Trait, Felt252TryIntoBytes31, bytes31,

bytes31_const,

};

pub mod byte_array;

#[allow(unused_imports)]

use byte_array::{ByteArray, ByteArrayIndexView, ByteArrayStringLiteral, ByteArrayTrait};

pub mod string;

#[allow(unused_imports)]

use string::StringLiteral;

mod fixed_size_array;

pub mod iter;

mod keyword_docs;

pub mod metaprogramming;

#[allow(unused_imports)]

mod prelude;

#[cfg(test)]

mod test;

pub mod testing;

pub mod to_byte_array;

mod tuple;