repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/bls12_381/benches/groups.rs | zkcrypto/bls12_381/benches/groups.rs | #[macro_use]
extern crate criterion;
extern crate bls12_381;
use bls12_381::*;
use criterion::{black_box, Criterion};
fn criterion_benchmark(c: &mut Criterion) {
// Pairings
{
let g = G1Affine::generator();
let h = G2Affine::generator();
c.bench_function("full pairing", move |b| {
b.iter(|| pairing(black_box(&g), black_box(&h)))
});
c.bench_function("G2 preparation for pairing", move |b| {
b.iter(|| G2Prepared::from(h))
});
let prep = G2Prepared::from(h);
c.bench_function("miller loop for pairing", move |b| {
b.iter(|| multi_miller_loop(&[(&g, &prep)]))
});
let prep = G2Prepared::from(h);
let r = multi_miller_loop(&[(&g, &prep)]);
c.bench_function("final exponentiation for pairing", move |b| {
b.iter(|| r.final_exponentiation())
});
}
// G1Affine
{
let name = "G1Affine";
let a = G1Affine::generator();
let s = Scalar::from_raw([1, 2, 3, 4]);
let compressed = [0u8; 48];
let uncompressed = [0u8; 96];
c.bench_function(&format!("{} check on curve", name), move |b| {
b.iter(|| black_box(a).is_on_curve())
});
c.bench_function(&format!("{} check equality", name), move |b| {
b.iter(|| black_box(a) == black_box(a))
});
c.bench_function(&format!("{} scalar multiplication", name), move |b| {
b.iter(|| black_box(a) * black_box(s))
});
c.bench_function(&format!("{} subgroup check", name), move |b| {
b.iter(|| black_box(a).is_torsion_free())
});
c.bench_function(
&format!("{} deserialize compressed point", name),
move |b| b.iter(|| G1Affine::from_compressed(black_box(&compressed))),
);
c.bench_function(
&format!("{} deserialize uncompressed point", name),
move |b| b.iter(|| G1Affine::from_uncompressed(black_box(&uncompressed))),
);
}
// G1Projective
{
let name = "G1Projective";
let a = G1Projective::generator();
let a_affine = G1Affine::generator();
let s = Scalar::from_raw([1, 2, 3, 4]);
const N: usize = 10000;
let v = vec![G1Projective::generator(); N];
let mut q = vec![G1Affine::identity(); N];
c.bench_function(&format!("{} check on curve", name), move |b| {
b.iter(|| black_box(a).is_on_curve())
});
c.bench_function(&format!("{} check equality", name), move |b| {
b.iter(|| black_box(a) == black_box(a))
});
c.bench_function(&format!("{} to affine", name), move |b| {
b.iter(|| G1Affine::from(black_box(a)))
});
c.bench_function(&format!("{} doubling", name), move |b| {
b.iter(|| black_box(a).double())
});
c.bench_function(&format!("{} addition", name), move |b| {
b.iter(|| black_box(a).add(&a))
});
c.bench_function(&format!("{} mixed addition", name), move |b| {
b.iter(|| black_box(a).add_mixed(&a_affine))
});
c.bench_function(&format!("{} scalar multiplication", name), move |b| {
b.iter(|| black_box(a) * black_box(s))
});
c.bench_function(&format!("{} batch to affine n={}", name, N), move |b| {
b.iter(|| {
G1Projective::batch_normalize(black_box(&v), black_box(&mut q));
black_box(&q)[0]
})
});
}
// G2Affine
{
let name = "G2Affine";
let a = G2Affine::generator();
let s = Scalar::from_raw([1, 2, 3, 4]);
let compressed = [0u8; 96];
let uncompressed = [0u8; 192];
c.bench_function(&format!("{} check on curve", name), move |b| {
b.iter(|| black_box(a).is_on_curve())
});
c.bench_function(&format!("{} check equality", name), move |b| {
b.iter(|| black_box(a) == black_box(a))
});
c.bench_function(&format!("{} scalar multiplication", name), move |b| {
b.iter(|| black_box(a) * black_box(s))
});
c.bench_function(&format!("{} subgroup check", name), move |b| {
b.iter(|| black_box(a).is_torsion_free())
});
c.bench_function(
&format!("{} deserialize compressed point", name),
move |b| b.iter(|| G2Affine::from_compressed(black_box(&compressed))),
);
c.bench_function(
&format!("{} deserialize uncompressed point", name),
move |b| b.iter(|| G2Affine::from_uncompressed(black_box(&uncompressed))),
);
}
// G2Projective
{
let name = "G2Projective";
let a = G2Projective::generator();
let a_affine = G2Affine::generator();
let s = Scalar::from_raw([1, 2, 3, 4]);
const N: usize = 10000;
let v = vec![G2Projective::generator(); N];
let mut q = vec![G2Affine::identity(); N];
c.bench_function(&format!("{} check on curve", name), move |b| {
b.iter(|| black_box(a).is_on_curve())
});
c.bench_function(&format!("{} check equality", name), move |b| {
b.iter(|| black_box(a) == black_box(a))
});
c.bench_function(&format!("{} to affine", name), move |b| {
b.iter(|| G2Affine::from(black_box(a)))
});
c.bench_function(&format!("{} doubling", name), move |b| {
b.iter(|| black_box(a).double())
});
c.bench_function(&format!("{} addition", name), move |b| {
b.iter(|| black_box(a).add(&a))
});
c.bench_function(&format!("{} mixed addition", name), move |b| {
b.iter(|| black_box(a).add_mixed(&a_affine))
});
c.bench_function(&format!("{} scalar multiplication", name), move |b| {
b.iter(|| black_box(a) * black_box(s))
});
c.bench_function(&format!("{} batch to affine n={}", name, N), move |b| {
b.iter(|| {
G2Projective::batch_normalize(black_box(&v), black_box(&mut q));
black_box(&q)[0]
})
});
}
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/consts.rs | zkcrypto/src/consts.rs | use crate::kzg_types::{ZG1, ZG2};
use bls12_381::{Fp as ZFp, Fp2 as ZFp2, G1Projective, G2Projective};
pub const SCALE_FACTOR: u64 = 5;
pub const NUM_ROOTS: usize = 32;
#[rustfmt::skip]
pub const SCALE2_ROOT_OF_UNITY: [[u64; 4]; 32] = [
[0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000],
[0xffffffff00000000, 0x53bda402fffe5bfe, 0x3339d80809a1d805, 0x73eda753299d7d48],
[0x0001000000000000, 0xec03000276030000, 0x8d51ccce760304d0, 0x0000000000000000],
[0x7228fd3397743f7a, 0xb38b21c28713b700, 0x8c0625cd70d77ce2, 0x345766f603fa66e7],
[0x53ea61d87742bcce, 0x17beb312f20b6f76, 0xdd1c0af834cec32c, 0x20b1ce9140267af9],
[0x360c60997369df4e, 0xbf6e88fb4c38fb8a, 0xb4bcd40e22f55448, 0x50e0903a157988ba],
[0x8140d032f0a9ee53, 0x2d967f4be2f95155, 0x14a1e27164d8fdbd, 0x45af6345ec055e4d],
[0x5130c2c1660125be, 0x98d0caac87f5713c, 0xb7c68b4d7fdd60d0, 0x6898111413588742],
[0x4935bd2f817f694b, 0x0a0865a899e8deff, 0x6b368121ac0cf4ad, 0x4f9b4098e2e9f12e],
[0x4541b8ff2ee0434e, 0xd697168a3a6000fe, 0x39feec240d80689f, 0x095166525526a654],
[0x3c28d666a5c2d854, 0xea437f9626fc085e, 0x8f4de02c0f776af3, 0x325db5c3debf77a1],
[0x4a838b5d59cd79e5, 0x55ea6811be9c622d, 0x09f1ca610a08f166, 0x6d031f1b5c49c834],
[0xe206da11a5d36306, 0x0ad1347b378fbf96, 0xfc3e8acfe0f8245f, 0x564c0a11a0f704f4],
[0x6fdd00bfc78c8967, 0x146b58bc434906ac, 0x2ccddea2972e89ed, 0x485d512737b1da3d],
[0x034d2ff22a5ad9e1, 0xae4622f6a9152435, 0xdc86b01c0d477fa6, 0x56624634b500a166],
[0xfbd047e11279bb6e, 0xc8d5f51db3f32699, 0x483405417a0cbe39, 0x3291357ee558b50d],
[0xd7118f85cd96b8ad, 0x67a665ae1fcadc91, 0x88f39a78f1aeb578, 0x2155379d12180caa],
[0x08692405f3b70f10, 0xcd7f2bd6d0711b7d, 0x473a2eef772c33d6, 0x224262332d8acbf4],
[0x6f421a7d8ef674fb, 0xbb97a3bf30ce40fd, 0x652f717ae1c34bb0, 0x2d3056a530794f01],
[0x194e8c62ecb38d9d, 0xad8e16e84419c750, 0xdf625e80d0adef90, 0x520e587a724a6955],
[0xfece7e0e39898d4b, 0x2f69e02d265e09d9, 0xa57a6e07cb98de4a, 0x03e1c54bcb947035],
[0xcd3979122d3ea03a, 0x46b3105f04db5844, 0xc70d0874b0691d4e, 0x47c8b5817018af4f],
[0xc6e7a6ffb08e3363, 0xe08fec7c86389bee, 0xf2d38f10fbb8d1bb, 0x0abe6a5e5abcaa32],
[0x5616c57de0ec9eae, 0xc631ffb2585a72db, 0x5121af06a3b51e3c, 0x73560252aa0655b2],
[0x92cf4deb77bd779c, 0x72cf6a8029b7d7bc, 0x6e0bcd91ee762730, 0x291cf6d68823e687],
[0xce32ef844e11a51e, 0xc0ba12bb3da64ca5, 0x0454dc1edc61a1a3, 0x019fe632fd328739],
[0x531a11a0d2d75182, 0x02c8118402867ddc, 0x116168bffbedc11d, 0x0a0a77a3b1980c0d],
[0xe2d0a7869f0319ed, 0xb94f1101b1d7a628, 0xece8ea224f31d25d, 0x23397a9300f8f98b],
[0xd7b688830a4f2089, 0x6558e9e3f6ac7b41, 0x99e276b571905a7d, 0x52dd465e2f094256],
[0x474650359d8e211b, 0x84d37b826214abc6, 0x8da40c1ef2bb4598, 0x0c83ea7744bf1bee],
[0x694341f608c9dd56, 0xed3a181fabb30adc, 0x1339a815da8b398f, 0x2c6d4e4511657e1e],
[0x63e7cb4906ffc93f, 0xf070bb00e28a193d, 0xad1715b02e5713b5, 0x4b5371495990693f],
];
/** The G1 generator */
pub const G1_GENERATOR: ZG1 = ZG1::from_g1_projective(G1Projective {
x: ZFp::from_raw_unchecked([
0x5cb3_8790_fd53_0c16,
0x7817_fc67_9976_fff5,
0x154f_95c7_143b_a1c1,
0xf0ae_6acd_f3d0_e747,
0xedce_6ecc_21db_f440,
0x1201_7741_9e0b_fb75,
]),
y: ZFp::from_raw_unchecked([
0xbaac_93d5_0ce7_2271,
0x8c22_631a_7918_fd8e,
0xdd59_5f13_5707_25ce,
0x51ac_5829_5040_5194,
0x0e1c_8c3f_ad00_59c0,
0x0bbc_3efc_5008_a26a,
]),
z: ZFp::from_raw_unchecked([
0x7609_0000_0002_fffd,
0xebf4_000b_c40c_0002,
0x5f48_9857_53c7_58ba,
0x77ce_5853_7052_5745,
0x5c07_1a97_a256_ec6d,
0x15f6_5ec3_fa80_e493,
]),
});
pub const G1_NEGATIVE_GENERATOR: ZG1 = ZG1::from_g1_projective(G1Projective {
x: ZFp::from_raw_unchecked([
0x5cb3_8790_fd53_0c16,
0x7817_fc67_9976_fff5,
0x154f_95c7_143b_a1c1,
0xf0ae_6acd_f3d0_e747,
0xedce_6ecc_21db_f440,
0x1201_7741_9e0b_fb75,
]),
y: ZFp::from_raw_unchecked([
0xff52_6c2a_f318_883a,
0x9289_9ce4_383b_0270,
0x89d7_738d_9fa9_d055,
0x12ca_f35b_a344_c12a,
0x3cff_1b76_964b_5317,
0x0e44_d2ed_e977_4430,
]),
z: ZFp::from_raw_unchecked([
0x7609_0000_0002_fffd,
0xebf4_000b_c40c_0002,
0x5f48_9857_53c7_58ba,
0x77ce_5853_7052_5745,
0x5c07_1a97_a256_ec6d,
0x15f6_5ec3_fa80_e493,
]),
});
#[rustfmt::skip]
pub const G1_IDENTITY: ZG1 = ZG1::from_g1_projective( G1Projective {
x: ZFp::zero(),
y: ZFp::one(),
z: ZFp::zero(),
});
pub const G2_GENERATOR: ZG2 = ZG2::from_g2_projective(G2Projective {
x: ZFp2 {
c0: ZFp([
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
]),
c1: ZFp([
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
]),
},
y: ZFp2 {
c0: ZFp([
0x4c730af860494c4a,
0x597cfa1f5e369c5a,
0xe7e6856caa0a635a,
0xbbefb5e96e0d495f,
0x07d3a975f0ef25a2,
0x0083fd8e7e80dae5,
]),
c1: ZFp([
0xadc0fc92df64b05d,
0x18aa270a2b1461dc,
0x86adac6a3be4eba0,
0x79495c4ec93da33a,
0xe7175850a43ccaed,
0x0b2bc2a163de1bf2,
]),
},
z: ZFp2 {
c0: ZFp([
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
]),
c1: ZFp([
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
]),
},
});
pub const G2_NEGATIVE_GENERATOR: ZG2 = ZG2::from_g2_projective(G2Projective {
x: ZFp2 {
c0: ZFp([
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
]),
c1: ZFp([
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
]),
},
y: ZFp2 {
c0: ZFp([
0x6d8bf5079fb65e61,
0xc52f05df531d63a5,
0x7f4a4d344ca692c9,
0xa887959b8577c95f,
0x4347fe40525c8734,
0x197d145bbaff0bb5,
]),
c1: ZFp([
0x0c3e036d209afa4e,
0x0601d8f4863f9e23,
0xe0832636bacc0a84,
0xeb2def362a476f84,
0x64044f659f0ee1e9,
0x0ed54f48d5a1caa7,
]),
},
z: ZFp2 {
c0: ZFp([
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
]),
c1: ZFp([
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
]),
},
});
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/das.rs | zkcrypto/src/das.rs | use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::ZFr as BlstFr;
use kzg::{DASExtension, Fr};
use std::cmp::Ordering;
impl FFTSettings {
fn das_fft_extension_stride(&self, ab: &mut [BlstFr], stride: usize) {
match ab.len().cmp(&2_usize) {
Ordering::Less => {}
Ordering::Greater => {
let half = ab.len();
let halfhalf = half / 2;
for i in 0..halfhalf {
let tmp1 = ab[i].add(&ab[halfhalf + i]);
let tmp2 = ab[i].sub(&ab[halfhalf + i]);
ab[halfhalf + i] = tmp2.mul(&self.reverse_roots_of_unity[i * 2 * stride]);
ab[i] = tmp1;
}
#[cfg(feature = "parallel")]
{
if ab.len() > 32 {
let (lo, hi) = ab.split_at_mut(halfhalf);
rayon::join(
|| self.das_fft_extension_stride(hi, stride * 2),
|| self.das_fft_extension_stride(lo, stride * 2),
);
} else {
self.das_fft_extension_stride(&mut ab[..halfhalf], stride * 2);
self.das_fft_extension_stride(&mut ab[halfhalf..], stride * 2);
}
}
#[cfg(not(feature = "parallel"))]
{
self.das_fft_extension_stride(&mut ab[..halfhalf], stride * 2);
self.das_fft_extension_stride(&mut ab[halfhalf..], stride * 2);
}
for i in 0..halfhalf {
let x = ab[i];
let y = ab[halfhalf + i];
let y_times_root = y.mul(&self.roots_of_unity[(1 + 2 * i) * stride]);
ab[i] = x.add(&y_times_root);
ab[halfhalf + i] = x.sub(&y_times_root);
}
}
Ordering::Equal => {
let x = ab[0].add(&ab[1]);
let y = ab[0].sub(&ab[1]);
let tmp = y.mul(&self.roots_of_unity[stride]);
ab[0] = x.add(&tmp);
ab[1] = x.sub(&tmp);
}
}
}
}
impl DASExtension<BlstFr> for FFTSettings {
fn das_fft_extension(&self, vals: &[BlstFr]) -> Result<Vec<BlstFr>, String> {
if vals.is_empty() {
return Err(String::from("vals can not be empty"));
}
if !vals.len().is_power_of_two() {
return Err(String::from("vals lenght has to be power of 2"));
}
if vals.len() * 2 > self.max_width {
return Err(String::from(
"vals lenght * 2 has to equal or less than FFTSetings max width",
));
}
let mut vals = vals.to_vec();
let stride = self.max_width / (vals.len() * 2);
self.das_fft_extension_stride(&mut vals, stride);
let invlen = BlstFr::from_u64(vals.len() as u64);
let invlen = invlen.inverse();
for val in &mut vals {
val.fr *= invlen.fr
}
Ok(vals)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/lib.rs | zkcrypto/src/lib.rs | pub mod consts;
pub mod das;
pub mod eip_4844;
pub mod eip_7594;
pub mod fft;
pub mod fft_g1;
pub mod fk20_proofs;
pub mod kzg_proofs;
pub mod kzg_types;
pub mod poly;
pub mod recover;
pub mod utils;
pub mod zero_poly;
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/eip_4844.rs | zkcrypto/src/eip_4844.rs | extern crate alloc;
#[cfg(feature = "c_bindings")]
use crate::utils::PRECOMPUTATION_TABLES;
#[cfg(feature = "c_bindings")]
use crate::{
kzg_proofs::KZGSettings,
kzg_types::{ZFr, ZG1, ZG2},
};
#[cfg(feature = "c_bindings")]
use core::ptr;
use kzg::eip_4844::load_trusted_setup_rust;
#[cfg(feature = "c_bindings")]
use kzg::{
eip_4844::{
BYTES_PER_G1, FIELD_ELEMENTS_PER_BLOB, TRUSTED_SETUP_NUM_G1_POINTS,
TRUSTED_SETUP_NUM_G2_POINTS,
},
eth,
eth::c_bindings::{Blob, Bytes32, Bytes48, CKZGSettings, CKzgRet, KZGCommitment, KZGProof},
Fr, G1,
};
#[cfg(all(feature = "std", feature = "c_bindings"))]
use libc::FILE;
#[cfg(feature = "std")]
use std::fs::File;
#[cfg(feature = "std")]
use std::io::Read;
#[cfg(feature = "std")]
use kzg::eip_4844::load_trusted_setup_string;
#[cfg(feature = "c_bindings")]
pub(crate) fn kzg_settings_to_c(rust_settings: &KZGSettings) -> CKZGSettings {
CKZGSettings {
roots_of_unity: Box::leak(
rust_settings
.fs
.roots_of_unity
.iter()
.map(ZFr::to_blst_fr)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
brp_roots_of_unity: Box::leak(
rust_settings
.fs
.brp_roots_of_unity
.iter()
.map(ZFr::to_blst_fr)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
reverse_roots_of_unity: Box::leak(
rust_settings
.fs
.reverse_roots_of_unity
.iter()
.map(ZFr::to_blst_fr)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g1_values_monomial: Box::leak(
rust_settings
.g1_values_monomial
.iter()
.map(ZG1::to_blst_p1)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g1_values_lagrange_brp: Box::leak(
rust_settings
.g1_values_lagrange_brp
.iter()
.map(ZG1::to_blst_p1)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g2_values_monomial: Box::leak(
rust_settings
.g2_values_monomial
.iter()
.map(ZG2::to_blst_p2)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
x_ext_fft_columns: Box::leak(
rust_settings
.x_ext_fft_columns
.iter()
.map(|r| {
Box::leak(
r.iter()
.map(ZG1::to_blst_p1)
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr()
})
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
tables: core::ptr::null_mut(),
wbits: 0,
scratch_size: 0,
}
}
#[cfg(feature = "c_bindings")]
macro_rules! handle_ckzg_badargs {
($x: expr) => {
match $x {
Ok(value) => value,
Err(_) => return kzg::eth::c_bindings::CKzgRet::BadArgs,
}
};
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn load_trusted_setup(
out: *mut CKZGSettings,
g1_monomial_bytes: *const u8,
num_g1_monomial_bytes: u64,
g1_lagrange_bytes: *const u8,
num_g1_lagrange_bytes: u64,
g2_monomial_bytes: *const u8,
num_g2_monomial_bytes: u64,
_precompute: u64,
) -> CKzgRet {
*out = CKZGSettings {
brp_roots_of_unity: ptr::null_mut(),
roots_of_unity: ptr::null_mut(),
reverse_roots_of_unity: ptr::null_mut(),
g1_values_monomial: ptr::null_mut(),
g1_values_lagrange_brp: ptr::null_mut(),
g2_values_monomial: ptr::null_mut(),
x_ext_fft_columns: ptr::null_mut(),
tables: ptr::null_mut(),
wbits: 0,
scratch_size: 0,
};
let g1_monomial_bytes =
core::slice::from_raw_parts(g1_monomial_bytes, num_g1_monomial_bytes as usize);
let g1_lagrange_bytes =
core::slice::from_raw_parts(g1_lagrange_bytes, num_g1_lagrange_bytes as usize);
let g2_monomial_bytes =
core::slice::from_raw_parts(g2_monomial_bytes, num_g2_monomial_bytes as usize);
TRUSTED_SETUP_NUM_G1_POINTS = num_g1_monomial_bytes as usize / BYTES_PER_G1;
let mut settings = handle_ckzg_badargs!(load_trusted_setup_rust(
g1_monomial_bytes,
g1_lagrange_bytes,
g2_monomial_bytes
));
let c_settings = kzg_settings_to_c(&settings);
#[allow(static_mut_refs)]
PRECOMPUTATION_TABLES.save_precomputation(settings.precomputation.take(), &c_settings);
*out = c_settings;
CKzgRet::Ok
}
/// # Safety
#[cfg(all(feature = "std", feature = "c_bindings"))]
#[no_mangle]
pub unsafe extern "C" fn load_trusted_setup_file(
out: *mut CKZGSettings,
in_: *mut FILE,
) -> CKzgRet {
use crate::utils::PRECOMPUTATION_TABLES;
*out = CKZGSettings {
brp_roots_of_unity: ptr::null_mut(),
roots_of_unity: ptr::null_mut(),
reverse_roots_of_unity: ptr::null_mut(),
g1_values_monomial: ptr::null_mut(),
g1_values_lagrange_brp: ptr::null_mut(),
g2_values_monomial: ptr::null_mut(),
x_ext_fft_columns: ptr::null_mut(),
tables: ptr::null_mut(),
wbits: 0,
scratch_size: 0,
};
let mut buf = vec![0u8; 1024 * 1024];
let len: usize = libc::fread(buf.as_mut_ptr() as *mut libc::c_void, 1, buf.len(), in_);
let s = handle_ckzg_badargs!(String::from_utf8(buf[..len].to_vec()));
let (g1_monomial_bytes, g1_lagrange_bytes, g2_monomial_bytes) =
handle_ckzg_badargs!(load_trusted_setup_string(&s));
TRUSTED_SETUP_NUM_G1_POINTS = g1_monomial_bytes.len() / BYTES_PER_G1;
if TRUSTED_SETUP_NUM_G1_POINTS != FIELD_ELEMENTS_PER_BLOB {
// Helps pass the Java test "shouldThrowExceptionOnIncorrectTrustedSetupFromFile",
// as well as 5 others that pass only if this one passes (likely because Java doesn't
// deallocate its KZGSettings pointer when no exception is thrown).
return CKzgRet::BadArgs;
}
let mut settings = handle_ckzg_badargs!(load_trusted_setup_rust(
&g1_monomial_bytes,
&g1_lagrange_bytes,
&g2_monomial_bytes
));
let c_settings = kzg_settings_to_c(&settings);
#[allow(static_mut_refs)]
PRECOMPUTATION_TABLES.save_precomputation(settings.precomputation.take(), &c_settings);
*out = c_settings;
CKzgRet::Ok
}
#[cfg(feature = "std")]
pub fn load_trusted_setup_filename_rust(
filepath: &str,
) -> Result<crate::kzg_proofs::KZGSettings, alloc::string::String> {
let mut file = File::open(filepath).map_err(|_| "Unable to open file".to_string())?;
let mut contents = String::new();
file.read_to_string(&mut contents)
.map_err(|_| "Unable to read file".to_string())?;
let (g1_monomial_bytes, g1_lagrange_bytes, g2_monomial_bytes) =
load_trusted_setup_string(&contents)?;
load_trusted_setup_rust(&g1_monomial_bytes, &g1_lagrange_bytes, &g2_monomial_bytes)
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn blob_to_kzg_commitment(
out: *mut KZGCommitment,
blob: *const Blob,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::blob_to_kzg_commitment_raw;
if TRUSTED_SETUP_NUM_G1_POINTS == 0 {
// FIXME: load_trusted_setup should set this value, but if not, it fails
TRUSTED_SETUP_NUM_G1_POINTS = FIELD_ELEMENTS_PER_BLOB
};
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let tmp = handle_ckzg_badargs!(blob_to_kzg_commitment_raw((*blob).bytes, &settings));
(*out).bytes = tmp.to_bytes();
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn free_trusted_setup(s: *mut CKZGSettings) {
if s.is_null() {
return;
}
#[allow(static_mut_refs)]
PRECOMPUTATION_TABLES.remove_precomputation(&*s);
if !(*s).roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
));
drop(v);
(*s).roots_of_unity = ptr::null_mut();
}
if !(*s).brp_roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).brp_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB,
));
drop(v);
(*s).brp_roots_of_unity = ptr::null_mut();
}
if !(*s).reverse_roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).reverse_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
));
drop(v);
(*s).reverse_roots_of_unity = ptr::null_mut();
}
if !(*s).g1_values_monomial.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g1_values_monomial,
FIELD_ELEMENTS_PER_BLOB,
));
drop(v);
(*s).g1_values_monomial = ptr::null_mut();
}
if !(*s).g1_values_lagrange_brp.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g1_values_lagrange_brp,
FIELD_ELEMENTS_PER_BLOB,
));
drop(v);
(*s).g1_values_lagrange_brp = ptr::null_mut();
}
if !(*s).g2_values_monomial.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g2_values_monomial,
TRUSTED_SETUP_NUM_G2_POINTS,
));
drop(v);
(*s).g2_values_monomial = ptr::null_mut();
}
if !(*s).x_ext_fft_columns.is_null() {
let x_ext_fft_columns = core::slice::from_raw_parts_mut(
(*s).x_ext_fft_columns,
2 * ((eth::FIELD_ELEMENTS_PER_EXT_BLOB / 2) / eth::FIELD_ELEMENTS_PER_CELL),
);
for column in x_ext_fft_columns.iter_mut() {
if !(*column).is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
*column,
eth::FIELD_ELEMENTS_PER_CELL,
));
drop(v);
*column = ptr::null_mut();
}
}
let v = Box::from_raw(x_ext_fft_columns);
drop(v);
(*s).x_ext_fft_columns = ptr::null_mut();
}
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_kzg_proof(
ok: *mut bool,
commitment_bytes: *const Bytes48,
z_bytes: *const Bytes32,
y_bytes: *const Bytes32,
proof_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_kzg_proof_raw(
(*commitment_bytes).bytes,
(*z_bytes).bytes,
(*y_bytes).bytes,
(*proof_bytes).bytes,
&settings
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_blob_kzg_proof(
ok: *mut bool,
blob: *const Blob,
commitment_bytes: *const Bytes48,
proof_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_blob_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_blob_kzg_proof_raw(
(*blob).bytes,
(*commitment_bytes).bytes,
(*proof_bytes).bytes,
&settings,
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_blob_kzg_proof_batch(
ok: *mut bool,
blobs: *const Blob,
commitments_bytes: *const Bytes48,
proofs_bytes: *const Bytes48,
n: usize,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_blob_kzg_proof_batch_raw;
let blobs = core::slice::from_raw_parts(blobs, n)
.iter()
.map(|v| v.bytes)
.collect::<Vec<_>>();
let commitments = core::slice::from_raw_parts(commitments_bytes, n)
.iter()
.map(|v| v.bytes)
.collect::<Vec<_>>();
let proofs = core::slice::from_raw_parts(proofs_bytes, n)
.iter()
.map(|v| v.bytes)
.collect::<Vec<_>>();
*ok = false;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_blob_kzg_proof_batch_raw(
&blobs,
&commitments,
&proofs,
&settings
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn compute_blob_kzg_proof(
out: *mut KZGProof,
blob: *const Blob,
commitment_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::compute_blob_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let proof = handle_ckzg_badargs!(compute_blob_kzg_proof_raw(
(*blob).bytes,
(*commitment_bytes).bytes,
&settings
));
(*out).bytes = proof.to_bytes();
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn compute_kzg_proof(
proof_out: *mut KZGProof,
y_out: *mut Bytes32,
blob: *const Blob,
z_bytes: *const Bytes32,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::compute_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let (proof_out_tmp, fry_tmp) = handle_ckzg_badargs!(compute_kzg_proof_raw(
(*blob).bytes,
(*z_bytes).bytes,
&settings
));
(*proof_out).bytes = proof_out_tmp.to_bytes();
(*y_out).bytes = fry_tmp.to_bytes();
CKzgRet::Ok
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/kzg_proofs.rs | zkcrypto/src/kzg_proofs.rs | #![allow(non_camel_case_types)]
use crate::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine};
use crate::kzg_types::{ZFr as BlstFr, ZG1, ZG2};
use crate::poly::PolyData;
use bls12_381::{
multi_miller_loop, Fp12 as ZFp12, G1Affine, G2Affine, G2Prepared, MillerLoopResult,
};
use kzg::common_utils::log2_pow2;
use kzg::eip_4844::hash_to_bls_field;
use kzg::msm::precompute::PrecomputationTable;
use kzg::{FFTSettings as _, Fr as FrTrait, G1Mul, G2Mul, FFTG1, G1, G2};
use std::ops::{Add, Neg};
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct FFTSettings {
pub max_width: usize,
pub root_of_unity: ZFr,
pub roots_of_unity: Vec<ZFr>,
pub brp_roots_of_unity: Vec<ZFr>,
pub reverse_roots_of_unity: Vec<ZFr>,
}
pub fn expand_root_of_unity(root: &BlstFr, width: usize) -> Result<Vec<BlstFr>, String> {
let mut generated_powers = vec![BlstFr::one(), *root];
while !(generated_powers.last().unwrap().is_one()) {
if generated_powers.len() > width {
return Err(String::from("Root of unity multiplied for too long"));
}
generated_powers.push(generated_powers.last().unwrap().mul(root));
}
if generated_powers.len() != width + 1 {
return Err(String::from("Root of unity has invalid scale"));
}
Ok(generated_powers)
}
#[derive(Debug, Clone, Default)]
#[allow(clippy::type_complexity)]
pub struct KZGSettings {
pub fs: FFTSettings,
pub g1_values_monomial: Vec<ZG1>,
pub g1_values_lagrange_brp: Vec<ZG1>,
pub g2_values_monomial: Vec<ZG2>,
pub precomputation:
Option<Arc<PrecomputationTable<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>>>,
pub x_ext_fft_columns: Vec<Vec<ZG1>>,
pub cell_size: usize,
}
pub fn generate_trusted_setup(len: usize, secret: [u8; 32usize]) -> (Vec<ZG1>, Vec<ZG1>, Vec<ZG2>) {
let s = hash_to_bls_field(&secret);
let mut s_pow = ZFr::one();
let mut g1_monomial_values = Vec::with_capacity(len);
let mut g2_monomial_values = Vec::with_capacity(len);
for _ in 0..len {
g1_monomial_values.push(ZG1::generator().mul(&s_pow));
g2_monomial_values.push(ZG2::generator().mul(&s_pow));
s_pow = s_pow.mul(&s);
}
let s = FFTSettings::new(log2_pow2(len)).unwrap();
let g1_lagrange_values = s.fft_g1(&g1_monomial_values, true).unwrap();
(g1_monomial_values, g1_lagrange_values, g2_monomial_values)
}
pub fn eval_poly(p: &PolyData, x: &ZFr) -> ZFr {
if p.coeffs.is_empty() {
return ZFr::zero();
} else if x.is_zero() {
return p.coeffs[0];
}
let mut out = p.coeffs[p.coeffs.len() - 1];
let mut i = p.coeffs.len() - 2;
loop {
let temp = out.mul(x);
out = temp.add(&p.coeffs[i]);
if i == 0 {
break;
}
i -= 1;
}
out
}
pub fn pairings_verify(a1: &ZG1, a2: &ZG2, b1: &ZG1, b2: &ZG2) -> bool {
let a1neg = a1.proj.neg();
let aa1 = G1Affine::from(&a1neg);
let bb1 = G1Affine::from(b1.proj);
let aa2 = G2Affine::from(a2.proj);
let bb2 = G2Affine::from(b2.proj);
let aa2_prepared = G2Prepared::from(aa2);
let bb2_prepared = G2Prepared::from(bb2);
let loop0 = multi_miller_loop(&[(&aa1, &aa2_prepared)]);
let loop1 = multi_miller_loop(&[(&bb1, &bb2_prepared)]);
let gt_point = loop0.add(loop1);
let new_point = MillerLoopResult::final_exponentiation(>_point);
ZFp12::eq(&ZFp12::one(), &new_point.0)
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/eip_7594.rs | zkcrypto/src/eip_7594.rs | extern crate alloc;
use kzg::EcBackend;
use crate::kzg_proofs::FFTSettings;
use crate::kzg_proofs::KZGSettings;
use crate::kzg_types::ZFp;
use crate::kzg_types::ZFr;
use crate::kzg_types::ZG1Affine;
use crate::kzg_types::ZG1ProjAddAffine;
use crate::kzg_types::ZG1;
use crate::kzg_types::ZG2;
use crate::poly::PolyData;
pub struct ZBackend;
impl EcBackend for ZBackend {
type Fr = ZFr;
type G1Fp = ZFp;
type G1Affine = ZG1Affine;
type G1ProjAddAffine = ZG1ProjAddAffine;
type G1 = ZG1;
type G2 = ZG2;
type Poly = PolyData;
type FFTSettings = FFTSettings;
type KZGSettings = KZGSettings;
}
#[cfg(feature = "c_bindings")]
kzg::c_bindings_eip7594!(ZBackend);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/poly.rs | zkcrypto/src/poly.rs | extern crate alloc;
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use crate::consts::SCALE_FACTOR;
use crate::kzg_proofs::FFTSettings as ZFFTSettings;
use crate::kzg_types::ZFr;
use kzg::common_utils::{log2_pow2, log2_u64, next_pow_of_2};
use kzg::{FFTFr, FFTSettings, FFTSettingsPoly, Fr, Poly};
#[derive(Debug, Clone, Eq, PartialEq, Default)]
pub struct PolyData {
pub coeffs: Vec<ZFr>,
}
impl Poly<ZFr> for PolyData {
fn new(size: usize) -> Self {
Self {
coeffs: vec![ZFr::default(); size],
}
}
fn get_coeff_at(&self, i: usize) -> ZFr {
self.coeffs[i]
}
fn set_coeff_at(&mut self, i: usize, x: &ZFr) {
self.coeffs[i] = *x
}
fn get_coeffs(&self) -> &[ZFr] {
&self.coeffs
}
fn len(&self) -> usize {
self.coeffs.len()
}
fn eval(&self, x: &ZFr) -> ZFr {
if self.coeffs.is_empty() {
return ZFr::zero();
} else if x.is_zero() {
return self.coeffs[0];
}
let mut ret = self.coeffs[self.coeffs.len() - 1];
let mut i = self.coeffs.len() - 2;
loop {
let temp = ret.mul(x);
ret = temp.add(&self.coeffs[i]);
if i == 0 {
break;
}
i -= 1;
}
ret
}
fn scale(&mut self) {
let scale_factor = ZFr::from_u64(SCALE_FACTOR);
let inv_factor = scale_factor.inverse();
let mut factor_power = ZFr::one();
for i in 0..self.coeffs.len() {
factor_power = factor_power.mul(&inv_factor);
self.coeffs[i] = self.coeffs[i].mul(&factor_power);
}
}
fn unscale(&mut self) {
let scale_factor = ZFr::from_u64(SCALE_FACTOR);
let mut factor_power = ZFr::one();
for i in 0..self.coeffs.len() {
factor_power = factor_power.mul(&scale_factor);
self.coeffs[i] = self.coeffs[i].mul(&factor_power);
}
}
// TODO: analyze how algo works
fn inverse(&mut self, output_len: usize) -> Result<Self, String> {
if output_len == 0 {
return Err(String::from("Can't produce a zero-length result"));
} else if self.coeffs.is_empty() {
return Err(String::from("Can't inverse a zero-length poly"));
} else if self.coeffs[0].is_zero() {
return Err(String::from(
"First coefficient of polynomial mustn't be zero",
));
}
let mut ret = PolyData {
coeffs: vec![ZFr::zero(); output_len],
};
// If the input polynomial is constant, the remainder of the series is zero
if self.coeffs.len() == 1 {
ret.coeffs[0] = self.coeffs[0].eucl_inverse();
return Ok(ret);
}
let maxd = output_len - 1;
// Max space for multiplications is (2 * length - 1)
// Don't need the following as its recalculated inside
// let scale: usize = log2_pow2(next_pow_of_2(2 * output_len - 1));
// let fft_settings = FsFFTSettings::new(scale).unwrap();
// To store intermediate results
// Base case for d == 0
ret.coeffs[0] = self.coeffs[0].eucl_inverse();
let mut d: usize = 0;
let mut mask: usize = 1 << log2_u64(maxd);
while mask != 0 {
d = 2 * d + usize::from((maxd & mask) != 0);
mask >>= 1;
// b.c -> tmp0 (we're using out for c)
// tmp0.length = min_u64(d + 1, b->length + output->length - 1);
let len_temp = (d + 1).min(self.len() + output_len - 1);
let mut tmp0 = self.mul(&ret, len_temp).unwrap();
// 2 - b.c -> tmp0
for i in 0..tmp0.len() {
tmp0.coeffs[i] = tmp0.coeffs[i].negate();
}
let fr_two = Fr::from_u64(2);
tmp0.coeffs[0] = tmp0.coeffs[0].add(&fr_two);
// c.(2 - b.c) -> tmp1;
let tmp1 = ret.mul(&tmp0, d + 1).unwrap();
for i in 0..tmp1.len() {
ret.coeffs[i] = tmp1.coeffs[i];
}
}
if d + 1 != output_len {
return Err(String::from("D + 1 must be equal to output_len"));
}
Ok(ret)
}
fn div(&mut self, divisor: &Self) -> Result<Self, String> {
if divisor.len() >= self.len() || divisor.len() < 128 {
// Tunable parameter
self.long_div(divisor)
} else {
self.fast_div(divisor)
}
}
fn long_div(&mut self, divisor: &Self) -> Result<Self, String> {
if divisor.coeffs.is_empty() {
return Err(String::from("Can't divide by zero"));
} else if divisor.coeffs[divisor.coeffs.len() - 1].is_zero() {
return Err(String::from("Highest coefficient must be non-zero"));
}
let out_length = self.poly_quotient_length(divisor);
if out_length == 0 {
return Ok(PolyData { coeffs: vec![] });
}
// Special case for divisor.len() == 2
if divisor.len() == 2 {
let divisor_0 = divisor.coeffs[0];
let divisor_1 = divisor.coeffs[1];
let mut out_coeffs = Vec::from(&self.coeffs[1..]);
for i in (1..out_length).rev() {
out_coeffs[i] = out_coeffs[i].div(&divisor_1).unwrap();
let tmp = out_coeffs[i].mul(&divisor_0);
out_coeffs[i - 1] = out_coeffs[i - 1].sub(&tmp);
}
out_coeffs[0] = out_coeffs[0].div(&divisor_1).unwrap();
Ok(PolyData { coeffs: out_coeffs })
} else {
let mut out: PolyData = PolyData {
coeffs: vec![ZFr::default(); out_length],
};
let mut a_pos = self.len() - 1;
let b_pos = divisor.len() - 1;
let mut diff = a_pos - b_pos;
let mut a = self.coeffs.clone();
while diff > 0 {
out.coeffs[diff] = a[a_pos].div(&divisor.coeffs[b_pos]).unwrap();
for i in 0..(b_pos + 1) {
let tmp = out.coeffs[diff].mul(&divisor.coeffs[i]);
a[diff + i] = a[diff + i].sub(&tmp);
}
diff -= 1;
a_pos -= 1;
}
out.coeffs[0] = a[a_pos].div(&divisor.coeffs[b_pos]).unwrap();
Ok(out)
}
}
fn fast_div(&mut self, divisor: &Self) -> Result<Self, String> {
if divisor.coeffs.is_empty() {
return Err(String::from("Cant divide by zero"));
} else if divisor.coeffs[divisor.coeffs.len() - 1].is_zero() {
return Err(String::from("Highest coefficient must be non-zero"));
}
let m: usize = self.len() - 1;
let n: usize = divisor.len() - 1;
// If the divisor is larger than the dividend, the result is zero-length
if n > m {
return Ok(PolyData { coeffs: Vec::new() });
}
// Special case for divisor.length == 1 (it's a constant)
if divisor.len() == 1 {
let mut out = PolyData {
coeffs: vec![ZFr::zero(); self.len()],
};
for i in 0..out.len() {
out.coeffs[i] = self.coeffs[i].div(&divisor.coeffs[0]).unwrap();
}
return Ok(out);
}
let mut a_flip = self.flip().unwrap();
let mut b_flip = divisor.flip().unwrap();
let inv_b_flip = b_flip.inverse(m - n + 1).unwrap();
let q_flip = a_flip.mul(&inv_b_flip, m - n + 1).unwrap();
let out = q_flip.flip().unwrap();
Ok(out)
}
fn mul_direct(&mut self, multiplier: &Self, output_len: usize) -> Result<Self, String> {
if self.len() == 0 || multiplier.len() == 0 {
return Ok(PolyData::new(0));
}
let a_degree = self.len() - 1;
let b_degree = multiplier.len() - 1;
let mut ret = PolyData {
coeffs: vec![Fr::zero(); output_len],
};
// Truncate the output to the length of the output polynomial
for i in 0..(a_degree + 1) {
let mut j = 0;
while (j <= b_degree) && ((i + j) < output_len) {
let tmp = self.coeffs[i].mul(&multiplier.coeffs[j]);
let tmp = ret.coeffs[i + j].add(&tmp);
ret.coeffs[i + j] = tmp;
j += 1;
}
}
Ok(ret)
}
}
impl FFTSettingsPoly<ZFr, PolyData, ZFFTSettings> for ZFFTSettings {
fn poly_mul_fft(
a: &PolyData,
b: &PolyData,
len: usize,
_fs: Option<&ZFFTSettings>,
) -> Result<PolyData, String> {
b.mul_fft(a, len)
}
}
impl PolyData {
pub fn _poly_norm(&self) -> Self {
let mut ret = self.clone();
let mut temp_len: usize = ret.coeffs.len();
while temp_len > 0 && ret.coeffs[temp_len - 1].is_zero() {
temp_len -= 1;
}
if temp_len == 0 {
ret.coeffs = Vec::new();
} else {
ret.coeffs = ret.coeffs[0..temp_len].to_vec();
}
ret
}
pub fn poly_quotient_length(&self, divisor: &Self) -> usize {
if self.len() >= divisor.len() {
self.len() - divisor.len() + 1
} else {
0
}
}
pub fn pad(&self, out_length: usize) -> Self {
let mut ret = Self {
coeffs: vec![ZFr::zero(); out_length],
};
for i in 0..self.len().min(out_length) {
ret.coeffs[i] = self.coeffs[i];
}
ret
}
pub fn flip(&self) -> Result<PolyData, String> {
let mut ret = PolyData {
coeffs: vec![ZFr::default(); self.len()],
};
for i in 0..self.len() {
ret.coeffs[i] = self.coeffs[self.coeffs.len() - i - 1]
}
Ok(ret)
}
pub fn mul_fft(&self, multiplier: &Self, output_len: usize) -> Result<Self, String> {
let length = next_pow_of_2(self.len() + multiplier.len() - 1);
let scale = log2_pow2(length);
let fft_settings = ZFFTSettings::new(scale).unwrap();
let a_pad = self.pad(length);
let b_pad = multiplier.pad(length);
let a_fft: Vec<ZFr>;
let b_fft: Vec<ZFr>;
#[cfg(feature = "parallel")]
{
if length > 1024 {
let mut a_fft_temp = vec![];
let mut b_fft_temp = vec![];
rayon::join(
|| a_fft_temp = fft_settings.fft_fr(&a_pad.coeffs, false).unwrap(),
|| b_fft_temp = fft_settings.fft_fr(&b_pad.coeffs, false).unwrap(),
);
a_fft = a_fft_temp;
b_fft = b_fft_temp;
} else {
a_fft = fft_settings.fft_fr(&a_pad.coeffs, false).unwrap();
b_fft = fft_settings.fft_fr(&b_pad.coeffs, false).unwrap();
}
}
#[cfg(not(feature = "parallel"))]
{
// Convert Poly to values
a_fft = fft_settings.fft_fr(&a_pad.coeffs, false).unwrap();
b_fft = fft_settings.fft_fr(&b_pad.coeffs, false).unwrap();
}
// Multiply two value ranges
let mut ab_fft = a_fft;
ab_fft.iter_mut().zip(b_fft).for_each(|(a, b)| {
*a = a.mul(&b);
});
// Convert value range multiplication to a resulting polynomial
let ab = fft_settings.fft_fr(&ab_fft, true).unwrap();
drop(ab_fft);
let mut ret = PolyData {
coeffs: vec![ZFr::zero(); output_len],
};
let range = ..output_len.min(length);
ret.coeffs[range].clone_from_slice(&ab[range]);
Ok(ret)
}
pub fn mul(&mut self, multiplier: &Self, output_len: usize) -> Result<Self, String> {
if self.len() < 64 || multiplier.len() < 64 || output_len < 128 {
// Tunable parameter
self.mul_direct(multiplier, output_len)
} else {
self.mul_fft(multiplier, output_len)
}
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/kzg_types.rs | zkcrypto/src/kzg_types.rs | use crate::consts::{
G1_GENERATOR, G1_IDENTITY, G1_NEGATIVE_GENERATOR, G2_GENERATOR, G2_NEGATIVE_GENERATOR,
SCALE2_ROOT_OF_UNITY,
};
use crate::fft_g1::g1_linear_combination;
use crate::kzg_proofs::{
expand_root_of_unity, pairings_verify, FFTSettings as ZFFTSettings, KZGSettings as ZKZGSettings,
};
use crate::poly::PolyData;
use crate::utils::{
blst_fr_into_pc_fr, blst_p1_into_pc_g1projective, blst_p2_into_pc_g2projective,
fft_settings_to_rust, pc_fr_into_blst_fr, pc_g1projective_into_blst_p1,
pc_g2projective_into_blst_p2, PRECOMPUTATION_TABLES,
};
use arbitrary::Arbitrary;
use bls12_381::{Fp, G1Affine, G1Projective, G2Affine, G2Projective, Scalar, MODULUS, R2};
use ff::Field;
use kzg::common_utils::reverse_bit_order;
use kzg::eip_4844::{BYTES_PER_FIELD_ELEMENT, BYTES_PER_G1, BYTES_PER_G2};
use kzg::eth::c_bindings::{blst_fr, blst_p1, blst_p2, CKZGSettings};
use kzg::msm::precompute::{precompute, PrecomputationTable};
use kzg::{eth, G1Affine as G1AffineTrait};
use kzg::{
FFTFr, FFTSettings, Fr as KzgFr, G1Fp, G1GetFp, G1LinComb, G1Mul, G1ProjAddAffine, G2Mul,
KZGSettings, PairingVerify, Poly, Scalar256, G1, G2,
};
use std::hash::Hash;
use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
use std::sync::Arc;
use ff::derive::sbb;
use subtle::{Choice, ConstantTimeEq, CtOption};
fn to_scalar(zfr: &ZFr) -> Scalar {
zfr.fr
}
fn bigint_check_mod_256(a: &[u64; 4]) -> bool {
let (_, overflow) = a[0].overflowing_sub(MODULUS.0[0]);
let (_, overflow) = a[1].overflowing_sub(MODULUS.0[1] + overflow as u64);
let (_, overflow) = a[2].overflowing_sub(MODULUS.0[2] + overflow as u64);
let (_, overflow) = a[3].overflowing_sub(MODULUS.0[3] + overflow as u64);
overflow
}
#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
pub struct ZFr {
pub fr: Scalar,
}
impl ZFr {
pub fn from_blst_fr(fr: blst_fr) -> Self {
Self {
fr: blst_fr_into_pc_fr(fr),
}
}
pub fn to_blst_fr(&self) -> blst_fr {
pc_fr_into_blst_fr(self.fr)
}
pub fn converter(points: &[ZFr]) -> Vec<Scalar> {
let mut result = Vec::new();
for zg1 in points {
result.push(zg1.fr);
}
result
}
}
impl<'a> Arbitrary<'a> for ZFr {
fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
let val: [u8; 32] = u.arbitrary()?;
Ok(Self::from_bytes_unchecked(&val).unwrap())
}
}
impl KzgFr for ZFr {
fn null() -> Self {
Self {
fr: Scalar([u64::MAX, u64::MAX, u64::MAX, u64::MAX]),
}
}
fn zero() -> Self {
Self::from_u64(0)
}
fn one() -> Self {
Self::from_u64(1)
}
#[cfg(feature = "rand")]
fn rand() -> Self {
let rng = rand::thread_rng();
let rusult = ff::Field::random(rng);
Self { fr: rusult }
}
#[allow(clippy::bind_instead_of_map)]
fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_FIELD_ELEMENT,
bytes.len()
)
})
.and_then(|bytes: &[u8; BYTES_PER_FIELD_ELEMENT]| {
let mut tmp = Scalar([0, 0, 0, 0]);
tmp.0[0] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[0..8]).unwrap());
tmp.0[1] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[8..16]).unwrap());
tmp.0[2] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[16..24]).unwrap());
tmp.0[3] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[24..32]).unwrap());
// Try to subtract the modulus
let (_, borrow) = sbb(tmp.0[0], MODULUS.0[0], 0);
let (_, borrow) = sbb(tmp.0[1], MODULUS.0[1], borrow);
let (_, borrow) = sbb(tmp.0[2], MODULUS.0[2], borrow);
let (_, _borrow) = sbb(tmp.0[3], MODULUS.0[3], borrow);
let mut tmp2 = Scalar::default();
tmp2.0[0] = tmp.0[3];
tmp2.0[1] = tmp.0[2];
tmp2.0[2] = tmp.0[1];
tmp2.0[3] = tmp.0[0];
let is_zero: bool = tmp2.is_zero().into();
if !is_zero && !bigint_check_mod_256(&tmp2.0) {
return Err("Invalid scalar".to_string());
}
tmp2 *= &R2;
Ok(Self { fr: tmp2 })
})
}
fn from_bytes_unchecked(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_FIELD_ELEMENT,
bytes.len()
)
})
.map(|bytes: &[u8; BYTES_PER_FIELD_ELEMENT]| {
let mut tmp = Scalar([0, 0, 0, 0]);
tmp.0[0] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[0..8]).unwrap());
tmp.0[1] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[8..16]).unwrap());
tmp.0[2] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[16..24]).unwrap());
tmp.0[3] = u64::from_be_bytes(<[u8; 8]>::try_from(&bytes[24..32]).unwrap());
// Try to subtract the modulus
let (_, borrow) = sbb(tmp.0[0], MODULUS.0[0], 0);
let (_, borrow) = sbb(tmp.0[1], MODULUS.0[1], borrow);
let (_, borrow) = sbb(tmp.0[2], MODULUS.0[2], borrow);
let (_, _borrow) = sbb(tmp.0[3], MODULUS.0[3], borrow);
let mut tmp2 = Scalar::default();
tmp2.0[0] = tmp.0[3];
tmp2.0[1] = tmp.0[2];
tmp2.0[2] = tmp.0[1];
tmp2.0[3] = tmp.0[0];
tmp2 *= &R2;
Self { fr: tmp2 }
})
}
fn from_hex(hex: &str) -> Result<Self, String> {
let bytes = hex::decode(&hex[2..]).unwrap();
Self::from_bytes(&bytes)
}
fn from_u64_arr(u: &[u64; 4]) -> Self {
Self {
fr: Scalar::from_raw(*u),
}
}
fn from_u64(val: u64) -> Self {
Self {
fr: Scalar::from(val),
}
}
fn to_bytes(&self) -> [u8; 32] {
let scalar = self.fr;
let tmp = Scalar::montgomery_reduce(
scalar.0[0],
scalar.0[1],
scalar.0[2],
scalar.0[3],
0,
0,
0,
0,
);
let mut res = [0; 32];
res[0..8].copy_from_slice(&tmp.0[3].to_be_bytes());
res[8..16].copy_from_slice(&tmp.0[2].to_be_bytes());
res[16..24].copy_from_slice(&tmp.0[1].to_be_bytes());
res[24..32].copy_from_slice(&tmp.0[0].to_be_bytes());
res
}
//testuoti
fn to_u64_arr(&self) -> [u64; 4] {
let bytes = self.to_bytes();
[
u64::from_be_bytes(bytes[24..32].try_into().unwrap()),
u64::from_be_bytes(bytes[16..24].try_into().unwrap()),
u64::from_be_bytes(bytes[8..16].try_into().unwrap()),
u64::from_be_bytes(bytes[0..8].try_into().unwrap()),
]
}
fn is_one(&self) -> bool {
self.fr.ct_eq(&ZFr::one().fr).unwrap_u8() == 1
}
fn is_zero(&self) -> bool {
self.fr.is_zero().unwrap_u8() == 1
}
fn is_null(&self) -> bool {
self.fr.ct_eq(&ZFr::null().fr).unwrap_u8() == 1
}
fn sqr(&self) -> Self {
Self {
fr: self.fr.square(),
}
}
fn mul(&self, b: &Self) -> Self {
Self {
fr: Scalar::mul(&to_scalar(self), &to_scalar(b)),
}
}
fn add(&self, b: &Self) -> Self {
Self { fr: self.fr + b.fr }
}
fn sub(&self, b: &Self) -> Self {
Self { fr: self.fr - b.fr }
}
fn eucl_inverse(&self) -> Self {
Self {
fr: self.fr.invert().unwrap(),
}
}
fn negate(&self) -> Self {
Self { fr: self.fr.neg() }
}
fn inverse(&self) -> Self {
Self {
fr: self.fr.invert().unwrap(),
}
}
fn pow(&self, n: usize) -> Self {
let mut tmp = *self;
let mut out = Self::one();
let mut n2 = n;
loop {
if n2 & 1 == 1 {
out = out.mul(&tmp);
}
n2 >>= 1;
if n2 == 0 {
break;
}
tmp = tmp.sqr();
}
out
}
fn div(&self, b: &Self) -> Result<Self, String> {
if <ZFr>::is_zero(b) {
return Err("Cannot divide by zero".to_string());
}
let tmp = b.eucl_inverse();
let out = self.mul(&tmp);
Ok(out)
}
fn equals(&self, b: &Self) -> bool {
self.fr == b.fr
}
fn to_scalar(&self) -> Scalar256 {
let tmp = Scalar::montgomery_reduce(
self.fr.0[0],
self.fr.0[1],
self.fr.0[2],
self.fr.0[3],
0,
0,
0,
0,
);
Scalar256::from_u64(tmp.0)
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
pub struct ZFp(pub Fp);
impl G1Fp for ZFp {
fn zero() -> Self {
Self(Fp::zero())
}
fn one() -> Self {
Self(Fp::one())
}
fn bls12_381_rx_p() -> Self {
Self(Fp([
8505329371266088957,
17002214543764226050,
6865905132761471162,
8632934651105793861,
6631298214892334189,
1582556514881692819,
]))
}
fn inverse(&self) -> Option<Self> {
self.0.invert().map(Self).into()
}
fn square(&self) -> Self {
Self(self.0.square())
}
fn double(&self) -> Self {
Self(self.0.add(&self.0))
}
fn from_underlying_arr(arr: &[u64; 6]) -> Self {
Self(Fp(*arr))
}
fn neg_assign(&mut self) {
self.0 = self.0.neg();
}
fn mul_assign_fp(&mut self, b: &Self) {
self.0.mul_assign(b.0);
}
fn sub_assign_fp(&mut self, b: &Self) {
self.0.sub_assign(b.0);
}
fn add_assign_fp(&mut self, b: &Self) {
self.0.add_assign(b.0);
}
fn mul3(&self) -> Self {
const THREE: Fp = Fp([
17157870155352091297,
9692872460839157767,
5726366251156250088,
11420128032487956561,
9069687087735597977,
1000072309349998725,
]);
Self(self.0 * THREE)
}
}
#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
pub struct ZG1 {
pub proj: G1Projective,
}
impl Hash for ZG1 {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.proj.x.0.hash(state);
self.proj.y.0.hash(state);
self.proj.z.0.hash(state);
}
}
impl ZG1 {
pub const fn from_blst_p1(p1: blst_p1) -> Self {
Self {
proj: blst_p1_into_pc_g1projective(&p1),
}
}
pub const fn to_blst_p1(&self) -> blst_p1 {
pc_g1projective_into_blst_p1(self.proj)
}
pub const fn from_g1_projective(proj: G1Projective) -> Self {
Self { proj }
}
fn affine_to_projective(p: G1Affine) -> Self {
Self {
proj: G1Projective::from(&p),
}
}
pub fn converter(points: &[ZG1]) -> Vec<G1Projective> {
let mut result = Vec::new();
for zg1 in points {
result.push(zg1.proj);
}
result
}
}
impl From<blst_p1> for ZG1 {
fn from(p1: blst_p1) -> Self {
let proj = blst_p1_into_pc_g1projective(&p1);
Self { proj }
}
}
impl G1 for ZG1 {
fn identity() -> Self {
G1_IDENTITY
}
fn generator() -> Self {
G1_GENERATOR
}
fn negative_generator() -> Self {
G1_NEGATIVE_GENERATOR
}
#[cfg(feature = "rand")]
fn rand() -> Self {
let mut rng = rand::thread_rng();
Self {
proj: G1Projective::random(&mut rng),
}
}
#[allow(clippy::bind_instead_of_map)]
fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_G1,
bytes.len()
)
})
.and_then(|bytes: &[u8; BYTES_PER_G1]| {
let affine: CtOption<G1Affine> = G1Affine::from_compressed(bytes);
match affine.into() {
Some(x) => Ok(ZG1::affine_to_projective(x)),
None => Err("Failed to deserialize G1: Affine not available".to_string()),
}
})
}
fn from_hex(hex: &str) -> Result<Self, String> {
let bytes = hex::decode(&hex[2..]).unwrap();
Self::from_bytes(&bytes)
}
fn to_bytes(&self) -> [u8; 48] {
let g1_affine = G1Affine::from(self.proj);
g1_affine.to_compressed()
}
fn add_or_dbl(&self, b: &Self) -> Self {
if b.proj.eq(&self.proj) {
self.dbl()
} else {
self.add(b)
}
}
fn is_inf(&self) -> bool {
bool::from(self.proj.is_identity())
}
fn is_valid(&self) -> bool {
bool::from(self.proj.is_on_curve())
}
fn dbl(&self) -> Self {
Self {
proj: self.proj.double(),
}
}
fn add(&self, b: &Self) -> Self {
if self.is_inf() {
return *b;
}
if b.is_inf() {
return *self;
}
Self {
proj: self.proj + b.proj,
}
}
fn sub(&self, b: &Self) -> Self {
Self {
proj: self.proj.sub(&b.proj),
}
}
fn equals(&self, b: &Self) -> bool {
self.proj.eq(&b.proj)
}
fn add_or_dbl_assign(&mut self, b: &Self) {
if self.proj.eq(&b.proj) {
self.dbl_assign();
} else {
self.add_assign(b);
}
}
fn add_assign(&mut self, b: &Self) {
*self = self.add(b);
}
fn dbl_assign(&mut self) {
self.proj = self.proj.double();
}
fn zero() -> Self {
Self {
proj: G1Projective {
x: Fp([
8505329371266088957,
17002214543764226050,
6865905132761471162,
8632934651105793861,
6631298214892334189,
1582556514881692819,
]),
y: Fp([
8505329371266088957,
17002214543764226050,
6865905132761471162,
8632934651105793861,
6631298214892334189,
1582556514881692819,
]),
z: Fp([0, 0, 0, 0, 0, 0]),
},
}
}
}
impl G1Mul<ZFr> for ZG1 {
fn mul(&self, b: &ZFr) -> Self {
Self {
proj: self.proj.mul(b.fr),
}
}
}
#[repr(C)]
#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
pub struct ZG1Affine(pub G1Affine);
impl<'a> Arbitrary<'a> for ZG1Affine {
fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
Ok(ZG1Affine::into_affine(
&ZG1::generator().mul(&u.arbitrary()?),
))
}
}
impl G1AffineTrait<ZG1, ZFp> for ZG1Affine {
fn into_affine(g1: &ZG1) -> Self {
Self(g1.proj.into())
}
fn into_affines(g1: &[ZG1]) -> Vec<Self> {
let points =
unsafe { core::slice::from_raw_parts(g1.as_ptr() as *const G1Projective, g1.len()) };
let mut g1_affine_batch: Vec<G1Affine> = vec![G1Affine::default(); points.len()];
G1Projective::batch_normalize(points, &mut g1_affine_batch);
unsafe { core::mem::transmute(g1_affine_batch) }
}
fn into_affines_loc(out: &mut [Self], g1: &[ZG1]) {
out.copy_from_slice(&Self::into_affines(g1));
}
fn to_proj(&self) -> ZG1 {
ZG1 {
proj: self.0.into(),
}
}
fn x(&self) -> &ZFp {
unsafe { core::mem::transmute(&self.0.x) }
}
fn y(&self) -> &ZFp {
unsafe { core::mem::transmute(&self.0.y) }
}
fn is_infinity(&self) -> bool {
bool::from(self.0.infinity)
}
fn is_zero(&self) -> bool {
bool::from(self.0.infinity)
// FIXME: definetly wrong
}
fn zero() -> Self {
Self(G1Affine {
x: ZFp::zero().0,
y: ZFp::zero().0,
infinity: Choice::from(1),
})
}
fn x_mut(&mut self) -> &mut ZFp {
unsafe { core::mem::transmute(&mut self.0.x) }
}
fn y_mut(&mut self) -> &mut ZFp {
unsafe { core::mem::transmute(&mut self.0.y) }
}
// fn double(&mut self) {
// self.0.add(&self.0);
// }
// fn add(&mut self, b: &Self) {
// self.0 += b.0;
// }
fn neg(&self) -> Self {
Self(-self.0)
}
fn from_xy(x: ZFp, y: ZFp) -> Self {
let is_infinity = if x.is_zero() && y.is_zero() { 0u8 } else { 1u8 };
Self(G1Affine {
x: x.0,
y: y.0,
infinity: Choice::from(is_infinity),
})
}
fn to_bytes_uncompressed(&self) -> [u8; 96] {
self.0.to_uncompressed()
}
fn from_bytes_uncompressed(bytes: [u8; 96]) -> Result<Self, String> {
G1Affine::from_uncompressed(&bytes)
.map(Self)
.into_option()
.ok_or("Failed to deserialize point".to_owned())
}
}
#[derive(Debug)]
pub struct ZG1ProjAddAffine;
impl G1ProjAddAffine<ZG1, ZFp, ZG1Affine> for ZG1ProjAddAffine {
fn add_assign_affine(proj: &mut ZG1, aff: &ZG1Affine) {
proj.proj += aff.0;
}
fn add_or_double_assign_affine(proj: &mut ZG1, aff: &ZG1Affine) {
proj.proj += aff.0;
}
}
impl G1GetFp<ZFp> for ZG1 {
fn x(&self) -> &ZFp {
unsafe {
// Transmute safe due to repr(C) on ZFp
core::mem::transmute(&self.proj.x)
}
}
fn y(&self) -> &ZFp {
unsafe {
// Transmute safe due to repr(C) on ZFp
core::mem::transmute(&self.proj.y)
}
}
fn z(&self) -> &ZFp {
unsafe {
// Transmute safe due to repr(C) on ZFp
core::mem::transmute(&self.proj.z)
}
}
fn x_mut(&mut self) -> &mut ZFp {
unsafe {
// Transmute safe due to repr(C) on ZFp
core::mem::transmute(&mut self.proj.x)
}
}
fn y_mut(&mut self) -> &mut ZFp {
unsafe {
// Transmute safe due to repr(C) on ZFp
core::mem::transmute(&mut self.proj.y)
}
}
fn z_mut(&mut self) -> &mut ZFp {
unsafe {
// Transmute safe due to repr(C) on ZFp
core::mem::transmute(&mut self.proj.z)
}
}
fn from_jacobian(x: ZFp, y: ZFp, z: ZFp) -> Self {
let x = x.mul_fp(&z);
let z = z.square().mul_fp(&z);
Self {
proj: G1Projective {
x: x.0,
y: y.0,
z: z.0,
},
}
}
}
impl G1LinComb<ZFr, ZFp, ZG1Affine, ZG1ProjAddAffine> for ZG1 {
fn g1_lincomb(
points: &[Self],
scalars: &[ZFr],
len: usize,
precomputation: Option<&PrecomputationTable<ZFr, Self, ZFp, ZG1Affine, ZG1ProjAddAffine>>,
) -> Self {
let mut out = ZG1::default();
g1_linear_combination(&mut out, points, scalars, len, precomputation);
out
}
}
impl PairingVerify<ZG1, ZG2> for ZG1 {
fn verify(a1: &ZG1, a2: &ZG2, b1: &ZG1, b2: &ZG2) -> bool {
pairings_verify(a1, a2, b1, b2)
}
}
#[derive(Debug, Default, PartialEq, Eq, Clone)]
pub struct ZG2 {
pub proj: G2Projective,
}
impl ZG2 {
pub const fn from_blst_p2(p2: blst_p2) -> Self {
Self {
proj: blst_p2_into_pc_g2projective(&p2),
}
}
pub const fn from_g2_projective(proj: G2Projective) -> Self {
Self { proj }
}
pub const fn to_blst_p2(&self) -> blst_p2 {
pc_g2projective_into_blst_p2(self.proj)
}
}
impl G2 for ZG2 {
fn generator() -> Self {
G2_GENERATOR
}
fn negative_generator() -> Self {
G2_NEGATIVE_GENERATOR
}
#[allow(clippy::bind_instead_of_map)]
fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_G2,
bytes.len()
)
})
.and_then(|bytes: &[u8; BYTES_PER_G2]| {
let affine = G2Affine::from_compressed(bytes).unwrap();
Ok(ZG2::from_g2_projective(G2Projective::from(affine)))
})
}
fn to_bytes(&self) -> [u8; 96] {
let g2_affine = G2Affine::from(self.proj);
g2_affine.to_compressed()
}
fn add_or_dbl(&mut self, b: &Self) -> Self {
Self {
proj: self.proj + b.proj,
}
}
fn dbl(&self) -> Self {
Self {
proj: self.proj.double(),
}
}
fn sub(&self, b: &Self) -> Self {
Self {
proj: self.proj - b.proj,
}
}
fn equals(&self, b: &Self) -> bool {
self.proj.eq(&b.proj)
}
}
impl G2Mul<ZFr> for ZG2 {
fn mul(&self, b: &ZFr) -> Self {
Self {
proj: self.proj.mul(b.fr),
}
}
}
impl Default for ZFFTSettings {
fn default() -> Self {
Self::new(0).unwrap()
}
}
pub fn fft_g1_fast(
ret: &mut [ZG1],
data: &[ZG1],
stride: usize,
roots: &[ZFr],
roots_stride: usize,
) {
let half = ret.len() / 2;
if half > 0 {
#[cfg(feature = "parallel")]
{
let (lo, hi) = ret.split_at_mut(half);
rayon::join(
|| fft_g1_fast(lo, data, stride * 2, roots, roots_stride * 2),
|| fft_g1_fast(hi, &data[stride..], stride * 2, roots, roots_stride * 2),
);
}
#[cfg(not(feature = "parallel"))]
{
fft_g1_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_g1_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
for i in 0..half {
let y_times_root = ret[i + half].mul(&roots[i * roots_stride]);
ret[i + half] = ret[i].sub(&y_times_root);
ret[i] = ret[i].add_or_dbl(&y_times_root);
}
} else {
ret[0] = data[0];
}
}
impl FFTSettings<ZFr> for ZFFTSettings {
fn new(scale: usize) -> Result<Self, String> {
if scale >= SCALE2_ROOT_OF_UNITY.len() {
return Err(String::from(
"Scale is expected to be within root of unity matrix row size",
));
}
// max_width = 2 ^ max_scale
let max_width: usize = 1 << scale;
let root_of_unity = ZFr::from_u64_arr(&SCALE2_ROOT_OF_UNITY[scale]);
// create max_width of roots & store them reversed as well
let roots_of_unity = expand_root_of_unity(&root_of_unity, max_width)?;
let mut brp_roots_of_unity = roots_of_unity.clone();
brp_roots_of_unity.pop();
reverse_bit_order(&mut brp_roots_of_unity)?;
let mut reverse_roots_of_unity = roots_of_unity.clone();
reverse_roots_of_unity.reverse();
Ok(Self {
max_width,
root_of_unity,
reverse_roots_of_unity,
roots_of_unity,
brp_roots_of_unity,
})
}
fn get_max_width(&self) -> usize {
self.max_width
}
fn get_reverse_roots_of_unity_at(&self, i: usize) -> ZFr {
self.reverse_roots_of_unity[i]
}
fn get_reversed_roots_of_unity(&self) -> &[ZFr] {
&self.reverse_roots_of_unity
}
fn get_roots_of_unity_at(&self, i: usize) -> ZFr {
self.roots_of_unity[i]
}
fn get_roots_of_unity(&self) -> &[ZFr] {
&self.roots_of_unity
}
fn get_brp_roots_of_unity(&self) -> &[ZFr] {
&self.brp_roots_of_unity
}
fn get_brp_roots_of_unity_at(&self, i: usize) -> ZFr {
self.brp_roots_of_unity[i]
}
}
fn toeplitz_part_1(
field_elements_per_ext_blob: usize,
output: &mut [ZG1],
x: &[ZG1],
s: &ZFFTSettings,
) -> Result<(), String> {
let n = x.len();
let n2 = n * 2;
let mut x_ext = vec![ZG1::identity(); n2];
x_ext[..n].copy_from_slice(x);
let x_ext = &x_ext[..];
/* Ensure the length is valid */
if x_ext.len() > field_elements_per_ext_blob || !x_ext.len().is_power_of_two() {
return Err("Invalid input size".to_string());
}
let roots_stride = field_elements_per_ext_blob / x_ext.len();
fft_g1_fast(output, x_ext, 1, &s.roots_of_unity, roots_stride);
Ok(())
}
impl KZGSettings<ZFr, ZG1, ZG2, ZFFTSettings, PolyData, ZFp, ZG1Affine, ZG1ProjAddAffine>
for ZKZGSettings
{
fn new(
g1_monomial: &[ZG1],
g1_lagrange_brp: &[ZG1],
g2_monomial: &[ZG2],
fft_settings: &ZFFTSettings,
cell_size: usize,
) -> Result<Self, String> {
if g1_monomial.len() != g1_lagrange_brp.len() {
return Err("G1 point length mismatch".to_string());
}
let field_elements_per_blob = g1_monomial.len();
let field_elements_per_ext_blob = field_elements_per_blob * 2;
let n = field_elements_per_ext_blob / 2;
let k = n / cell_size;
let k2 = 2 * k;
let mut points = vec![ZG1::default(); k2];
let mut x = vec![ZG1::default(); k];
let mut x_ext_fft_columns = vec![vec![ZG1::default(); cell_size]; k2];
for offset in 0..cell_size {
let start = n - cell_size - 1 - offset;
for (i, p) in x.iter_mut().enumerate().take(k - 1) {
let j = start - i * cell_size;
*p = g1_monomial[j];
}
x[k - 1] = ZG1::identity();
toeplitz_part_1(field_elements_per_ext_blob, &mut points, &x, fft_settings)?;
for row in 0..k2 {
x_ext_fft_columns[row][offset] = points[row];
}
}
Ok(Self {
g1_values_monomial: g1_monomial.to_vec(),
g1_values_lagrange_brp: g1_lagrange_brp.to_vec(),
g2_values_monomial: g2_monomial.to_vec(),
fs: fft_settings.clone(),
precomputation: precompute(g1_lagrange_brp, &x_ext_fft_columns)
.ok()
.flatten()
.map(Arc::new),
x_ext_fft_columns,
cell_size,
})
}
fn commit_to_poly(&self, p: &PolyData) -> Result<ZG1, String> {
if p.coeffs.len() > self.g1_values_monomial.len() {
return Err(String::from("Polynomial is longer than secret g1"));
}
let mut out = ZG1::default();
g1_linear_combination(
&mut out,
&self.g1_values_monomial,
&p.coeffs,
p.coeffs.len(),
None,
);
Ok(out)
}
fn compute_proof_single(&self, p: &PolyData, x: &ZFr) -> Result<ZG1, String> {
if p.coeffs.is_empty() {
return Err(String::from("Polynomial must not be empty"));
}
// `-(x0^n)`, where `n` is `1`
let divisor_0 = x.negate();
// Calculate `q = p / (x^n - x0^n)` for our reduced case (see `compute_proof_multi` for
// generic implementation)
let mut out_coeffs = Vec::from(&p.coeffs[1..]);
for i in (1..out_coeffs.len()).rev() {
let tmp = out_coeffs[i].mul(&divisor_0);
out_coeffs[i - 1] = out_coeffs[i - 1].sub(&tmp);
}
let q = PolyData { coeffs: out_coeffs };
let ret = self.commit_to_poly(&q)?;
Ok(ret)
}
fn check_proof_single(&self, com: &ZG1, proof: &ZG1, x: &ZFr, y: &ZFr) -> Result<bool, String> {
let x_g2 = G2_GENERATOR.mul(x);
let s_minus_x: ZG2 = self.g2_values_monomial[1].sub(&x_g2);
let y_g1 = G1_GENERATOR.mul(y);
let commitment_minus_y: ZG1 = com.sub(&y_g1);
Ok(pairings_verify(
&commitment_minus_y,
&G2_GENERATOR,
proof,
&s_minus_x,
))
}
fn compute_proof_multi(&self, p: &PolyData, x: &ZFr, n: usize) -> Result<ZG1, String> {
if p.coeffs.is_empty() {
return Err(String::from("Polynomial must not be empty"));
}
if !n.is_power_of_two() {
return Err(String::from("n must be a power of two"));
}
// Construct x^n - x0^n = (x - x0.w^0)(x - x0.w^1)...(x - x0.w^(n-1))
let mut divisor = PolyData {
coeffs: Vec::with_capacity(n + 1),
};
// -(x0^n)
let x_pow_n = x.pow(n);
divisor.coeffs.push(x_pow_n.negate());
// Zeros
for _ in 1..n {
divisor.coeffs.push(ZFr { fr: Scalar::zero() });
}
// x^n
divisor.coeffs.push(ZFr { fr: Scalar::one() });
let mut new_polina = p.clone();
// Calculate q = p / (x^n - x0^n)
// let q = p.div(&divisor).unwrap();
let q = new_polina.div(&divisor)?;
let ret = self.commit_to_poly(&q)?;
Ok(ret)
}
fn check_proof_multi(
&self,
com: &ZG1,
proof: &ZG1,
x: &ZFr,
ys: &[ZFr],
n: usize,
) -> Result<bool, String> {
if !n.is_power_of_two() {
return Err(String::from("n is not a power of two"));
}
// Interpolate at a coset.
let mut interp = PolyData {
coeffs: self.fs.fft_fr(ys, true)?,
};
let inv_x = x.inverse(); // Not euclidean?
let mut inv_x_pow = inv_x;
for i in 1..n {
interp.coeffs[i] = interp.coeffs[i].mul(&inv_x_pow);
inv_x_pow = inv_x_pow.mul(&inv_x);
}
// [x^n]_2
let x_pow = inv_x_pow.inverse();
let xn2 = G2_GENERATOR.mul(&x_pow);
// [s^n - x^n]_2
let xn_minus_yn = self.g2_values_monomial[n].sub(&xn2);
// [interpolation_polynomial(s)]_1
let is1 = self.commit_to_poly(&interp).unwrap();
// [commitment - interpolation_polynomial(s)]_1 = [commit]_1 - [interpolation_polynomial(s)]_1
let commit_minus_interp = com.sub(&is1);
let ret = pairings_verify(&commit_minus_interp, &G2_GENERATOR, proof, &xn_minus_yn);
Ok(ret)
}
fn get_roots_of_unity_at(&self, i: usize) -> ZFr {
self.fs.get_roots_of_unity_at(i)
}
fn get_fft_settings(&self) -> &ZFFTSettings {
&self.fs
}
fn get_precomputation(
&self,
) -> Option<&PrecomputationTable<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>> {
self.precomputation.as_ref().map(|v| v.as_ref())
}
fn get_g1_monomial(&self) -> &[ZG1] {
&self.g1_values_monomial
}
fn get_g1_lagrange_brp(&self) -> &[ZG1] {
&self.g1_values_lagrange_brp
}
fn get_g2_monomial(&self) -> &[ZG2] {
&self.g2_values_monomial
}
fn get_x_ext_fft_columns(&self) -> &[Vec<ZG1>] {
&self.x_ext_fft_columns
}
fn get_cell_size(&self) -> usize {
self.cell_size
}
}
impl<'a> TryFrom<&'a CKZGSettings> for ZKZGSettings {
type Error = String;
fn try_from(c_settings: &'a CKZGSettings) -> Result<Self, Self::Error> {
Ok(ZKZGSettings {
fs: fft_settings_to_rust(c_settings)?,
g1_values_monomial: unsafe {
core::slice::from_raw_parts(
c_settings.g1_values_monomial,
eth::FIELD_ELEMENTS_PER_BLOB,
)
}
.iter()
.map(|r| ZG1::from_blst_p1(*r))
.collect::<Vec<_>>(),
g1_values_lagrange_brp: unsafe {
core::slice::from_raw_parts(
c_settings.g1_values_lagrange_brp,
eth::FIELD_ELEMENTS_PER_BLOB,
)
}
.iter()
.map(|r| ZG1::from_blst_p1(*r))
.collect::<Vec<_>>(),
g2_values_monomial: unsafe {
core::slice::from_raw_parts(
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | true |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/zero_poly.rs | zkcrypto/src/zero_poly.rs | use super::kzg_proofs::FFTSettings;
use crate::kzg_types::ZFr as BlstFr;
use crate::poly::PolyData;
use kzg::common_utils::next_pow_of_2;
use kzg::{FFTFr, Fr, ZeroPoly};
use std::cmp::{min, Ordering};
pub(crate) fn pad_poly(poly: &PolyData, new_length: usize) -> Result<Vec<BlstFr>, String> {
if new_length <= poly.coeffs.len() {
return Ok(poly.coeffs.clone());
}
let mut out = poly.coeffs.to_vec();
for _i in poly.coeffs.len()..new_length {
out.push(BlstFr::zero())
}
Ok(out)
}
impl ZeroPoly<BlstFr, PolyData> for FFTSettings {
#[allow(clippy::needless_range_loop)]
fn do_zero_poly_mul_partial(
&self,
indices: &[usize],
stride: usize,
) -> Result<PolyData, String> {
if indices.is_empty() {
// == 0
return Err(String::from("index array length mustnt be zero"));
}
let mut poly = PolyData {
coeffs: vec![BlstFr::one(); indices.len() + 1],
};
poly.coeffs[0] = (self.roots_of_unity[indices[0] * stride]).negate();
for i in 1..indices.len() {
let neg_di = (self.roots_of_unity[indices[i] * stride]).negate();
poly.coeffs[i] = neg_di;
poly.coeffs[i] = poly.coeffs[i].add(&poly.coeffs[i - 1]);
let mut j = i - 1;
while j > 0 {
poly.coeffs[j] = poly.coeffs[j].mul(&neg_di);
poly.coeffs[j] = poly.coeffs[j].add(&poly.coeffs[j - 1]);
j -= 1;
}
poly.coeffs[0] = poly.coeffs[0].mul(&neg_di);
}
Ok(poly)
}
#[allow(clippy::needless_range_loop)]
fn reduce_partials(&self, len_out: usize, partials: &[PolyData]) -> Result<PolyData, String> {
let mut out_degree: usize = 0;
for partial in partials {
out_degree += partial.coeffs.len() - 1;
}
if out_degree + 1 > len_out {
return Err(String::from("Expected domain size to be a power of 2"));
}
let mut p_partial = pad_poly(&partials[0], len_out).unwrap();
let mut mul_eval_ps = self.fft_fr(&p_partial, false).unwrap();
for partial in partials.iter().skip(1) {
p_partial = pad_poly(partial, len_out)?;
let p_eval = self.fft_fr(&p_partial, false).unwrap();
for j in 0..len_out {
mul_eval_ps[j].fr *= p_eval[j].fr;
}
}
let coeffs = self.fft_fr(&mul_eval_ps, true)?;
let out = PolyData {
coeffs: coeffs[..(out_degree + 1)].to_vec(),
};
Ok(out)
}
#[allow(clippy::comparison_chain)]
fn zero_poly_via_multiplication(
&self,
length: usize,
missing_indices: &[usize],
) -> Result<(Vec<BlstFr>, PolyData), String> {
let zero_eval: Vec<BlstFr>;
let mut zero_poly: PolyData;
if missing_indices.is_empty() {
zero_eval = Vec::new();
zero_poly = PolyData { coeffs: Vec::new() };
return Ok((zero_eval, zero_poly));
}
if missing_indices.len() >= length {
return Err(String::from("Missing idxs greater than domain size"));
} else if length > self.max_width {
return Err(String::from(
"Domain size greater than fft_settings.max_width",
));
} else if !length.is_power_of_two() {
return Err(String::from("Domain size must be a power of 2"));
}
let degree_of_partial = 256;
let missing_per_partial = degree_of_partial - 1;
let domain_stride = self.max_width / length;
let mut partial_count =
(missing_per_partial + missing_indices.len() - 1) / missing_per_partial;
let domain_ceiling = min(next_pow_of_2(partial_count * degree_of_partial), length);
if missing_indices.len() <= missing_per_partial {
zero_poly = self.do_zero_poly_mul_partial(missing_indices, domain_stride)?;
} else {
let mut work = vec![BlstFr::zero(); next_pow_of_2(partial_count * degree_of_partial)];
let mut partial_lens = Vec::new();
let mut offset = 0;
let mut out_offset = 0;
let max = missing_indices.len();
for _i in 0..partial_count {
let end = min(offset + missing_per_partial, max);
let mut partial =
self.do_zero_poly_mul_partial(&missing_indices[offset..end], domain_stride)?;
partial.coeffs = pad_poly(&partial, degree_of_partial)?;
work.splice(
out_offset..(out_offset + degree_of_partial),
partial.coeffs.to_vec(),
);
partial_lens.push(degree_of_partial);
offset += missing_per_partial;
out_offset += degree_of_partial;
}
partial_lens[partial_count - 1] =
1 + missing_indices.len() - (partial_count - 1) * missing_per_partial;
let reduction_factor = 4;
while partial_count > 1 {
let reduced_count = 1 + (partial_count - 1) / reduction_factor;
let partial_size = next_pow_of_2(partial_lens[0]);
for i in 0..reduced_count {
let start = i * reduction_factor;
let out_end = min((start + reduction_factor) * partial_size, domain_ceiling);
let reduced_len = min(out_end - start * partial_size, length);
let partials_num = min(reduction_factor, partial_count - start);
let mut partial_vec = Vec::new();
for j in 0..partials_num {
let k = (start + j) * partial_size;
partial_vec.push(PolyData {
coeffs: work[k..(k + partial_lens[i + j])].to_vec(),
});
}
if partials_num > 1 {
let mut reduced_poly = self.reduce_partials(reduced_len, &partial_vec)?;
partial_lens[i] = reduced_poly.coeffs.len();
reduced_poly.coeffs = pad_poly(&reduced_poly, partial_size * partials_num)?;
work.splice(
(start * partial_size)
..(start * partial_size + reduced_poly.coeffs.len()),
reduced_poly.coeffs,
);
} else {
partial_lens[i] = partial_lens[start];
}
}
partial_count = reduced_count;
}
zero_poly = PolyData { coeffs: work };
}
match zero_poly.coeffs.len().cmp(&length) {
Ordering::Less => zero_poly.coeffs = pad_poly(&zero_poly, length)?,
Ordering::Greater => zero_poly.coeffs = zero_poly.coeffs[..length].to_vec(),
Ordering::Equal => {}
}
zero_eval = self.fft_fr(&zero_poly.coeffs, false)?;
Ok((zero_eval, zero_poly))
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/fk20_proofs.rs | zkcrypto/src/fk20_proofs.rs | use crate::consts::G1_IDENTITY;
use crate::kzg_proofs::{FFTSettings, KZGSettings};
use crate::kzg_types::{ZFp, ZFr as BlstFr, ZG1Affine, ZG1ProjAddAffine, ZG1, ZG2};
use crate::poly::PolyData;
use kzg::common_utils::reverse_bit_order;
use kzg::{FFTFr, FK20MultiSettings, FK20SingleSettings, Fr, G1Mul, Poly, FFTG1, G1};
#[cfg(feature = "parallel")]
use rayon::prelude::*;
#[repr(C)]
#[derive(Debug, Clone, Default)]
pub struct KzgFK20SingleSettings {
pub ks: KZGSettings,
pub x_ext_fft: Vec<ZG1>,
pub x_ext_fft_len: usize,
}
#[repr(C)]
#[derive(Debug, Clone, Default)]
pub struct KzgFK20MultiSettings {
pub ks: KZGSettings,
pub chunk_len: usize,
pub x_ext_fft_files: Vec<Vec<ZG1>>,
pub length: usize,
}
impl
FK20SingleSettings<
BlstFr,
ZG1,
ZG2,
FFTSettings,
PolyData,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
> for KzgFK20SingleSettings
{
fn new(ks: &KZGSettings, n2: usize) -> Result<Self, String> {
let n = n2 / 2;
if n2 > ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n2.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
if n2 < 2 {
return Err(String::from("n2 must be equal or greater than 2"));
}
let mut x = Vec::new();
for i in 0..(n - 1) {
x.push(ks.g1_values_monomial[n - 2 - i])
}
x.push(G1_IDENTITY);
let new_ks = KZGSettings {
fs: ks.fs.clone(),
..KZGSettings::default()
};
Ok(KzgFK20SingleSettings {
ks: new_ks,
x_ext_fft: toeplitz_part_1(&x, &ks.fs).unwrap(),
x_ext_fft_len: n2,
})
}
fn data_availability(&self, p: &PolyData) -> Result<Vec<ZG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > self.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let mut out = fk20_single_da_opt(p, self).unwrap();
reverse_bit_order(&mut out)?;
Ok(out)
}
fn data_availability_optimized(&self, p: &PolyData) -> Result<Vec<ZG1>, String> {
fk20_single_da_opt(p, self)
}
}
impl
FK20MultiSettings<
BlstFr,
ZG1,
ZG2,
FFTSettings,
PolyData,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
> for KzgFK20MultiSettings
{
fn new(ks: &KZGSettings, n2: usize, chunk_len: usize) -> Result<Self, String> {
if n2 > ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n2.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
if n2 < 2 {
return Err(String::from("n2 must be equal or greater than 2"));
}
if chunk_len > n2 / 2 {
return Err(String::from("chunk_len must be equal or less than n2/2"));
}
if !chunk_len.is_power_of_two() {
return Err(String::from("chunk_len must be power of 2"));
}
if chunk_len == 0 {
return Err(String::from("chunk_len must be greater than 0"));
}
let n = n2 / 2;
let k = n / chunk_len;
let mut x_ext_fft_files = Vec::new();
for offset in 0..chunk_len {
let mut x = vec![ZG1::default(); k];
let start = if n >= chunk_len + 1 + offset {
n - chunk_len - 1 - offset
} else {
0
};
let mut j = start;
for i in x.iter_mut().take(k - 1) {
i.proj = ks.g1_values_monomial[j].proj;
if j >= chunk_len {
j -= chunk_len;
} else {
j = 0;
}
}
x[k - 1] = G1_IDENTITY;
x_ext_fft_files.push(toeplitz_part_1(&x, &ks.fs).unwrap());
}
let new_ks = KZGSettings {
fs: ks.fs.clone(),
..KZGSettings::default()
};
Ok(KzgFK20MultiSettings {
ks: new_ks,
x_ext_fft_files,
chunk_len,
length: n, //unsure if this is right
})
}
fn data_availability(&self, p: &PolyData) -> Result<Vec<ZG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > self.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let mut out = fk20_multi_da_opt(p, self).unwrap();
reverse_bit_order(&mut out)?;
Ok(out)
}
fn data_availability_optimized(&self, p: &PolyData) -> Result<Vec<ZG1>, String> {
fk20_multi_da_opt(p, self)
}
}
fn fk20_single_da_opt(p: &PolyData, fk: &KzgFK20SingleSettings) -> Result<Vec<ZG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > fk.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let outlen = 2 * p.len();
let toeplitz_coeffs = toeplitz_coeffs_step(p, outlen).unwrap();
let h_ext_fft = toeplitz_part_2(&toeplitz_coeffs, &fk.x_ext_fft, &fk.ks.fs).unwrap();
let h = toeplitz_part_3(&h_ext_fft, &fk.ks.fs).unwrap();
fk.ks.fs.fft_g1(&h, false)
}
fn fk20_multi_da_opt(p: &PolyData, fk: &KzgFK20MultiSettings) -> Result<Vec<ZG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > fk.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let n = n2 / 2;
let k = n / fk.chunk_len;
let k2 = k * 2;
let mut h_ext_fft = Vec::new();
for _i in 0..k2 {
h_ext_fft.push(G1_IDENTITY);
}
let mut toeplitz_coeffs = PolyData::new(n2 / fk.chunk_len);
for i in 0..fk.chunk_len {
toeplitz_coeffs =
toeplitz_coeffs_stride(p, i, fk.chunk_len, toeplitz_coeffs.len()).unwrap();
let h_ext_fft_file =
toeplitz_part_2(&toeplitz_coeffs, &fk.x_ext_fft_files[i], &fk.ks.fs).unwrap();
for j in 0..k2 {
h_ext_fft[j] = h_ext_fft[j].add_or_dbl(&h_ext_fft_file[j]);
}
}
// Calculate `h`
let mut h = toeplitz_part_3(&h_ext_fft, &fk.ks.fs).unwrap();
// Overwrite the second half of `h` with zero
for i in h.iter_mut().take(k2).skip(k) {
i.proj = G1_IDENTITY.proj;
}
fk.ks.fs.fft_g1(&h, false)
}
fn toeplitz_coeffs_step(p: &PolyData, outlen: usize) -> Result<PolyData, String> {
toeplitz_coeffs_stride(p, 0, 1, outlen)
}
fn toeplitz_coeffs_stride(
poly: &PolyData,
offset: usize,
stride: usize,
outlen: usize,
) -> Result<PolyData, String> {
let n = poly.len();
if stride == 0 {
return Err(String::from("stride must be greater than 0"));
}
let k = n / stride;
let k2 = k * 2;
if outlen < k2 {
return Err(String::from("outlen must be equal or greater than k2"));
}
let mut out = PolyData::new(outlen);
out.set_coeff_at(0, &poly.coeffs[n - 1 - offset]);
let mut i = 1;
while i <= (k + 1) && i < k2 {
out.set_coeff_at(i, &BlstFr::zero());
i += 1;
}
let mut j = 2 * stride - offset - 1;
for i in (k + 2)..k2 {
out.set_coeff_at(i, &poly.coeffs[j]);
j += stride;
}
Ok(out)
}
fn toeplitz_part_1(x: &[ZG1], fs: &FFTSettings) -> Result<Vec<ZG1>, String> {
let n = x.len();
let n2 = n * 2;
let mut x_ext = Vec::new();
for i in x.iter().take(n) {
x_ext.push(*i);
}
for _i in n..n2 {
x_ext.push(G1_IDENTITY);
}
fs.fft_g1(&x_ext, false)
}
fn toeplitz_part_2(
toeplitz_coeffs: &PolyData,
x_ext_fft: &[ZG1],
fs: &FFTSettings,
) -> Result<Vec<ZG1>, String> {
let toeplitz_coeffs_fft = fs.fft_fr(&toeplitz_coeffs.coeffs, false).unwrap();
#[cfg(feature = "parallel")]
{
let out: Vec<_> = (0..toeplitz_coeffs.len())
.into_par_iter()
.map(|i| x_ext_fft[i].mul(&toeplitz_coeffs_fft[i]))
.collect();
Ok(out)
}
#[cfg(not(feature = "parallel"))]
{
let mut out = Vec::new();
for i in 0..toeplitz_coeffs.len() {
out.push(x_ext_fft[i].mul(&toeplitz_coeffs_fft[i]));
}
Ok(out)
}
}
fn toeplitz_part_3(h_ext_fft: &[ZG1], fs: &FFTSettings) -> Result<Vec<ZG1>, String> {
let n = h_ext_fft.len() / 2;
let mut out = fs.fft_g1(h_ext_fft, true).unwrap();
// Zero the second half of h
for i in out.iter_mut().take(h_ext_fft.len()).skip(n) {
i.proj = G1_IDENTITY.proj;
}
Ok(out)
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/utils.rs | zkcrypto/src/utils.rs | use crate::{
kzg_proofs::FFTSettings,
kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1},
};
use bls12_381::{G1Projective, G2Projective, Scalar};
use kzg::{
eip_4844::PrecomputationTableManager,
eth::{
self,
c_bindings::{blst_fp, blst_fp2, blst_fr, blst_p1, blst_p2, CKZGSettings},
},
};
#[derive(Debug, PartialEq, Eq)]
pub struct Error;
pub const fn blst_fr_into_pc_fr(fr: blst_fr) -> Scalar {
Scalar(fr.l)
}
pub const fn pc_fr_into_blst_fr(scalar: Scalar) -> blst_fr {
blst_fr { l: scalar.0 }
}
pub const fn blst_fp2_into_pc_fq2(fp: &blst_fp2) -> bls12_381::Fp2 {
let c0 = bls12_381::Fp(fp.fp[0].l);
let c1 = bls12_381::Fp(fp.fp[1].l);
bls12_381::Fp2 { c0, c1 }
}
pub const fn blst_p1_into_pc_g1projective(p1: &blst_p1) -> G1Projective {
let x = bls12_381::Fp(p1.x.l);
let y = bls12_381::Fp(p1.y.l);
let z = bls12_381::Fp(p1.z.l);
G1Projective { x, y, z }
}
pub const fn pc_g1projective_into_blst_p1(p1: G1Projective) -> blst_p1 {
let x = blst_fp { l: p1.x.0 };
let y = blst_fp { l: p1.y.0 };
let z = blst_fp { l: p1.z.0 };
blst_p1 { x, y, z }
}
pub const fn blst_p2_into_pc_g2projective(p2: &blst_p2) -> G2Projective {
G2Projective {
x: blst_fp2_into_pc_fq2(&p2.x),
y: blst_fp2_into_pc_fq2(&p2.y),
z: blst_fp2_into_pc_fq2(&p2.z),
}
}
pub const fn pc_g2projective_into_blst_p2(p2: G2Projective) -> blst_p2 {
let x = blst_fp2 {
fp: [blst_fp { l: p2.x.c0.0 }, blst_fp { l: p2.x.c1.0 }],
};
let y = blst_fp2 {
fp: [blst_fp { l: p2.y.c0.0 }, blst_fp { l: p2.y.c1.0 }],
};
let z = blst_fp2 {
fp: [blst_fp { l: p2.z.c0.0 }, blst_fp { l: p2.z.c1.0 }],
};
blst_p2 { x, y, z }
}
pub(crate) fn fft_settings_to_rust(c_settings: *const CKZGSettings) -> Result<FFTSettings, String> {
let settings = unsafe { &*c_settings };
let roots_of_unity = unsafe {
core::slice::from_raw_parts(
settings.roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
)
.iter()
.map(|r| ZFr::from_blst_fr(*r))
.collect::<Vec<ZFr>>()
};
let brp_roots_of_unity = unsafe {
core::slice::from_raw_parts(
settings.brp_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB,
)
.iter()
.map(|r| ZFr::from_blst_fr(*r))
.collect::<Vec<ZFr>>()
};
let reverse_roots_of_unity = unsafe {
core::slice::from_raw_parts(
settings.reverse_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
)
.iter()
.map(|r| ZFr::from_blst_fr(*r))
.collect::<Vec<ZFr>>()
};
Ok(FFTSettings {
max_width: eth::FIELD_ELEMENTS_PER_EXT_BLOB,
root_of_unity: roots_of_unity[1],
roots_of_unity,
brp_roots_of_unity,
reverse_roots_of_unity,
})
}
pub(crate) static mut PRECOMPUTATION_TABLES: PrecomputationTableManager<
ZFr,
ZG1,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
> = PrecomputationTableManager::new();
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/fft_g1.rs | zkcrypto/src/fft_g1.rs | use crate::consts::G1_GENERATOR;
use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1};
use kzg::msm::precompute::PrecomputationTable;
use kzg::{Fr as KzgFr, G1Mul};
use kzg::{FFTG1, G1};
use std::ops::MulAssign;
#[warn(unused_variables)]
pub fn g1_linear_combination(
out: &mut ZG1,
points: &[ZG1],
scalars: &[ZFr],
len: usize,
precomputation: Option<&PrecomputationTable<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>>,
) {
let g1 = kzg::msm::msm_impls::msm(points, scalars, len, precomputation);
*out = g1
}
pub fn make_data(data: usize) -> Vec<ZG1> {
let mut vec = Vec::new();
if data != 0 {
vec.push(G1_GENERATOR);
for i in 1..data as u64 {
let res = vec[(i - 1) as usize].add_or_dbl(&G1_GENERATOR);
vec.push(res);
}
}
vec
}
impl FFTG1<ZG1> for FFTSettings {
fn fft_g1(&self, data: &[ZG1], inverse: bool) -> Result<Vec<ZG1>, String> {
if data.len() > self.max_width {
return Err(String::from("data length is longer than allowed max width"));
}
if !data.len().is_power_of_two() {
return Err(String::from("data length is not power of 2"));
}
let stride: usize = self.max_width / data.len();
let mut ret = vec![ZG1::default(); data.len()];
let roots = if inverse {
&self.reverse_roots_of_unity
} else {
&self.roots_of_unity
};
fft_g1_fast(&mut ret, data, 1, roots, stride);
if inverse {
let inv_fr_len = ZFr::from_u64(data.len() as u64).inverse();
ret[..data.len()]
.iter_mut()
.for_each(|f| f.proj.mul_assign(&inv_fr_len.fr));
}
Ok(ret)
}
}
pub fn fft_g1_slow(
ret: &mut [ZG1],
data: &[ZG1],
stride: usize,
roots: &[ZFr],
roots_stride: usize,
) {
for i in 0..data.len() {
ret[i] = data[0].mul(&roots[0]);
for j in 1..data.len() {
let jv = data[j * stride];
let r = roots[((i * j) % data.len()) * roots_stride];
let v = jv.mul(&r);
ret[i] = ret[i].add_or_dbl(&v);
}
}
}
pub fn fft_g1_fast(
ret: &mut [ZG1],
data: &[ZG1],
stride: usize,
roots: &[ZFr],
roots_stride: usize,
) {
let half = ret.len() / 2;
if half > 0 {
#[cfg(feature = "parallel")]
{
let (lo, hi) = ret.split_at_mut(half);
rayon::join(
|| fft_g1_fast(hi, &data[stride..], stride * 2, roots, roots_stride * 2),
|| fft_g1_fast(lo, data, stride * 2, roots, roots_stride * 2),
);
}
#[cfg(not(feature = "parallel"))]
{
fft_g1_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_g1_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
for i in 0..half {
let y_times_root = ret[i + half].mul(&roots[i * roots_stride]);
ret[i + half] = ret[i].sub(&y_times_root);
ret[i] = ret[i].add_or_dbl(&y_times_root);
}
} else {
ret[0] = data[0];
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/recover.rs | zkcrypto/src/recover.rs | use crate::consts::SCALE_FACTOR;
use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::ZFr as BlstFr;
use crate::poly::PolyData;
use kzg::{FFTFr, Fr, Poly, PolyRecover, ZeroPoly};
#[cfg(feature = "parallel")]
use kzg::common_utils::next_pow_of_2;
#[cfg(feature = "parallel")]
static mut INVERSE_FACTORS: Vec<BlstFr> = Vec::new();
#[cfg(feature = "parallel")]
static mut UNSCALE_FACTOR_POWERS: Vec<BlstFr> = Vec::new();
#[allow(clippy::needless_range_loop)]
pub fn scale_poly(p: &mut PolyData) {
let scale_factor = BlstFr::from_u64(SCALE_FACTOR);
let inv_factor = scale_factor.inverse();
#[allow(static_mut_refs)]
#[cfg(feature = "parallel")]
{
let optim = next_pow_of_2(p.len() - 1);
if optim <= 1024 {
unsafe {
if INVERSE_FACTORS.len() < p.len() {
if INVERSE_FACTORS.is_empty() {
INVERSE_FACTORS.push(BlstFr::one());
}
for i in (INVERSE_FACTORS.len())..p.len() {
INVERSE_FACTORS.push(INVERSE_FACTORS[i - 1].mul(&inv_factor));
}
}
for i in 1..p.len() {
p.coeffs[i] = p.coeffs[i].mul(&INVERSE_FACTORS[i]);
}
}
} else {
let mut factor_power = BlstFr::one();
for i in 1..p.len() {
factor_power = factor_power.mul(&inv_factor);
p.set_coeff_at(i, &p.get_coeff_at(i).mul(&factor_power));
}
}
}
#[cfg(not(feature = "parallel"))]
{
let mut factor_power = BlstFr::one();
for i in 1..p.len() {
factor_power = factor_power.mul(&inv_factor);
p.set_coeff_at(i, &p.get_coeff_at(i).mul(&factor_power));
}
}
}
#[allow(clippy::needless_range_loop)]
pub fn unscale_poly(p: &mut PolyData) {
let scale_factor = BlstFr::from_u64(SCALE_FACTOR);
#[allow(static_mut_refs)]
#[cfg(feature = "parallel")]
{
unsafe {
if UNSCALE_FACTOR_POWERS.len() < p.len() {
if UNSCALE_FACTOR_POWERS.is_empty() {
UNSCALE_FACTOR_POWERS.push(BlstFr::one());
}
for i in (UNSCALE_FACTOR_POWERS.len())..p.len() {
UNSCALE_FACTOR_POWERS.push(UNSCALE_FACTOR_POWERS[i - 1].mul(&scale_factor));
}
}
for i in 1..p.len() {
p.coeffs[i] = p.coeffs[i].mul(&UNSCALE_FACTOR_POWERS[i]);
}
}
}
#[cfg(not(feature = "parallel"))]
{
let mut factor_power = BlstFr::one();
for i in 1..p.len() {
factor_power = factor_power.mul(&scale_factor);
p.set_coeff_at(i, &p.get_coeff_at(i).mul(&factor_power));
}
}
}
impl PolyRecover<BlstFr, PolyData, FFTSettings> for PolyData {
fn recover_poly_coeffs_from_samples(
samples: &[Option<BlstFr>],
fs: &FFTSettings,
) -> Result<Self, String> {
if !samples.len().is_power_of_two() {
return Err(String::from("samples lenght has to be power of 2"));
}
let mut missing = Vec::new();
for (i, sample) in samples.iter().enumerate() {
if sample.is_none() {
missing.push(i);
}
}
if missing.len() > samples.len() / 2 {
return Err(String::from(
"Impossible to recover, too many shards are missing",
));
}
// Calculate `Z_r,I`
let (zero_eval, mut zero_poly) =
fs.zero_poly_via_multiplication(samples.len(), missing.as_slice())?;
// Check all is well
for (i, item) in zero_eval.iter().enumerate().take(samples.len()) {
if samples[i].is_none() != item.is_zero() {
return Err(String::from("sample and item are both zero"));
}
}
// Construct E * Z_r,I: the loop makes the evaluation polynomial
let mut poly_evaluations_with_zero = vec![BlstFr::zero(); samples.len()];
for i in 0..samples.len() {
if samples[i].is_none() {
poly_evaluations_with_zero[i] = BlstFr::zero();
} else {
poly_evaluations_with_zero[i] = samples[i].unwrap().mul(&zero_eval[i]);
}
}
// Now inverse FFT so that poly_with_zero is (E * Z_r,I)(x) = (D * Z_r,I)(x)
let mut poly_with_zero = PolyData {
coeffs: fs
.fft_fr(poly_evaluations_with_zero.as_slice(), true)
.unwrap(),
};
#[cfg(feature = "parallel")]
let optim = next_pow_of_2(poly_with_zero.len() - 1);
#[cfg(feature = "parallel")]
{
if optim > 1024 {
rayon::join(
|| scale_poly(&mut poly_with_zero),
|| scale_poly(&mut zero_poly),
);
} else {
scale_poly(&mut poly_with_zero);
scale_poly(&mut zero_poly);
}
}
#[cfg(not(feature = "parallel"))]
{
scale_poly(&mut poly_with_zero);
scale_poly(&mut zero_poly);
}
// Q1 = (D * Z_r,I)(k * x)
let scaled_poly_with_zero = poly_with_zero; // Renaming
// Q2 = Z_r,I(k * x)
let scaled_zero_poly = zero_poly.coeffs; // Renaming
let eval_scaled_poly_with_zero;
let eval_scaled_zero_poly;
#[cfg(feature = "parallel")]
{
if optim > 1024 {
let mut eval_scaled_poly_with_zero_temp = vec![];
let mut eval_scaled_zero_poly_temp = vec![];
rayon::join(
|| {
eval_scaled_poly_with_zero_temp =
fs.fft_fr(&scaled_poly_with_zero.coeffs, false).unwrap()
},
|| eval_scaled_zero_poly_temp = fs.fft_fr(&scaled_zero_poly, false).unwrap(),
);
eval_scaled_poly_with_zero = eval_scaled_poly_with_zero_temp;
eval_scaled_zero_poly = eval_scaled_zero_poly_temp;
} else {
eval_scaled_poly_with_zero =
fs.fft_fr(&scaled_poly_with_zero.coeffs, false).unwrap();
eval_scaled_zero_poly = fs.fft_fr(&scaled_zero_poly, false).unwrap();
}
}
#[cfg(not(feature = "parallel"))]
{
eval_scaled_poly_with_zero = fs.fft_fr(&scaled_poly_with_zero.coeffs, false).unwrap();
eval_scaled_zero_poly = fs.fft_fr(&scaled_zero_poly, false).unwrap();
}
let mut eval_scaled_reconstructed_poly = eval_scaled_poly_with_zero.clone();
for i in 0..samples.len() {
eval_scaled_reconstructed_poly[i] = eval_scaled_poly_with_zero[i]
.div(&eval_scaled_zero_poly[i])
.unwrap();
}
// The result of the division is D(k * x):
let mut scaled_reconstructed_poly = PolyData {
coeffs: fs.fft_fr(&eval_scaled_reconstructed_poly, true).unwrap(),
};
// k * x -> x
unscale_poly(&mut scaled_reconstructed_poly);
// Finally we have D(x) which evaluates to our original data at the powers of roots of unity
Ok(scaled_reconstructed_poly)
}
fn recover_poly_from_samples(
samples: &[Option<BlstFr>],
fs: &FFTSettings,
) -> Result<Self, String> {
let reconstructed_poly = Self::recover_poly_coeffs_from_samples(samples, fs)?;
// The evaluation polynomial for D(x) is the reconstructed data:
let out = PolyData {
coeffs: fs.fft_fr(&reconstructed_poly.coeffs, false).unwrap(),
};
// Check all is well
for (i, sample) in samples.iter().enumerate() {
if !sample.is_none() && !out.get_coeff_at(i).equals(&sample.unwrap()) {
return Err(String::from(
"sample is zero and out coeff at i is not equals to sample",
));
}
}
Ok(out)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/src/fft.rs | zkcrypto/src/fft.rs | use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::ZFr as BlstFr;
use kzg::{FFTFr, Fr as FFr};
impl FFTFr<BlstFr> for FFTSettings {
fn fft_fr(&self, data: &[BlstFr], inverse: bool) -> Result<Vec<BlstFr>, String> {
if data.len() > self.max_width {
return Err(String::from("data length is longer than allowed max width"));
}
if !data.len().is_power_of_two() {
return Err(String::from("data length is not power of 2"));
}
let stride = self.max_width / data.len();
let mut ret = vec![BlstFr::default(); data.len()];
let roots = if inverse {
&self.reverse_roots_of_unity
} else {
&self.roots_of_unity
};
fft_fr_fast(&mut ret, data, 1, roots, stride);
if inverse {
let inv_fr_len = BlstFr::from_u64(data.len() as u64).inverse();
ret[..data.len()]
.iter_mut()
.for_each(|f| *f = BlstFr::mul(f, &inv_fr_len));
}
Ok(ret)
}
}
pub fn fft_fr_fast(
ret: &mut [BlstFr],
data: &[BlstFr],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
) {
let half: usize = ret.len() / 2;
if half > 0 {
#[cfg(not(feature = "parallel"))]
{
fft_fr_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_fr_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
#[cfg(feature = "parallel")]
{
if half > 256 {
let (lo, hi) = ret.split_at_mut(half);
rayon::join(
|| fft_fr_fast(lo, data, stride * 2, roots, roots_stride * 2),
|| fft_fr_fast(hi, &data[stride..], stride * 2, roots, roots_stride * 2),
);
} else {
fft_fr_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_fr_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
}
for i in 0..half {
let y_times_root = ret[i + half].mul(&roots[i * roots_stride]);
ret[i + half] = ret[i].sub(&y_times_root);
ret[i] = ret[i].add(&y_times_root);
}
} else {
ret[0] = data[0];
}
}
pub fn fft_fr_slow(
ret: &mut [BlstFr],
data: &[BlstFr],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
) {
let mut v;
let mut jv;
let mut r;
for i in 0..data.len() {
ret[i] = data[0].mul(&roots[0]);
for j in 1..data.len() {
jv = data[j * stride];
r = roots[((i * j) % data.len()) * roots_stride];
v = jv.mul(&r);
ret[i] = ret[i].add(&v);
}
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/consts.rs | zkcrypto/tests/consts.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::consts::{
expand_roots_is_plausible, new_fft_settings_is_plausible, roots_of_unity_are_plausible,
roots_of_unity_is_the_expected_size, roots_of_unity_out_of_bounds_fails,
};
use rust_kzg_zkcrypto::consts::SCALE2_ROOT_OF_UNITY;
use rust_kzg_zkcrypto::kzg_proofs::expand_root_of_unity;
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
#[test]
fn roots_of_unity_out_of_bounds_fails_() {
roots_of_unity_out_of_bounds_fails::<ZFr, FFTSettings>();
}
#[test]
fn roots_of_unity_are_plausible_() {
roots_of_unity_are_plausible::<ZFr>(&SCALE2_ROOT_OF_UNITY);
}
#[test]
fn expand_roots_is_plausible_() {
expand_roots_is_plausible::<ZFr>(&SCALE2_ROOT_OF_UNITY, &expand_root_of_unity);
}
#[test]
fn new_fft_settings_is_plausible_() {
new_fft_settings_is_plausible::<ZFr, FFTSettings>();
}
#[test]
fn roots_of_unity_is_the_expected_size_() {
roots_of_unity_is_the_expected_size(&SCALE2_ROOT_OF_UNITY);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/das.rs | zkcrypto/tests/das.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::das::{das_extension_test_known, das_extension_test_random};
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
#[test]
fn das_extension_test_known_() {
das_extension_test_known::<ZFr, FFTSettings>();
}
#[test]
fn das_extension_test_random_() {
das_extension_test_random::<ZFr, FFTSettings>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/eip_4844.rs | zkcrypto/tests/eip_4844.rs | #[cfg(test)]
mod tests {
use kzg::eip_4844::{
blob_to_kzg_commitment_rust, blob_to_polynomial, bytes_to_blob,
compute_blob_kzg_proof_rust, compute_challenge_rust, compute_kzg_proof_rust,
compute_powers, evaluate_polynomial_in_evaluation_form, verify_blob_kzg_proof_batch_rust,
verify_blob_kzg_proof_rust, verify_kzg_proof_rust,
};
use kzg::Fr;
use kzg_bench::tests::eip_4844::{
blob_to_kzg_commitment_test, bytes_to_bls_field_test,
compute_and_verify_blob_kzg_proof_fails_with_incorrect_proof_test,
compute_and_verify_blob_kzg_proof_test,
compute_and_verify_kzg_proof_fails_with_incorrect_proof_test,
compute_and_verify_kzg_proof_round_trip_test,
compute_and_verify_kzg_proof_within_domain_test, compute_kzg_proof_test,
compute_powers_test, test_vectors_blob_to_kzg_commitment,
test_vectors_compute_blob_kzg_proof, test_vectors_compute_challenge,
test_vectors_compute_kzg_proof, test_vectors_verify_blob_kzg_proof,
test_vectors_verify_blob_kzg_proof_batch, test_vectors_verify_kzg_proof,
verify_kzg_proof_batch_fails_with_incorrect_proof_test, verify_kzg_proof_batch_test,
};
use rust_kzg_zkcrypto::consts::SCALE2_ROOT_OF_UNITY;
use rust_kzg_zkcrypto::eip_4844::load_trusted_setup_filename_rust;
use rust_kzg_zkcrypto::kzg_proofs::{expand_root_of_unity, FFTSettings, KZGSettings};
use rust_kzg_zkcrypto::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1, ZG2};
use rust_kzg_zkcrypto::poly::PolyData;
#[test]
pub fn bytes_to_bls_field_test_() {
bytes_to_bls_field_test::<ZFr>();
}
#[test]
pub fn compute_powers_test_() {
compute_powers_test::<ZFr>(&compute_powers);
}
#[test]
pub fn blob_to_kzg_commitment_test_() {
blob_to_kzg_commitment_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
);
}
#[test]
pub fn compute_kzg_proof_test_() {
compute_kzg_proof_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
);
}
#[test]
pub fn compute_and_verify_kzg_proof_round_trip_test_() {
compute_and_verify_kzg_proof_round_trip_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
&verify_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_kzg_proof_within_domain_test_() {
compute_and_verify_kzg_proof_within_domain_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
&verify_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_kzg_proof_fails_with_incorrect_proof_test_() {
compute_and_verify_kzg_proof_fails_with_incorrect_proof_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
&verify_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_blob_kzg_proof_test_() {
compute_and_verify_blob_kzg_proof_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_blob_kzg_proof_fails_with_incorrect_proof_test_() {
compute_and_verify_blob_kzg_proof_fails_with_incorrect_proof_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
);
}
#[test]
pub fn verify_kzg_proof_batch_test_() {
verify_kzg_proof_batch_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
#[test]
pub fn verify_kzg_proof_batch_fails_with_incorrect_proof_test_() {
verify_kzg_proof_batch_fails_with_incorrect_proof_test::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
#[test]
pub fn test_vectors_blob_to_kzg_commitment_() {
test_vectors_blob_to_kzg_commitment::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
);
}
#[test]
pub fn test_vectors_compute_kzg_proof_() {
test_vectors_compute_kzg_proof::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&compute_kzg_proof_rust,
&bytes_to_blob,
);
}
#[test]
pub fn test_vectors_compute_blob_kzg_proof_() {
test_vectors_compute_blob_kzg_proof::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
);
}
#[test]
pub fn test_vectors_verify_kzg_proof_() {
test_vectors_verify_kzg_proof::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(&load_trusted_setup_filename_rust, &verify_kzg_proof_rust);
}
#[test]
pub fn test_vectors_verify_blob_kzg_proof_() {
test_vectors_verify_blob_kzg_proof::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&verify_blob_kzg_proof_rust,
);
}
#[test]
pub fn test_vectors_verify_blob_kzg_proof_batch_() {
test_vectors_verify_blob_kzg_proof_batch::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&verify_blob_kzg_proof_batch_rust,
);
}
#[test]
pub fn test_vectors_compute_challenge_() {
test_vectors_compute_challenge::<ZFr, ZG1>(&bytes_to_blob, &compute_challenge_rust);
}
#[test]
pub fn expand_root_of_unity_too_long() {
let out = expand_root_of_unity(&ZFr::from_u64_arr(&SCALE2_ROOT_OF_UNITY[1]), 1);
assert!(out.is_err());
}
#[test]
pub fn expand_root_of_unity_too_short() {
let out = expand_root_of_unity(&ZFr::from_u64_arr(&SCALE2_ROOT_OF_UNITY[1]), 3);
assert!(out.is_err());
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/kzg_proofs.rs | zkcrypto/tests/kzg_proofs.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::kzg_proofs::{
commit_to_nil_poly, commit_to_too_long_poly_returns_err, proof_multi, proof_single,
trusted_setup_in_correct_form,
};
use rust_kzg_zkcrypto::eip_7594::ZBackend;
use rust_kzg_zkcrypto::kzg_proofs::generate_trusted_setup;
#[test]
pub fn test_trusted_setup_in_correct_form() {
trusted_setup_in_correct_form::<ZBackend>(&generate_trusted_setup);
}
#[test]
fn proof_single_() {
proof_single::<ZBackend>(&generate_trusted_setup);
}
#[test]
fn commit_to_nil_poly_() {
commit_to_nil_poly::<ZBackend>(&generate_trusted_setup);
}
#[test]
fn commit_to_too_long_poly_() {
commit_to_too_long_poly_returns_err::<ZBackend>(&generate_trusted_setup);
}
#[test]
fn proof_multi_() {
proof_multi::<ZBackend>(&generate_trusted_setup);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/eip_7594.rs | zkcrypto/tests/eip_7594.rs | #[cfg(test)]
mod tests {
use kzg::eip_4844::bytes_to_blob;
use kzg_bench::tests::eip_7594::{
test_vectors_compute_cells, test_vectors_compute_cells_and_kzg_proofs,
test_vectors_compute_verify_cell_kzg_proof_batch_challenge,
test_vectors_recover_cells_and_kzg_proofs, test_vectors_verify_cell_kzg_proof_batch,
};
use rust_kzg_zkcrypto::{eip_4844::load_trusted_setup_filename_rust, eip_7594::ZBackend};
#[test]
pub fn test_vectors_compute_cells_() {
test_vectors_compute_cells::<ZBackend>(&load_trusted_setup_filename_rust, &bytes_to_blob);
}
#[test]
pub fn test_vectors_compute_cells_and_kzg_proofs_() {
test_vectors_compute_cells_and_kzg_proofs::<ZBackend>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
);
}
#[test]
pub fn test_vectors_recover_cells_and_kzg_proofs_() {
test_vectors_recover_cells_and_kzg_proofs::<ZBackend>(&load_trusted_setup_filename_rust);
}
#[test]
pub fn test_vectors_verify_cell_kzg_proof_batch_() {
test_vectors_verify_cell_kzg_proof_batch::<ZBackend>(&load_trusted_setup_filename_rust);
}
#[test]
pub fn test_vectors_compute_verify_cell_kzg_proof_batch_challenge_() {
test_vectors_compute_verify_cell_kzg_proof_batch_challenge::<ZBackend>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/poly.rs | zkcrypto/tests/poly.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::poly::{
create_poly_of_length_ten, poly_div_by_zero, poly_div_fast_test, poly_div_long_test,
poly_div_random, poly_eval_0_check, poly_eval_check, poly_eval_nil_check,
poly_inverse_simple_0, poly_inverse_simple_1, poly_mul_direct_test, poly_mul_fft_test,
poly_mul_random, poly_test_div,
};
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
use rust_kzg_zkcrypto::poly::PolyData;
#[test]
fn create_poly_of_length_ten_() {
create_poly_of_length_ten::<ZFr, PolyData>();
}
#[test]
fn poly_eval_check_() {
poly_eval_check::<ZFr, PolyData>();
}
#[test]
fn poly_eval_0_check_() {
poly_eval_0_check::<ZFr, PolyData>();
}
#[test]
fn poly_eval_nil_check_() {
poly_eval_nil_check::<ZFr, PolyData>();
}
#[test]
fn poly_inverse_simple_0_() {
poly_inverse_simple_0::<ZFr, PolyData>();
}
#[test]
fn poly_inverse_simple_1_() {
poly_inverse_simple_1::<ZFr, PolyData>();
}
#[test]
fn poly_test_div_() {
poly_test_div::<ZFr, PolyData>();
}
#[test]
fn poly_div_by_zero_() {
poly_div_by_zero::<ZFr, PolyData>();
}
#[test]
fn poly_mul_direct_test_() {
poly_mul_direct_test::<ZFr, PolyData>();
}
#[test]
fn poly_mul_fft_test_() {
poly_mul_fft_test::<ZFr, PolyData, FFTSettings>();
}
#[test]
fn poly_mul_random_() {
poly_mul_random::<ZFr, PolyData, FFTSettings>();
}
#[test]
fn poly_div_random_() {
poly_div_random::<ZFr, PolyData>();
}
#[test]
fn poly_div_long_test_() {
poly_div_long_test::<ZFr, PolyData>()
}
#[test]
fn poly_div_fast_test_() {
poly_div_fast_test::<ZFr, PolyData>()
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/zero_poly.rs | zkcrypto/tests/zero_poly.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::zero_poly::{
check_test_data, reduce_partials_random, test_reduce_partials, zero_poly_252,
zero_poly_all_but_one, zero_poly_known, zero_poly_random,
};
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
use rust_kzg_zkcrypto::poly::PolyData;
#[test]
fn test_reduce_partials_() {
test_reduce_partials::<ZFr, FFTSettings, PolyData>();
}
#[test]
fn reduce_partials_random_() {
reduce_partials_random::<ZFr, FFTSettings, PolyData>();
}
#[test]
fn check_test_data_() {
check_test_data::<ZFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_known_() {
zero_poly_known::<ZFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_random_() {
zero_poly_random::<ZFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_all_but_one_() {
zero_poly_all_but_one::<ZFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_252_() {
zero_poly_252::<ZFr, FFTSettings, PolyData>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/bls12_381.rs | zkcrypto/tests/bls12_381.rs | #[cfg(test)]
mod tests {
use kzg::common_utils::log_2_byte;
use kzg_bench::tests::bls12_381::*;
use rust_kzg_zkcrypto::fft_g1::g1_linear_combination;
use rust_kzg_zkcrypto::kzg_proofs::pairings_verify;
use rust_kzg_zkcrypto::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1, ZG2};
#[test]
pub fn log_2_byte_works_() {
log_2_byte_works(&log_2_byte);
}
#[test]
pub fn fr_is_zero_works_() {
fr_is_zero_works::<ZFr>();
}
#[test]
pub fn fr_is_one_works_() {
fr_is_one_works::<ZFr>();
}
#[test]
pub fn fr_from_uint64_works_() {
fr_from_uint64_works::<ZFr>();
}
#[test]
pub fn fr_equal_works_() {
fr_equal_works::<ZFr>();
}
#[test]
pub fn fr_negate_works_() {
fr_negate_works::<ZFr>();
}
#[test]
pub fn fr_pow_works_() {
fr_pow_works::<ZFr>();
}
#[test]
pub fn fr_div_works_() {
fr_div_works::<ZFr>();
}
#[test]
#[should_panic]
pub fn fr_div_by_zero_() {
fr_div_by_zero::<ZFr>();
}
#[test]
pub fn fr_uint64s_roundtrip_() {
fr_uint64s_roundtrip::<ZFr>();
}
#[test]
pub fn p1_mul_works_() {
p1_mul_works::<ZFr, ZG1>();
}
#[test]
pub fn p1_sub_works_() {
p1_sub_works::<ZG1>();
}
#[test]
pub fn p1_add_or_dbl_works_() {
p1_add_or_dbl_works::<ZG1>();
}
#[test]
pub fn p1_add_zero_works_() {
p1_add_zero_works::<ZG1>();
}
#[test]
pub fn p2_add_or_dbl_works_() {
p2_add_or_dbl_works::<ZG2>();
}
#[test]
pub fn p2_mul_works_() {
p2_mul_works::<ZFr, ZG2>();
}
#[test]
pub fn p2_sub_works_() {
p2_sub_works::<ZG2>();
}
#[test]
pub fn g1_identity_is_infinity_() {
g1_identity_is_infinity::<ZG1>();
}
#[test]
pub fn g1_identity_is_identity_() {
g1_identity_is_identity::<ZG1>();
}
#[test]
pub fn g1_make_linear_combination_() {
g1_make_linear_combination::<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>(
&g1_linear_combination,
);
}
#[test]
pub fn g1_random_linear_combination_() {
g1_random_linear_combination::<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>(
&g1_linear_combination,
);
}
#[test]
pub fn g1_linear_combination_infinity_points_() {
g1_linear_combination_infinity_points::<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>(
&g1_linear_combination,
);
}
#[test]
pub fn pairings_work_() {
pairings_work::<ZFr, ZG1, ZG2>(&pairings_verify);
}
#[test]
pub fn fr_is_null_works_() {
fr_is_null_works::<ZFr>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/fk20_proofs.rs | zkcrypto/tests/fk20_proofs.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::fk20_proofs::*;
use rust_kzg_zkcrypto::eip_7594::ZBackend;
use rust_kzg_zkcrypto::fk20_proofs::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use rust_kzg_zkcrypto::kzg_proofs::generate_trusted_setup;
#[test]
fn test_fk_single() {
fk_single::<ZBackend, KzgFK20SingleSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_single_strided() {
fk_single_strided::<ZBackend, KzgFK20SingleSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_settings() {
fk_multi_settings::<ZBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_1_512() {
fk_multi_chunk_len_1_512::<ZBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_16_512() {
fk_multi_chunk_len_16_512::<ZBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_16_16() {
fk_multi_chunk_len_16_16::<ZBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/fft_g1.rs | zkcrypto/tests/fft_g1.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::fft_g1::{compare_sft_fft, roundtrip_fft, stride_fft};
use rust_kzg_zkcrypto::fft_g1::{fft_g1_fast, fft_g1_slow, make_data};
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::{ZFr, ZG1};
#[test]
fn roundtrip_fft_() {
roundtrip_fft::<ZFr, ZG1, FFTSettings>(&make_data);
}
#[test]
fn stride_fft_() {
stride_fft::<ZFr, ZG1, FFTSettings>(&make_data);
}
#[test]
fn compare_sft_fft_() {
compare_sft_fft::<ZFr, ZG1, FFTSettings>(&fft_g1_slow, &fft_g1_fast, &make_data);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/fft_fr.rs | zkcrypto/tests/fft_fr.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::fft_fr::{compare_sft_fft, inverse_fft, roundtrip_fft, stride_fft};
use rust_kzg_zkcrypto::fft::{fft_fr_fast, fft_fr_slow};
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
#[test]
fn compare_sft_fft_() {
compare_sft_fft::<ZFr, FFTSettings>(&fft_fr_slow, &fft_fr_fast);
}
#[test]
fn roundtrip_fft_() {
roundtrip_fft::<ZFr, FFTSettings>();
}
#[test]
fn inverse_fft_() {
inverse_fft::<ZFr, FFTSettings>();
}
#[test]
fn stride_fft_() {
stride_fft::<ZFr, FFTSettings>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/tests/recover.rs | zkcrypto/tests/recover.rs | #[cfg(test)]
mod recover_tests {
use kzg_bench::tests::recover::*;
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr as Fr;
use rust_kzg_zkcrypto::poly::PolyData;
#[test]
fn recover_simple_() {
recover_simple::<Fr, FFTSettings, PolyData, PolyData>();
}
//Could be not working because of zero poly.
#[test]
fn recover_random_() {
recover_random::<Fr, FFTSettings, PolyData, PolyData>();
}
#[test]
fn more_than_half_missing_() {
more_than_half_missing::<Fr, FFTSettings, PolyData, PolyData>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/das.rs | zkcrypto/benches/das.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::das::bench_das_extension;
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
fn bench_das_extension_(c: &mut Criterion) {
bench_das_extension::<ZFr, FFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_das_extension_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/eip_4844.rs | zkcrypto/benches/eip_4844.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg::eip_4844::{
blob_to_kzg_commitment_rust, bytes_to_blob, compute_blob_kzg_proof_rust,
compute_kzg_proof_rust, verify_blob_kzg_proof_batch_rust, verify_blob_kzg_proof_rust,
verify_kzg_proof_rust,
};
use kzg_bench::benches::eip_4844::bench_eip_4844;
use rust_kzg_zkcrypto::eip_4844::load_trusted_setup_filename_rust;
use rust_kzg_zkcrypto::kzg_proofs::{FFTSettings, KZGSettings};
use rust_kzg_zkcrypto::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1, ZG2};
use rust_kzg_zkcrypto::poly::PolyData;
fn bench_eip_4844_(c: &mut Criterion) {
bench_eip_4844::<
ZFr,
ZG1,
ZG2,
PolyData,
FFTSettings,
KZGSettings,
ZFp,
ZG1Affine,
ZG1ProjAddAffine,
>(
c,
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&verify_kzg_proof_rust,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
criterion_group!(benches, bench_eip_4844_,);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/eip_7594.rs | zkcrypto/benches/eip_7594.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg::eip_4844::{blob_to_kzg_commitment_rust, bytes_to_blob};
use kzg_bench::benches::eip_7594::bench_eip_7594;
use rust_kzg_zkcrypto::{eip_4844::load_trusted_setup_filename_rust, eip_7594::ZBackend};
fn bench_eip_7594_(c: &mut Criterion) {
bench_eip_7594::<ZBackend>(
c,
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&blob_to_kzg_commitment_rust,
);
}
criterion_group!(benches, bench_eip_7594_);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/poly.rs | zkcrypto/benches/poly.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::poly::bench_new_poly_div;
use rust_kzg_zkcrypto::kzg_types::ZFr;
use rust_kzg_zkcrypto::poly::PolyData;
fn bench_new_poly_div_(c: &mut Criterion) {
bench_new_poly_div::<ZFr, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_new_poly_div_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/zero_poly.rs | zkcrypto/benches/zero_poly.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::zero_poly::bench_zero_poly;
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
use rust_kzg_zkcrypto::poly::PolyData;
fn bench_zero_poly_(c: &mut Criterion) {
bench_zero_poly::<ZFr, FFTSettings, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_zero_poly_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/kzg.rs | zkcrypto/benches/kzg.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::kzg::{bench_commit_to_poly, bench_compute_proof_single};
use rust_kzg_zkcrypto::eip_7594::ZBackend;
use rust_kzg_zkcrypto::kzg_proofs::generate_trusted_setup;
fn bench_commit_to_poly_(c: &mut Criterion) {
bench_commit_to_poly::<ZBackend>(c, &generate_trusted_setup);
}
fn bench_compute_proof_single_(c: &mut Criterion) {
bench_compute_proof_single::<ZBackend>(c, &generate_trusted_setup);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_commit_to_poly_, bench_compute_proof_single_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/lincomb.rs | zkcrypto/benches/lincomb.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::lincomb::bench_g1_lincomb;
use rust_kzg_zkcrypto::fft_g1::g1_linear_combination;
use rust_kzg_zkcrypto::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1};
fn bench_g1_lincomb_(c: &mut Criterion) {
bench_g1_lincomb::<ZFr, ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine>(c, &g1_linear_combination);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_g1_lincomb_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/fk_20.rs | zkcrypto/benches/fk_20.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fk20::{bench_fk_multi_da, bench_fk_single_da};
use rust_kzg_zkcrypto::eip_7594::ZBackend;
use rust_kzg_zkcrypto::fk20_proofs::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use rust_kzg_zkcrypto::kzg_proofs::generate_trusted_setup;
fn bench_fk_single_da_(c: &mut Criterion) {
bench_fk_single_da::<ZBackend, KzgFK20SingleSettings>(c, &generate_trusted_setup)
}
fn bench_fk_multi_da_(c: &mut Criterion) {
bench_fk_multi_da::<ZBackend, KzgFK20MultiSettings>(c, &generate_trusted_setup)
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fk_single_da_, bench_fk_multi_da_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/recover.rs | zkcrypto/benches/recover.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::recover::bench_recover;
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::ZFr;
use rust_kzg_zkcrypto::poly::PolyData;
fn bench_recover_(c: &mut Criterion) {
bench_recover::<ZFr, FFTSettings, PolyData, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_recover_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/zkcrypto/benches/fft.rs | zkcrypto/benches/fft.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fft::{bench_fft_fr, bench_fft_g1};
use rust_kzg_zkcrypto::kzg_proofs::FFTSettings;
use rust_kzg_zkcrypto::kzg_types::{ZFr, ZG1};
fn bench_fft_fr_(c: &mut Criterion) {
bench_fft_fr::<ZFr, FFTSettings>(c);
}
fn bench_fft_g1_(c: &mut Criterion) {
bench_fft_g1::<ZFr, ZG1, FFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fft_fr_, bench_fft_g1_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark/build.rs | arkworks3-sppark/build.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use std::env;
use std::path::PathBuf;
fn main() {
// account for cross-compilation [by examining environment variable]
let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
// Set CC environment variable to choose alternative C compiler.
// Optimization level depends on whether or not --release is passed
// or implied.
let mut cc = cc::Build::new();
let c_src_dir = PathBuf::from("src");
let files = vec![c_src_dir.join("lib.c")];
let mut cc_opt = None;
match (cfg!(feature = "portable"), cfg!(feature = "force-adx")) {
(true, false) => {
println!("Compiling in portable mode without ISA extensions");
cc_opt = Some("__BLST_PORTABLE__");
}
(false, true) => {
if target_arch.eq("x86_64") {
println!("Enabling ADX support via `force-adx` feature");
cc_opt = Some("__ADX__");
} else {
println!("`force-adx` is ignored for non-x86_64 targets");
}
}
(false, false) =>
{
#[cfg(target_arch = "x86_64")]
if target_arch.eq("x86_64") && std::is_x86_feature_detected!("adx") {
println!("Enabling ADX because it was detected on the host");
cc_opt = Some("__ADX__");
}
}
(true, true) => panic!("Cannot compile with both `portable` and `force-adx` features"),
}
cc.flag_if_supported("-mno-avx") // avoid costly transitions
.flag_if_supported("-fno-builtin")
.flag_if_supported("-Wno-unused-command-line-argument");
if !cfg!(debug_assertions) {
cc.opt_level(2);
}
if let Some(def) = cc_opt {
cc.define(def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
cc.include(include);
}
cc.files(&files).compile("msm_cuda");
if cfg!(target_os = "windows") && !cfg!(target_env = "msvc") {
return;
}
// Detect if there is CUDA compiler and engage "cuda" feature accordingly
let nvcc = match env::var("NVCC") {
Ok(var) => which::which(var),
Err(_) => which::which("nvcc"),
};
if nvcc.is_ok() {
let mut nvcc = cc::Build::new();
nvcc.cuda(true);
nvcc.flag("-arch=sm_80");
nvcc.flag("-gencode").flag("arch=compute_70,code=sm_70");
nvcc.flag("-t0");
if cfg!(feature = "quiet") {
nvcc.flag("-diag-suppress=177"); // bug in the warning system.
}
#[cfg(not(target_env = "msvc"))]
nvcc.flag("-Xcompiler").flag("-Wno-unused-function");
nvcc.define("TAKE_RESPONSIBILITY_FOR_ERROR_MESSAGE", None);
if let Some(def) = cc_opt {
nvcc.define(def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_ROOT") {
nvcc.include(include);
}
nvcc.file("cuda/pippenger.cu").compile("blst_cuda_msm");
println!("cargo:rustc-cfg=feature=\"cuda\"");
println!("cargo:rerun-if-changed=cuda");
println!("cargo:rerun-if-env-changed=CXXFLAGS");
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark/src/lib.rs | arkworks3-sppark/src/lib.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use ark_bls12_381::{Fr, G1Affine, G1Projective, G2Affine, G2Projective};
use ark_ec::AffineCurve;
use ark_ff::PrimeField;
use ark_std::Zero;
use std::ffi::c_void;
pub fn prepare_multi_scalar_mult<G: AffineCurve>(points: &[G]) -> *mut c_void {
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn prepare_msm(
points: *const G1Affine,
npoints: usize,
ffi_affine_sz: usize,
) -> *mut c_void;
}
let npoints = points.len();
unsafe {
prepare_msm(
points.as_ptr() as *const _,
npoints,
std::mem::size_of::<G>(),
)
}
}
pub fn multi_scalar_mult_prepared<G: AffineCurve>(
msm: *mut c_void,
scalars: &[<G::ScalarField as PrimeField>::BigInt],
) -> G::Projective {
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn mult_pippenger_prepared(
msm: *mut c_void,
out: *mut G1Projective,
npoints: usize,
scalars: *const Fr,
) -> sppark::Error;
}
let npoints = scalars.len();
let mut ret = G::Projective::zero();
let err = unsafe {
mult_pippenger_prepared(
msm,
&mut ret as *mut _ as *mut _,
npoints,
scalars.as_ptr() as *const _,
)
};
if err.code != 0 {
panic!("{}", String::from(err));
}
ret
}
pub fn multi_scalar_mult<G: AffineCurve>(
points: &[G],
scalars: &[<G::ScalarField as PrimeField>::BigInt],
) -> G::Projective {
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn mult_pippenger(
out: *mut G1Projective,
points: *const G1Affine,
npoints: usize,
scalars: *const Fr,
ffi_affine_sz: usize,
) -> sppark::Error;
}
let npoints = points.len();
if npoints != scalars.len() {
panic!("length mismatch")
}
let mut ret = G::Projective::zero();
let err = unsafe {
mult_pippenger(
&mut ret as *mut _ as *mut _,
points.as_ptr() as *const _,
npoints,
scalars.as_ptr() as *const _,
std::mem::size_of::<G>(),
)
};
if err.code != 0 {
panic!("{}", String::from(err));
}
ret
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark/benches/lincomb.rs | arkworks3-sppark/benches/lincomb.rs | use blst::{blst_fr, blst_p1_affine, blst_scalar, blst_scalar_from_fr};
use criterion::{criterion_group, criterion_main, Criterion};
use kzg::Fr;
use kzg::G1;
use rust_kzg_blst::types::fp::FsFp;
use rust_kzg_blst::types::fr::FsFr;
use rust_kzg_blst::types::g1::{FsG1, FsG1Affine};
extern crate alloc;
fn bench_g1_lincomb(c: &mut Criterion) {
const NUM_POINTS: usize = 1usize << 21;
let points = (0..NUM_POINTS)
.into_iter()
.map(|_| FsG1::rand())
.collect::<Vec<_>>();
let scalars = (0..NUM_POINTS)
.into_iter()
.map(|_| FsFr::rand())
.collect::<Vec<_>>();
let affines = kzg::msm::msm_impls::batch_convert::<FsG1, FsFp, FsG1Affine>(&points);
let scalars =
unsafe { alloc::slice::from_raw_parts(scalars.as_ptr() as *const blst_fr, scalars.len()) };
let affines = unsafe {
alloc::slice::from_raw_parts(affines.as_ptr() as *const blst_p1_affine, affines.len())
};
let id = format!("bench_g1_lincomb points: '{}'", NUM_POINTS);
c.bench_function(&id, |b| {
b.iter(|| {
rust_kzg_blst_sppark::multi_scalar_mult(&affines, &scalars);
})
});
let msm = rust_kzg_blst_sppark::prepare_multi_scalar_mult(&affines);
let id = format!("bench_g1_lincomb points (prepared, mont): '{}'", NUM_POINTS);
c.bench_function(&id, |b| {
b.iter(|| {
rust_kzg_blst_sppark::multi_scalar_mult_prepared(msm, &scalars);
})
});
}
criterion_group! {
name = benches;
config = Criterion::default()/*.sample_size(100)*/;
targets = bench_g1_lincomb
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_balance.rs | tests/integration/test_balance.rs | use serde_json::json;
use starknet_rs_core::types::Felt;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{PREDEPLOYED_ACCOUNT_ADDRESS, PREDEPLOYED_ACCOUNT_INITIAL_BALANCE};
use crate::common::utils::FeeUnit;
#[tokio::test]
async fn getting_balance_of_predeployed_contract() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
for unit in [FeeUnit::Fri, FeeUnit::Wei] {
let balance = devnet.get_balance_latest(&contract_address, unit).await.unwrap();
assert_eq!(balance, Felt::from(PREDEPLOYED_ACCOUNT_INITIAL_BALANCE));
}
}
#[tokio::test]
/// Tests the same logic that is used by BackgroundDevnet::get_balance
async fn assert_balance_endpoint_response() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
for (address, expected_balance) in [
("0x123", "0"), // dummy address expected to have no balance
(PREDEPLOYED_ACCOUNT_ADDRESS, PREDEPLOYED_ACCOUNT_INITIAL_BALANCE.to_string().as_str()),
] {
for unit in ["WEI", "FRI"] {
let json_resp: serde_json::Value = devnet
.send_custom_rpc(
"devnet_getAccountBalance",
json!({ "address": address, "unit": unit }),
)
.await
.unwrap();
assert_eq!(json_resp["unit"], unit);
assert_eq!(json_resp["amount"], expected_balance);
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_restart.rs | tests/integration/test_restart.rs | use std::path::Path;
use std::sync::Arc;
use starknet_rs_accounts::{
Account, AccountFactory, ExecutionEncoding, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{BlockId, BlockTag, Felt, StarknetError};
use starknet_rs_core::utils::get_storage_var_address;
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_0_ACCOUNT_CONTRACT_HASH, CHAIN_ID, STRK_ERC20_CONTRACT_ADDRESS,
};
use crate::common::utils::{
FeeUnit, assert_tx_succeeded_accepted, get_deployable_account_signer,
get_simple_contract_artifacts, remove_file, send_ctrl_c_signal_and_wait,
};
#[tokio::test]
async fn assert_restartable() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
devnet.restart().await;
}
#[tokio::test]
async fn assert_tx_and_block_not_present_after_restart() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// generate dummy tx
let mint_hash = devnet.mint(Felt::ONE, 100).await;
assert!(devnet.json_rpc_client.get_transaction_by_hash(mint_hash).await.is_ok());
devnet.restart().await;
match devnet.json_rpc_client.get_transaction_by_hash(mint_hash).await {
Err(ProviderError::StarknetError(StarknetError::TransactionHashNotFound)) => (),
other => panic!("Unexpected result: {other:?}"),
}
match devnet.json_rpc_client.get_block_with_txs(BlockId::Number(1)).await {
Err(ProviderError::StarknetError(StarknetError::BlockNotFound)) => (),
other => panic!("Unexpected result: {other:?}"),
}
}
#[tokio::test]
async fn assert_storage_restarted() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// change storage
let dummy_address = Felt::ONE;
let mint_amount = 100;
devnet.mint(dummy_address, mint_amount).await;
// define storage retriever
let storage_key = get_storage_var_address("ERC20_balances", &[dummy_address]).unwrap();
let get_storage = || {
devnet.json_rpc_client.get_storage_at(
STRK_ERC20_CONTRACT_ADDRESS,
storage_key,
BlockId::Tag(BlockTag::Latest),
)
};
let storage_value_before = get_storage().await.unwrap();
assert_eq!(storage_value_before, Felt::from(mint_amount));
devnet.restart().await;
let storage_value_after = get_storage().await.unwrap();
assert_eq!(storage_value_after, Felt::ZERO);
}
#[tokio::test]
async fn assert_account_deployment_reverted() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// deploy new account
let account_signer = get_deployable_account_signer();
let account_factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
CHAIN_ID,
account_signer.clone(),
devnet.clone_provider(),
)
.await
.unwrap();
let salt = Felt::ONE;
let deployment = account_factory.deploy_v3(salt).l1_gas(0).l1_data_gas(1000).l2_gas(1e7 as u64);
let deployment_address = deployment.address();
devnet.mint(deployment_address, 1e21 as u128).await;
let deployment_tx = deployment.send().await.unwrap();
// assert deployment successful and class associated with deployment address is present
assert_tx_succeeded_accepted(&deployment_tx.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
devnet
.json_rpc_client
.get_class_at(BlockId::Tag(BlockTag::Latest), deployment_address)
.await
.unwrap();
devnet.restart().await;
// expect ContractNotFound error since account not present anymore
match devnet
.json_rpc_client
.get_class_at(BlockId::Tag(BlockTag::Latest), deployment_address)
.await
{
Err(ProviderError::StarknetError(StarknetError::ContractNotFound)) => (),
other => panic!("Invalid response: {other:?}"),
}
}
#[tokio::test]
async fn assert_gas_price_unaffected_by_restart() {
let expected_l1_gas_price = 1_000_000_u64;
let expected_l2_gas_price = 2_000_000_u64;
let expected_data_gas_price = 3_000_000_u64;
// assert difference to ensure values don't get mixed up in the logic
assert_ne!(expected_l1_gas_price, expected_data_gas_price);
let devnet_args = [
"--gas-price-fri",
&expected_l1_gas_price.to_string(),
"--l2-gas-price-fri",
&expected_l2_gas_price.to_string(),
"--data-gas-price-fri",
&expected_data_gas_price.to_string(),
];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
// get a predeployed account
let (signer, address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
));
// get class
let (contract_artifact, casm_hash) = get_simple_contract_artifacts();
let contract_artifact = Arc::new(contract_artifact);
// check gas price via fee estimation
let estimate_before = predeployed_account
.declare_v3(contract_artifact.clone(), casm_hash)
.estimate_fee()
.await
.unwrap();
assert_eq!(estimate_before.l1_gas_price, expected_l1_gas_price.into());
assert_eq!(estimate_before.l2_gas_price, expected_l2_gas_price.into());
assert_eq!(estimate_before.l1_data_gas_price, expected_data_gas_price.into());
devnet.restart().await;
let estimate_after =
predeployed_account.declare_v3(contract_artifact, casm_hash).estimate_fee().await.unwrap();
// assert gas_price and fee are equal to the values before restart
assert_eq!(estimate_after.l1_gas_price, expected_l1_gas_price.into());
assert_eq!(estimate_after.l2_gas_price, expected_l2_gas_price.into());
assert_eq!(estimate_after.l1_data_gas_price, expected_data_gas_price.into());
assert_eq!(estimate_before.overall_fee, estimate_after.overall_fee);
}
#[tokio::test]
async fn assert_predeployed_account_is_prefunded_after_restart() {
let initial_balance = 1_000_000_u32;
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--initial-balance",
&initial_balance.to_string(),
])
.await
.unwrap();
let predeployed_account_address = devnet.get_first_predeployed_account().await.1;
let balance_before =
devnet.get_balance_latest(&predeployed_account_address, FeeUnit::Wei).await.unwrap();
assert_eq!(balance_before, Felt::from(initial_balance));
devnet.restart().await;
let balance_after =
devnet.get_balance_latest(&predeployed_account_address, FeeUnit::Wei).await.unwrap();
assert_eq!(balance_before, balance_after);
}
#[tokio::test]
async fn assert_dumping_not_affected_by_restart() {
let dump_file_name = "dump_after_restart";
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
dump_file_name,
"--dump-on",
"exit",
])
.await
.unwrap();
devnet.restart().await;
// send a dummy tx; otherwise there's no dump
devnet.mint(Felt::ONE, 1).await;
// assert dump file not already here
assert!(!Path::new(dump_file_name).exists());
// assert killing the process can still dump devnet
send_ctrl_c_signal_and_wait(&devnet.process).await;
assert!(Path::new(dump_file_name).exists());
remove_file(dump_file_name);
}
#[tokio::test]
async fn assert_load_not_affecting_restart() {
let dump_file_name = "dump_before_restart";
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
dump_file_name,
"--dump-on",
"exit",
])
.await
.unwrap();
// send a dummy tx; otherwise there's no dump
let tx_hash = devnet.mint(Felt::ONE, 1).await;
send_ctrl_c_signal_and_wait(&devnet.process).await;
assert!(Path::new(dump_file_name).exists());
let loaded_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--dump-path", dump_file_name])
.await
.unwrap();
loaded_devnet.restart().await;
// asserting that restarting really clears the state, without re-executing txs from dump
match loaded_devnet.json_rpc_client.get_transaction_by_hash(tx_hash).await {
Err(ProviderError::StarknetError(StarknetError::TransactionHashNotFound)) => (),
other => panic!("Unexpected result: {other:?}"),
}
remove_file(dump_file_name);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_simulate_transactions.rs | tests/integration/test_simulate_transactions.rs | use std::sync::Arc;
use serde_json::json;
use starknet_core::constants::STRK_ERC20_CONTRACT_ADDRESS;
use starknet_rs_accounts::{
Account, AccountError, AccountFactory, ConnectedAccount, ExecutionEncoder, ExecutionEncoding,
OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{
BlockId, BlockTag, BroadcastedDeclareTransactionV3, BroadcastedDeployAccountTransactionV3,
BroadcastedInvokeTransactionV3, BroadcastedTransaction, Call, ContractExecutionError,
DataAvailabilityMode, ExecuteInvocation, Felt, FunctionCall, InvokeTransactionTrace,
MaybePreConfirmedBlockWithTxHashes, ResourceBounds, ResourceBoundsMapping,
SimulatedTransaction, SimulationFlag, StarknetError, TransactionExecutionErrorData,
TransactionTrace,
};
use starknet_rs_core::utils::{
UdcUniqueness, cairo_short_string_to_felt, get_selector_from_name, get_udc_deployed_address,
};
use starknet_rs_providers::{Provider, ProviderError};
use starknet_rs_signers::{LocalWallet, Signer, SigningKey};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, CAIRO_1_CONTRACT_PATH,
CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH, CAIRO_1_VERSION_ASSERTER_SIERRA_PATH, CHAIN_ID,
ETH_ERC20_CONTRACT_ADDRESS, QUERY_VERSION_OFFSET, UDC_CONTRACT_ADDRESS,
};
use crate::common::fees::{assert_difference_if_validation, assert_fee_in_resp_at_least_equal};
use crate::common::utils::{
LocalFee, assert_contains, declare_v3_deploy_v3, get_deployable_account_signer,
get_flattened_sierra_contract_and_casm_hash, get_simple_contract_artifacts, iter_to_hex_felt,
new_contract_factory, to_hex_felt, to_num_as_hex,
};
#[tokio::test]
async fn simulate_declare_v3() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
CHAIN_ID,
ExecutionEncoding::New,
);
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_CONTRACT_PATH);
let nonce = Felt::ZERO;
let declaration = account.declare_v3(Arc::new(flattened_contract_artifact.clone()), casm_hash);
let fee = LocalFee::from(declaration.estimate_fee().await.unwrap());
let declaration = declaration
.l1_gas(fee.l1_gas)
.l1_gas_price(fee.l1_gas_price)
.l2_gas(fee.l2_gas)
.l2_gas_price(fee.l2_gas_price)
.l1_data_gas(fee.l1_data_gas)
.l1_data_gas_price(fee.l1_data_gas_price)
.nonce(nonce)
.tip(0)
.prepared()
.unwrap();
let declaration_hash = declaration.transaction_hash(false);
let signature = signer.sign_hash(&declaration_hash).await.unwrap();
let sender_address_hex = to_hex_felt(&account_address);
let get_params = |simulation_flags: &[&str]| -> serde_json::Value {
json!({
"block_id": "latest",
"simulation_flags": simulation_flags,
"transactions": [
{
"type": "DECLARE",
"sender_address": sender_address_hex,
"compiled_class_hash": to_hex_felt(&casm_hash),
"version": "0x3",
"signature": iter_to_hex_felt(&[signature.r, signature.s]),
"nonce": to_num_as_hex(&nonce),
"contract_class": flattened_contract_artifact,
"resource_bounds": ResourceBoundsMapping::from(fee),
"tip": "0x0",
"paymaster_data": [],
"account_deployment_data":[],
"nonce_data_availability_mode":"L1",
"fee_data_availability_mode":"L1",
}
]
})
};
let resp_no_flags = &devnet
.send_custom_rpc("starknet_simulateTransactions", get_params(&["SKIP_FEE_CHARGE"]))
.await
.unwrap()[0];
let resp_skip_validation = &devnet
.send_custom_rpc(
"starknet_simulateTransactions",
get_params(&["SKIP_VALIDATE", "SKIP_FEE_CHARGE"]),
)
.await
.unwrap()[0];
assert_difference_if_validation(resp_no_flags, resp_skip_validation, &sender_address_hex, true);
}
#[tokio::test]
async fn simulate_deploy_account() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// define the key of the new account - dummy value
let new_account_signer = get_deployable_account_signer();
let account_factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH),
CHAIN_ID,
new_account_signer.clone(),
devnet.clone_provider(),
)
.await
.unwrap();
let nonce = Felt::ZERO;
let salt_hex = "0x123";
let deployment = account_factory.deploy_v3(Felt::from_hex_unchecked(salt_hex));
let fee = LocalFee::from(deployment.estimate_fee().await.unwrap());
let deployment = deployment
.nonce(nonce)
.l1_gas(fee.l1_gas)
.l1_gas_price(fee.l1_gas_price)
.l2_gas_price(fee.l2_gas_price)
.l2_gas(fee.l2_gas)
.l1_data_gas(fee.l1_data_gas)
.l1_data_gas_price(fee.l1_data_gas_price)
.tip(0)
.prepared()
.unwrap();
let deployment_tx_hash = deployment.transaction_hash(false);
let signature = new_account_signer.sign_hash(&deployment_tx_hash).await.unwrap();
let signature_hex: Vec<String> = iter_to_hex_felt(&[signature.r, signature.s]);
let account_public_key = new_account_signer.get_public_key().await.unwrap().scalar();
let get_params = |simulation_flags: &[&str]| -> serde_json::Value {
json!({
"block_id": "latest",
"simulation_flags": simulation_flags,
"transactions": [
{
"type": "DEPLOY_ACCOUNT",
"version": "0x3",
"signature": signature_hex,
"nonce": to_num_as_hex(&nonce),
"contract_address_salt": salt_hex,
"constructor_calldata": [to_hex_felt(&account_public_key)],
"class_hash": CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH,
"resource_bounds": ResourceBoundsMapping::from(fee),
"tip": "0x0",
"paymaster_data": [],
"nonce_data_availability_mode":"L1",
"fee_data_availability_mode":"L1",
}
]
})
};
let account_address = deployment.address();
let account_address_hex = to_hex_felt(&account_address);
devnet.mint(account_address, 1e18 as u128).await;
// no flags
let params_no_flags = get_params(&[]);
let resp_no_flags =
&devnet.send_custom_rpc("starknet_simulateTransactions", params_no_flags).await.unwrap()[0];
let no_flags_trace = &resp_no_flags["transaction_trace"];
assert_eq!(
no_flags_trace["validate_invocation"]["contract_address"].as_str().unwrap(),
account_address_hex
);
assert_eq!(
Felt::from_hex_unchecked(
no_flags_trace["fee_transfer_invocation"]["contract_address"].as_str().unwrap()
),
STRK_ERC20_CONTRACT_ADDRESS
);
assert_eq!(
no_flags_trace["constructor_invocation"]["contract_address"].as_str().unwrap(),
account_address_hex
);
// skipped validation
let params_skip_validation = get_params(&["SKIP_VALIDATE"]);
let resp_skip_validation = &devnet
.send_custom_rpc("starknet_simulateTransactions", params_skip_validation)
.await
.unwrap()[0];
let skip_validation_trace = &resp_skip_validation["transaction_trace"];
assert!(skip_validation_trace["validate_invocation"].as_object().is_none());
assert_eq!(
Felt::from_hex_unchecked(
skip_validation_trace["fee_transfer_invocation"]["contract_address"].as_str().unwrap()
),
STRK_ERC20_CONTRACT_ADDRESS
);
assert_eq!(
skip_validation_trace["constructor_invocation"]["contract_address"].as_str().unwrap(),
account_address_hex
);
assert_fee_in_resp_at_least_equal(resp_no_flags, resp_skip_validation);
// skipped validation and fee charging (everything)
let params_skip_everything = get_params(&["SKIP_VALIDATE", "SKIP_FEE_CHARGE"]);
let resp_skip_everything = &devnet
.send_custom_rpc("starknet_simulateTransactions", params_skip_everything)
.await
.unwrap()[0];
let skip_everything_trace = &resp_skip_everything["transaction_trace"];
assert!(skip_everything_trace["validate_invocation"].as_object().is_none());
assert!(skip_everything_trace["fee_transfer_invocation"].as_object().is_none());
assert_eq!(
skip_everything_trace["constructor_invocation"]["contract_address"].as_str().unwrap(),
account_address_hex
);
}
#[tokio::test]
async fn simulate_invoke_v3() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
// get class
let (contract_artifact, casm_hash) = get_simple_contract_artifacts();
let contract_artifact = Arc::new(contract_artifact);
let class_hash = contract_artifact.class_hash();
// declare class
let declaration_result = account.declare_v3(contract_artifact, casm_hash).send().await.unwrap();
assert_eq!(declaration_result.class_hash, class_hash);
// deploy instance of class
let contract_factory = new_contract_factory(class_hash, account.clone());
let salt = Felt::from_hex_unchecked("0x123");
let constructor_calldata = vec![Felt::ZERO];
let contract_address = get_udc_deployed_address(
salt,
class_hash,
&UdcUniqueness::NotUnique,
&constructor_calldata,
);
contract_factory.deploy_v3(constructor_calldata, salt, false).send().await.unwrap();
// prepare the call used in simulation
let calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![Felt::from(100u128), Felt::ZERO], // increase amount
}];
// TODO fails if gas bounds too low, can be used to test reverted case
let nonce = Felt::TWO; // after declare+deploy
let execution = account.execute_v3(calls.clone());
let fee = LocalFee::from(execution.estimate_fee().await.unwrap());
let invoke_request = execution
.l1_gas(fee.l1_gas)
.l1_gas_price(fee.l1_gas_price)
.l1_data_gas(fee.l1_data_gas)
.l1_data_gas_price(fee.l1_data_gas_price)
.l2_gas(fee.l2_gas)
.l2_gas_price(fee.l2_gas_price)
.nonce(nonce)
.tip(0)
.prepared()
.unwrap();
let signature = signer.sign_hash(&invoke_request.transaction_hash(false)).await.unwrap();
let sender_address_hex = to_hex_felt(&account.address());
let get_params = |simulation_flags: &[&str]| -> serde_json::Value {
json!({
"block_id": "latest",
"simulation_flags": simulation_flags,
"transactions": [
{
"type": "INVOKE",
"version": "0x3",
"signature": iter_to_hex_felt(&[signature.r, signature.s]),
"nonce": nonce,
"calldata": iter_to_hex_felt(&account.encode_calls(&calls)),
"sender_address": sender_address_hex,
"resource_bounds": ResourceBoundsMapping::from(fee),
"tip":"0x0",
"paymaster_data":[],
"account_deployment_data":[],
"nonce_data_availability_mode":"L1",
"fee_data_availability_mode":"L1"
}
]
})
};
let params_no_flags = get_params(&[]);
let resp_no_flags =
&devnet.send_custom_rpc("starknet_simulateTransactions", params_no_flags).await.unwrap()[0];
assert_eq!(
resp_no_flags["transaction_trace"]["execute_invocation"]["contract_address"],
sender_address_hex
);
let params_skip_validation = get_params(&["SKIP_VALIDATE"]);
let resp_skip_validation = &devnet
.send_custom_rpc("starknet_simulateTransactions", params_skip_validation)
.await
.unwrap()[0];
assert_eq!(
resp_skip_validation["transaction_trace"]["execute_invocation"]["contract_address"],
sender_address_hex
);
assert_difference_if_validation(
resp_no_flags,
resp_skip_validation,
&sender_address_hex,
false, // skip fee
);
// assert simulations haven't changed the balance property
let final_balance = devnet
.json_rpc_client
.call(
FunctionCall {
contract_address,
entry_point_selector: get_selector_from_name("get_balance").unwrap(),
calldata: vec![],
},
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap();
assert_eq!(final_balance, vec![Felt::ZERO]);
}
#[tokio::test]
async fn using_query_version_if_simulating() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
CHAIN_ID,
ExecutionEncoding::New,
);
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_VERSION_ASSERTER_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
let (generated_class_hash, contract_address) =
declare_v3_deploy_v3(&account, flattened_contract_artifact, casm_hash, &[]).await.unwrap();
assert_eq!(generated_class_hash, class_hash);
let calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("assert_version").unwrap(),
calldata: vec![QUERY_VERSION_OFFSET + Felt::THREE], // expected version
}];
let execution = account.execute_v3(calls.clone());
let fee = LocalFee::from(execution.estimate_fee().await.unwrap());
let nonce = Felt::TWO; // after declare+deploy
let invoke_request = execution
.l1_data_gas(fee.l1_data_gas)
.l1_gas(fee.l1_gas)
.l1_data_gas_price(fee.l1_data_gas_price)
.l1_gas_price(fee.l1_gas_price)
.l2_gas(fee.l2_gas)
.l2_gas_price(fee.l2_gas_price)
.nonce(nonce)
.tip(0)
.prepared()
.unwrap();
let signature = signer.sign_hash(&invoke_request.transaction_hash(false)).await.unwrap();
let invoke_simulation_body = json!({
"block_id": "latest",
"simulation_flags": [],
"transactions": [
{
"type": "INVOKE",
"version": "0x3",
"signature": [signature.r, signature.s],
"nonce": nonce,
"calldata": account.encode_calls(&calls),
"sender_address": account.address(),
"resource_bounds": ResourceBoundsMapping::from(fee),
"tip":"0x0",
"paymaster_data":[],
"account_deployment_data":[],
"nonce_data_availability_mode":"L1",
"fee_data_availability_mode":"L1"
}
]
});
devnet.send_custom_rpc("starknet_simulateTransactions", invoke_simulation_body).await.unwrap();
}
#[tokio::test]
async fn test_simulation_of_panicking_invoke() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
starknet_rs_accounts::ExecutionEncoding::New,
);
let (contract_class, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let (_, contract_address) =
declare_v3_deploy_v3(&account, contract_class, casm_hash, &[]).await.unwrap();
let top_selector = get_selector_from_name("create_panic").unwrap();
let panic_message_text = "funny_text";
let panic_message = cairo_short_string_to_felt(panic_message_text).unwrap();
let calls =
vec![Call { to: contract_address, selector: top_selector, calldata: vec![panic_message] }];
let block = devnet
.json_rpc_client
.get_block_with_tx_hashes(BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
let gas_price = match block {
starknet_rs_core::types::MaybePreConfirmedBlockWithTxHashes::Block(latest) => {
latest.l2_gas_price.price_in_fri
}
MaybePreConfirmedBlockWithTxHashes::PreConfirmedBlock(pre_confirmed) => {
pre_confirmed.l2_gas_price.price_in_fri
}
};
let gas_price = u128::from_le_bytes(gas_price.to_bytes_le()[..16].try_into().unwrap());
let nonce = Felt::TWO; // after declare + deploy
let simulation = account
.execute_v3(calls)
.nonce(nonce)
.l1_data_gas_price(gas_price)
.l1_gas_price(gas_price)
.l2_gas_price(gas_price)
.l1_gas(0)
.l1_data_gas(1e3 as u64)
.l2_gas(1e8 as u64)
.simulate(false, false)
.await
.unwrap();
match simulation.transaction_trace {
TransactionTrace::Invoke(InvokeTransactionTrace {
execute_invocation: ExecuteInvocation::Reverted(reverted_invocation),
..
}) => {
assert_contains(&reverted_invocation.revert_reason, panic_message_text).unwrap();
}
other_trace => panic!("Unexpected trace {other_trace:?}"),
}
}
#[tokio::test]
async fn simulate_of_multiple_txs_shouldnt_return_an_error_if_invoke_transaction_reverts() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
let estimate_fee_resource_bounds = ResourceBoundsMapping {
l1_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l1_data_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
};
// call non existent method in UDC
let calls = vec![Call {
to: UDC_CONTRACT_ADDRESS,
selector: get_selector_from_name("no_such_method").unwrap(),
calldata: vec![
class_hash,
Felt::from_hex_unchecked("0x123"), // salt
Felt::ZERO,
Felt::ZERO,
],
}];
let calldata = account.encode_calls(&calls);
let is_query = true;
let nonce_data_availability_mode = DataAvailabilityMode::L1;
let fee_data_availability_mode = DataAvailabilityMode::L1;
let simulation_result = devnet
.json_rpc_client
.simulate_transactions(
account.block_id(),
[
BroadcastedTransaction::Declare(BroadcastedDeclareTransactionV3 {
sender_address: account_address,
compiled_class_hash: casm_hash,
signature: vec![],
nonce: Felt::ZERO,
contract_class: Arc::new(flattened_contract_artifact.clone()),
resource_bounds: estimate_fee_resource_bounds.clone(),
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
}),
BroadcastedTransaction::Invoke(BroadcastedInvokeTransactionV3 {
sender_address: account_address,
calldata,
signature: vec![],
nonce: Felt::ONE,
resource_bounds: estimate_fee_resource_bounds,
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
}),
],
[SimulationFlag::SkipValidate, SimulationFlag::SkipFeeCharge],
)
.await
.unwrap();
match &simulation_result[1].transaction_trace {
TransactionTrace::Invoke(InvokeTransactionTrace {
execute_invocation: ExecuteInvocation::Reverted(reverted_invocation),
..
}) => assert_contains(&reverted_invocation.revert_reason, "ENTRYPOINT_NOT_FOUND").unwrap(),
other_trace => panic!("Unexpected trace {:?}", other_trace),
}
}
#[tokio::test]
async fn simulate_of_multiple_txs_should_return_index_of_first_failing_transaction() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
let estimate_fee_resource_bounds = ResourceBoundsMapping {
l1_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l1_data_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
};
// call non existent method in UDC
let calls = vec![Call {
to: UDC_CONTRACT_ADDRESS,
selector: get_selector_from_name("no_such_method").unwrap(),
calldata: vec![
class_hash,
Felt::from_hex_unchecked("0x123"), // salt
Felt::ZERO,
Felt::ZERO,
],
}];
let calldata = account.encode_calls(&calls);
let is_query = true;
let nonce_data_availability_mode = DataAvailabilityMode::L1;
let fee_data_availability_mode = DataAvailabilityMode::L1;
let simulation_err = devnet
.json_rpc_client
.simulate_transactions(
account.block_id(),
[
BroadcastedTransaction::Declare(BroadcastedDeclareTransactionV3 {
sender_address: account_address,
compiled_class_hash: casm_hash,
signature: vec![],
nonce: Felt::ZERO,
contract_class: Arc::new(flattened_contract_artifact.clone()),
resource_bounds: estimate_fee_resource_bounds.clone(),
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
}),
BroadcastedTransaction::Invoke(BroadcastedInvokeTransactionV3 {
sender_address: account_address,
calldata,
signature: vec![],
nonce: Felt::ONE,
resource_bounds: estimate_fee_resource_bounds,
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
}),
],
[],
)
.await
.unwrap_err();
match simulation_err {
ProviderError::StarknetError(StarknetError::TransactionExecutionError(
TransactionExecutionErrorData { transaction_index, .. },
)) => {
assert_eq!(transaction_index, 0);
}
other_error => panic!("Unexpected error {:?}", other_error),
}
}
#[tokio::test]
async fn simulate_with_gas_bounds_exceeding_balance_returns_error_if_charging_not_skipped() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (sierra_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let gas = 1e11 as u64;
let gas_price = 1e11 as u128;
let declaration = account
.declare_v3(Arc::new(sierra_artifact), casm_hash)
.l1_data_gas(gas)
.l2_gas(gas)
.l1_gas(gas)
.l1_gas_price(gas_price)
.l2_gas_price(gas_price)
.l1_data_gas_price(gas_price);
match declaration.simulate(false, false).await.unwrap_err() {
AccountError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(TransactionExecutionErrorData {
execution_error,
..
}),
)) => assert_contains(&format!("{:?}", execution_error), "exceed balance").unwrap(),
other => panic!("Unexpected error {other:?}"),
}
// should not fail because fee transfer is skipped
declaration.simulate(false, true).await.unwrap();
}
#[tokio::test]
async fn simulate_v3_with_skip_fee_charge_deploy_account_declare_deploy_via_invoke_to_udc_happy_path()
{
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--account-class", "cairo1"])
.await
.expect("Could not start Devnet");
let new_account_private_key = Felt::from(7777);
let signer =
LocalWallet::from_signing_key(SigningKey::from_secret_scalar(new_account_private_key));
let latest = BlockId::Tag(BlockTag::Latest);
let public_key = signer.get_public_key().await.unwrap();
let salt = Felt::from_hex_unchecked("0x123");
let account_class_hash = Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH);
let resource_bounds = ResourceBoundsMapping {
l1_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l1_data_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
};
let nonce_data_availability_mode = DataAvailabilityMode::L1;
let fee_data_availability_mode = DataAvailabilityMode::L1;
let is_query = true;
let chain_id = devnet.json_rpc_client.chain_id().await.unwrap();
let paymaster_data = vec![];
let tip = 0;
let account_factory = OpenZeppelinAccountFactory::new(
account_class_hash,
chain_id,
&signer,
&devnet.json_rpc_client,
)
.await
.unwrap();
let nonce = Felt::ZERO;
let account_deployment = account_factory
.deploy_v3(salt)
.nonce(nonce)
.l1_data_gas(0)
.l1_gas(0)
.l2_gas(0)
.l1_data_gas_price(0)
.l2_gas_price(0)
.l1_gas_price(0)
.tip(0);
let account_address = account_deployment.address();
let txn_hash = account_deployment.prepared().unwrap().transaction_hash(is_query);
let signature = signer.sign_hash(&txn_hash).await.unwrap();
let deploy_account_transaction = BroadcastedDeployAccountTransactionV3 {
nonce,
signature: vec![signature.r, signature.s],
contract_address_salt: salt,
constructor_calldata: vec![public_key.scalar()],
class_hash: account_class_hash,
resource_bounds: resource_bounds.clone(),
tip,
paymaster_data: paymaster_data.clone(),
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
};
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
&signer,
account_address,
chain_id,
ExecutionEncoding::New,
);
let (sierra_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let contract_class_hash = sierra_artifact.class_hash();
let nonce = Felt::ONE;
let declare_txn_hash = account
.declare_v3(Arc::new(sierra_artifact.clone()), casm_hash)
.nonce(nonce)
.l1_data_gas(0)
.l1_gas(0)
.l2_gas(0)
.l1_data_gas_price(0)
.l2_gas_price(0)
.l1_gas_price(0)
.tip(0)
.prepared()
.unwrap()
.transaction_hash(is_query);
let declare_signature = signer.sign_hash(&declare_txn_hash).await.unwrap();
let declare_transaction = BroadcastedDeclareTransactionV3 {
sender_address: account_address,
compiled_class_hash: casm_hash,
signature: vec![declare_signature.r, declare_signature.s],
nonce,
contract_class: Arc::new(sierra_artifact),
resource_bounds: resource_bounds.clone(),
tip,
paymaster_data: paymaster_data.clone(),
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
};
// call non existent method in UDC
let calls = vec![Call {
to: UDC_CONTRACT_ADDRESS,
selector: get_selector_from_name("deployContract").unwrap(),
calldata: vec![
contract_class_hash,
Felt::from_hex_unchecked("0x123"), // salt
Felt::ZERO,
Felt::ZERO,
],
}];
let calldata = account.encode_calls(&calls);
let nonce = Felt::TWO;
let invoke_transaction_hash = account
.execute_v3(calls)
.l1_data_gas(0)
.l1_gas(0)
.l2_gas(0)
.l1_data_gas_price(0)
.l2_gas_price(0)
.l1_gas_price(0)
.nonce(nonce)
.tip(0)
.prepared()
.unwrap()
.transaction_hash(is_query);
let invoke_signature = signer.sign_hash(&invoke_transaction_hash).await.unwrap();
let invoke_transaction = BroadcastedInvokeTransactionV3 {
sender_address: account_address,
calldata,
signature: vec![invoke_signature.r, invoke_signature.s],
nonce,
resource_bounds: resource_bounds.clone(),
tip,
paymaster_data: paymaster_data.clone(),
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
};
devnet
.json_rpc_client
.simulate_transactions(
latest,
[
BroadcastedTransaction::DeployAccount(deploy_account_transaction),
BroadcastedTransaction::Declare(declare_transaction),
BroadcastedTransaction::Invoke(invoke_transaction),
],
[SimulationFlag::SkipFeeCharge],
)
.await
.unwrap();
}
#[tokio::test]
async fn simulate_invoke_v3_with_fee_just_below_estimated_should_return_a_trace_of_reverted_transaction()
{
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | true |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_trace.rs | tests/integration/test_trace.rs | use std::sync::Arc;
use starknet_core::constants::{
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, CHARGEABLE_ACCOUNT_ADDRESS, STRK_ERC20_CONTRACT_ADDRESS,
};
use starknet_rs_accounts::{
Account, AccountFactory, ExecutionEncoding, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{
ConfirmedBlockId, DeployedContractItem, ExecuteInvocation, Felt, InvokeTransactionTrace,
StarknetError, TransactionTrace,
};
use starknet_rs_core::utils::{UdcUniqueness, get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
get_deployable_account_signer, get_events_contract_artifacts, new_contract_factory,
};
use crate::{assert_eq_prop, assert_gte_prop};
static DUMMY_ADDRESS: Felt = Felt::from_hex_unchecked("0x7b");
static DUMMY_AMOUNT: u128 = 456;
fn assert_mint_invocation(trace: &TransactionTrace) -> Result<(), anyhow::Error> {
match trace {
TransactionTrace::Invoke(InvokeTransactionTrace {
validate_invocation,
execute_invocation: ExecuteInvocation::Success(execute_invocation),
fee_transfer_invocation,
execution_resources,
..
}) => {
for invocation in [validate_invocation.as_ref().unwrap(), execute_invocation] {
assert_eq_prop!(
invocation.contract_address,
Felt::from_hex_unchecked(CHARGEABLE_ACCOUNT_ADDRESS)
)?;
let expected_calldata = vec![
Felt::ONE, // number of calls
STRK_ERC20_CONTRACT_ADDRESS,
get_selector_from_name("permissioned_mint").unwrap(),
Felt::THREE, // calldata length
DUMMY_ADDRESS,
Felt::from(DUMMY_AMOUNT), // low bytes
Felt::ZERO, // high bytes
];
assert_eq_prop!(invocation.calldata, expected_calldata)?;
}
let fee_transfer_contract_address = fee_transfer_invocation
.as_ref()
.ok_or(anyhow::anyhow!("failed to reference fee transfer invocation"))?
.contract_address;
assert_eq_prop!(fee_transfer_contract_address, STRK_ERC20_CONTRACT_ADDRESS)?;
assert_eq_prop!(execution_resources.l1_gas, 0)?;
assert_gte_prop!(execution_resources.l1_data_gas, 0)?;
assert_gte_prop!(execution_resources.l2_gas, 0)
}
other => anyhow::bail!("Invalid trace: {other:?}"),
}
}
async fn get_invoke_trace(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let mint_tx_hash = devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
devnet.create_block().await?;
let mint_tx_trace = devnet.json_rpc_client.trace_transaction(mint_tx_hash).await?;
assert_mint_invocation(&mint_tx_trace)
}
#[tokio::test]
async fn get_trace_non_existing_transaction() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
match devnet.json_rpc_client.trace_transaction(Felt::ZERO).await {
Err(ProviderError::StarknetError(StarknetError::TransactionHashNotFound)) => (),
other => panic!("Should fail with error; got: {other:?}"),
}
}
#[tokio::test]
async fn get_invoke_trace_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
get_invoke_trace(&devnet).await.unwrap()
}
#[tokio::test]
async fn get_invoke_trace_block_generation_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.expect("Could not start Devnet");
get_invoke_trace(&devnet).await.unwrap()
}
#[tokio::test]
async fn get_declare_trace() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (cairo_1_contract, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await
.unwrap();
let declare_tx_trace = devnet
.json_rpc_client
.trace_transaction(declaration_result.transaction_hash)
.await
.unwrap();
if let TransactionTrace::Declare(declare_trace) = declare_tx_trace {
let validate_invocation = declare_trace.validate_invocation.unwrap();
assert_eq!(validate_invocation.contract_address, account_address);
assert_eq!(
validate_invocation.class_hash,
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH)
);
assert_eq!(
validate_invocation.calldata[0],
Felt::from_hex_unchecked(
"0x113bf26d112a164297e04381212c9bd7409f07591f0a04f539bdf56693eaaf3"
)
);
assert_eq!(
declare_trace.fee_transfer_invocation.unwrap().contract_address,
STRK_ERC20_CONTRACT_ADDRESS
);
} else {
panic!("Could not unpack the transaction trace from {declare_tx_trace:?}");
}
}
#[tokio::test]
async fn test_contract_deployment_trace() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
));
let (cairo_1_contract, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await
.unwrap();
// deploy twice - should result in only 1 instance in deployed_contracts and no declares
let contract_factory = new_contract_factory(declaration_result.class_hash, account.clone());
for salt in (0_u32..2).map(Felt::from) {
let ctor_data = vec![];
let deployment_tx = contract_factory
.deploy_v3(ctor_data.clone(), salt, false)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.expect("Cannot deploy");
let deployment_address = get_udc_deployed_address(
salt,
declaration_result.class_hash,
&UdcUniqueness::NotUnique,
&ctor_data,
);
let deployment_trace =
devnet.json_rpc_client.trace_transaction(deployment_tx.transaction_hash).await.unwrap();
match deployment_trace {
TransactionTrace::Invoke(tx) => {
let state_diff = tx.state_diff.unwrap();
assert_eq!(state_diff.declared_classes, []);
assert_eq!(state_diff.deprecated_declared_classes, []);
assert_eq!(
state_diff.deployed_contracts,
[DeployedContractItem {
address: deployment_address,
class_hash: declaration_result.class_hash
}]
);
}
other => panic!("Invalid trace: {other:?}"),
}
}
}
#[tokio::test]
async fn get_deploy_account_trace() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// define the key of the new account - dummy value
let new_account_signer = get_deployable_account_signer();
let account_factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH),
constants::CHAIN_ID,
new_account_signer.clone(),
devnet.clone_provider(),
)
.await
.unwrap();
// deploy account
let deployment = account_factory
.deploy_v3(Felt::from(0x123))
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.nonce(Felt::ZERO);
let new_account_address = deployment.address();
devnet.mint(new_account_address, u128::MAX).await;
let deployment_result = deployment.send().await.unwrap();
let deployment_hash = deployment_result.transaction_hash;
let deployment_trace = devnet.json_rpc_client.trace_transaction(deployment_hash).await.unwrap();
if let starknet_rs_core::types::TransactionTrace::DeployAccount(deployment_trace) =
deployment_trace
{
let validate_invocation = deployment_trace.validate_invocation.unwrap();
assert_eq!(
validate_invocation.class_hash,
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH)
);
assert_eq!(
validate_invocation.calldata[0],
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH)
);
assert_eq!(
deployment_trace.constructor_invocation.class_hash,
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH)
);
assert_eq!(
deployment_trace.fee_transfer_invocation.unwrap().contract_address,
STRK_ERC20_CONTRACT_ADDRESS
);
} else {
panic!("Could not unpack the transaction trace from {deployment_trace:?}");
}
}
#[tokio::test]
async fn get_traces_from_block() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let mint_tx_hash: Felt = devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let traces =
devnet.json_rpc_client.trace_block_transactions(ConfirmedBlockId::Latest).await.unwrap();
assert_eq!(traces.len(), 1);
let trace = &traces[0];
assert_eq!(trace.transaction_hash, mint_tx_hash);
assert_mint_invocation(&trace.trace_root).unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_deploy.rs | tests/integration/test_deploy.rs | use std::sync::Arc;
use starknet_core::constants::UDC_CONTRACT_CLASS_HASH;
use starknet_rs_accounts::{Account, AccountError, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
Call, ContractExecutionError, Felt, StarknetError, TransactionExecutionErrorData,
};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::ProviderError;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, UDC_CONTRACT_ADDRESS, UDC_LEGACY_CONTRACT_ADDRESS,
};
use crate::common::utils::{
assert_contains, assert_tx_succeeded_accepted, extract_message_error, extract_nested_error,
get_simple_contract_artifacts, new_contract_factory,
};
// Testing of account deployment can be found in test_account_selection.rs
#[tokio::test]
async fn double_deployment_not_allowed() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// declare
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let declaration_result = account
.declare_v3(Arc::new(contract_class), casm_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
// prepare deployment
let contract_factory = new_contract_factory(declaration_result.class_hash, account.clone());
let ctor_args = vec![Felt::ZERO]; // initial value
let salt = Felt::from(10);
let unique = false;
// first deployment should be successful
contract_factory.deploy_v3(ctor_args.clone(), salt, unique).send().await.unwrap();
// second deployment should be unsuccessful
match contract_factory.deploy_v3(ctor_args, salt, unique).send().await {
Err(AccountError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(TransactionExecutionErrorData {
transaction_index: 0,
execution_error: ContractExecutionError::Nested(top_error),
}),
))) => {
assert_eq!(top_error.contract_address, account.address());
assert_eq!(
top_error.class_hash,
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH)
);
assert_eq!(top_error.selector, get_selector_from_name("__execute__").unwrap());
let udc_error = extract_nested_error(&top_error.error).unwrap();
assert_eq!(udc_error.contract_address, UDC_CONTRACT_ADDRESS);
assert_eq!(udc_error.class_hash, UDC_CONTRACT_CLASS_HASH);
assert_eq!(udc_error.selector, get_selector_from_name("deployContract").unwrap());
let undeployed_contract_error = extract_nested_error(&udc_error.error).unwrap();
assert_eq!(undeployed_contract_error.class_hash, declaration_result.class_hash);
assert_eq!(undeployed_contract_error.selector, Felt::ZERO); // constructor
let msg_error = extract_message_error(&undeployed_contract_error.error).unwrap();
assert_contains(msg_error, "contract already deployed").unwrap();
}
other => panic!("Unexpected result: {other:?}"),
};
}
#[tokio::test]
async fn cannot_deploy_undeclared_class() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// skip declaration
let (contract_class, _) = get_simple_contract_artifacts();
// prepare deployment
let contract_factory = new_contract_factory(contract_class.class_hash(), account.clone());
let ctor_args = vec![Felt::ZERO]; // initial value
let salt = Felt::from(10);
let unique = false;
// deployment should fail
match contract_factory.deploy_v3(ctor_args, salt, unique).send().await {
Err(e) => assert_contains(&format!("{e:?}"), "not declared").unwrap(),
other => panic!("Unexpected result: {other:?}"),
};
}
#[tokio::test]
async fn test_all_udc_deployment_methods_supported() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// declare
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let declaration_result = account
.declare_v3(Arc::new(contract_class), casm_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&declaration_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let mut salt = Felt::ONE;
let legacy_deployment_method = "deployContract";
for (udc_address, deployment_method) in [
(UDC_LEGACY_CONTRACT_ADDRESS, legacy_deployment_method),
(UDC_LEGACY_CONTRACT_ADDRESS, legacy_deployment_method),
(UDC_CONTRACT_ADDRESS, "deploy_contract"),
] {
let contract_invoke = vec![Call {
to: udc_address,
selector: get_selector_from_name(deployment_method).unwrap(),
calldata: vec![
declaration_result.class_hash, // the hash of the class whose instance is deployed
salt,
Felt::ONE, // unique or not_from_zero
Felt::ONE, // ctor_args len
Felt::ONE, // ctor_arg
],
}];
salt += Felt::ONE; // iI salt not changed, error: contract already deployed
let invoke_result = account.execute_v3(contract_invoke.clone()).send().await.unwrap();
assert_tx_succeeded_accepted(&invoke_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_get_block_txs_count.rs | tests/integration/test_get_block_txs_count.rs | use starknet_rs_core::types::{BlockId, BlockTag, StarknetError};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
#[tokio::test]
async fn test_invalid_block() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let res = devnet
.json_rpc_client
.get_block_transaction_count(BlockId::Number(9000000000))
.await
.unwrap_err();
match res {
ProviderError::StarknetError(StarknetError::BlockNotFound) => (),
_ => panic!("Invalid error: {res:?}"),
}
}
#[tokio::test]
async fn test_valid_block() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
devnet
.json_rpc_client
.get_block_transaction_count(BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_get_events.rs | tests/integration/test_get_events.rs | use std::sync::Arc;
use starknet_rs_accounts::{Account, ConnectedAccount, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
BlockId, BlockStatus, BlockTag, Call, EmittedEvent, EventFilter, Felt, StarknetError,
};
use starknet_rs_core::utils::{get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{self, MAINNET_URL, STRK_ERC20_CONTRACT_ADDRESS};
use crate::common::utils::{get_events_contract_artifacts, new_contract_factory};
async fn get_events_follow_continuation_token(
devnet: &BackgroundDevnet,
event_filter: EventFilter,
chunk_size: u64,
) -> Result<Vec<EmittedEvent>, ProviderError> {
let mut events = vec![];
let mut continuation_token: Option<String> = None;
loop {
let events_page = devnet
.json_rpc_client
.get_events(event_filter.clone(), continuation_token, chunk_size)
.await?;
events.extend(events_page.events);
continuation_token = events_page.continuation_token;
if continuation_token.is_none() {
break;
}
}
Ok(events)
}
/// A helper function which asserts that the `starknet_getEvents` RPC method returns the correct
/// events. It expects a running Devnet, gets the first predeployed account and uses it to declare
/// and deploy a contract that emits events. Then the events are fetched: first all in a single
/// chunk, then in multiple chunks.
async fn get_events_correct_chunking(devnet: &BackgroundDevnet, block_on_demand: bool) {
let (signer, address) = devnet.get_first_predeployed_account().await;
let mut predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
predeployed_account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed));
let (cairo_1_contract, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result: starknet_rs_core::types::DeclareTransactionResult = predeployed_account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.send()
.await
.unwrap();
let predeployed_account = Arc::new(predeployed_account);
if block_on_demand {
devnet.create_block().await.unwrap();
}
// deploy the contract
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
contract_factory.deploy_v3(vec![], Felt::ZERO, false).send().await.unwrap();
if block_on_demand {
devnet.create_block().await.unwrap();
}
// generate the address of the newly deployed contract
let new_contract_address = get_udc_deployed_address(
Felt::ZERO,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&[],
);
let events_contract_call = vec![Call {
to: new_contract_address,
selector: get_selector_from_name("emit_event").unwrap(),
calldata: vec![Felt::ONE],
}];
// invoke 10 times the contract to emit event, it should produce 10 events
let n_events_contract_invocations = 10;
let nonce = predeployed_account.get_nonce().await.unwrap();
for n in 0..n_events_contract_invocations {
predeployed_account
.execute_v3(events_contract_call.clone())
.nonce(nonce + Felt::from(n))
.send()
.await
.unwrap();
}
if block_on_demand {
devnet.create_block().await.unwrap();
}
// get all the events from the contract, the chunk size is large enough so we are sure
// we get all the events in one call
let event_filter = EventFilter {
from_block: None,
to_block: Some(BlockId::Tag(BlockTag::Latest)),
address: Some(new_contract_address),
keys: None,
};
let events =
devnet.json_rpc_client.get_events(event_filter.clone(), None, 100000000).await.unwrap();
let generated_events_count = events.events.len();
assert_eq!(generated_events_count, n_events_contract_invocations);
// divide the events by a group of 3
// and iterate over with continuation token
// on the last iteration the continuation token should be None
let chunk_size = 3;
let mut continuation_token: Option<String> = None;
let mut total_extracted_events = 0;
loop {
let events = devnet
.json_rpc_client
.get_events(event_filter.clone(), continuation_token, chunk_size as u64)
.await
.unwrap();
total_extracted_events += events.events.len();
if events.continuation_token.is_some() {
assert_eq!(events.events.len(), chunk_size);
} else {
assert!(events.events.len() <= chunk_size);
}
continuation_token = events.continuation_token;
if continuation_token.is_none() {
break;
}
}
assert_eq!(total_extracted_events, generated_events_count);
}
#[tokio::test]
async fn get_events_correct_chunking_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
get_events_correct_chunking(&devnet, false).await
}
#[tokio::test]
async fn get_events_correct_chunking_blocks_generation_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.expect("Could not start Devnet");
get_events_correct_chunking(&devnet, true).await
}
#[tokio::test]
async fn get_events_errors() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
{
let chunk_size: u64 = 3;
let continuation_token: Option<String> = None;
let event_filter = EventFilter {
from_block: Some(BlockId::Number(90_000_000)),
to_block: Some(BlockId::Tag(BlockTag::Latest)),
address: None,
keys: None,
};
match devnet.json_rpc_client.get_events(event_filter, continuation_token, chunk_size).await
{
Err(ProviderError::StarknetError(StarknetError::BlockNotFound)) => (),
resp => panic!("Unexpected response: {resp:?}"),
}
}
{
let chunk_size: u64 = 3;
let continuation_token = Some(String::from("invalid token"));
let event_filter = EventFilter {
from_block: Some(BlockId::Number(0)),
to_block: Some(BlockId::Tag(BlockTag::Latest)),
address: None,
keys: None,
};
match devnet.json_rpc_client.get_events(event_filter, continuation_token, chunk_size).await
{
Err(ProviderError::StarknetError(StarknetError::InvalidContinuationToken)) => (),
resp => panic!("Unexpected response: {resp:?}"),
}
}
}
/// Spawns Devnet which forks mainnet at block number `block`.
async fn fork_mainnet_at(block: u64) -> Result<BackgroundDevnet, anyhow::Error> {
let cli_args = ["--fork-network", MAINNET_URL, "--fork-block", &block.to_string()];
Ok(BackgroundDevnet::spawn_with_additional_args(&cli_args).await?)
}
const FORK_BLOCK_NUMBER: u64 = 1374700;
const EVENTS_IN_FORK_BLOCK: usize = 330;
#[tokio::test]
async fn get_events_from_forked_devnet_when_last_queried_block_on_origin() {
let fork_devnet = fork_mainnet_at(FORK_BLOCK_NUMBER).await.unwrap();
assert_eq!(
FORK_BLOCK_NUMBER + 1,
fork_devnet.get_latest_block_with_tx_hashes().await.unwrap().block_number
);
let chunk_size = 100; // to force pagination
let events = get_events_follow_continuation_token(
&fork_devnet,
EventFilter {
from_block: Some(BlockId::Number(FORK_BLOCK_NUMBER)),
to_block: Some(BlockId::Number(FORK_BLOCK_NUMBER)),
address: Some(STRK_ERC20_CONTRACT_ADDRESS),
keys: Some(vec![vec![get_selector_from_name("Transfer").unwrap()]]),
},
chunk_size,
)
.await
.unwrap();
assert_eq!(events.len(), EVENTS_IN_FORK_BLOCK);
}
#[tokio::test]
async fn get_events_from_forked_devnet_when_first_queried_block_on_devnet() {
let fork_devnet = fork_mainnet_at(FORK_BLOCK_NUMBER).await.unwrap();
assert_eq!(
FORK_BLOCK_NUMBER + 1,
fork_devnet.get_latest_block_with_tx_hashes().await.unwrap().block_number
);
let dummy_address = Felt::ONE;
let mint_amount = 10;
let n_mints = 3;
for _ in 0..n_mints {
fork_devnet.mint(dummy_address, mint_amount).await;
}
let chunk_size = 100; // to force pagination
let events = get_events_follow_continuation_token(
&fork_devnet,
EventFilter {
from_block: Some(BlockId::Number(FORK_BLOCK_NUMBER + 1)),
to_block: None,
address: Some(STRK_ERC20_CONTRACT_ADDRESS),
keys: Some(vec![vec![get_selector_from_name("Transfer").unwrap()]]),
},
chunk_size,
)
.await
.unwrap();
// Each minting creates 2 transfers: one to charge the chargeable contract, one to give funds
// to the target address.
assert_eq!(events.len(), n_mints * 2);
}
#[tokio::test]
async fn get_events_from_forked_devnet_when_first_queried_block_on_origin_and_last_on_devnet() {
let fork_devnet = fork_mainnet_at(FORK_BLOCK_NUMBER).await.unwrap();
assert_eq!(
FORK_BLOCK_NUMBER + 1,
fork_devnet.get_latest_block_with_tx_hashes().await.unwrap().block_number
);
let n_mints = 3;
for _ in 0..n_mints {
fork_devnet.mint(Felt::ONE, 10).await; // dummy data
}
let chunk_size = 100; // to force pagination
let events = get_events_follow_continuation_token(
&fork_devnet,
EventFilter {
from_block: Some(BlockId::Number(FORK_BLOCK_NUMBER)),
to_block: None,
address: Some(STRK_ERC20_CONTRACT_ADDRESS),
keys: Some(vec![vec![get_selector_from_name("Transfer").unwrap()]]),
},
chunk_size,
)
.await
.unwrap();
// Each minting creates 2 transfers: one to charge the chargeable contract, one to give funds
// to the target address.
let fork_events = n_mints * 2;
assert_eq!(events.len(), EVENTS_IN_FORK_BLOCK + fork_events);
}
#[tokio::test]
async fn get_events_since_accepted_on_l1_on_origin() {
let fork_devnet = fork_mainnet_at(FORK_BLOCK_NUMBER).await.unwrap();
// accepted_on_l1 should be on origin
let fork_block = fork_devnet
.get_confirmed_block_with_tx_hashes(&BlockId::Number(FORK_BLOCK_NUMBER))
.await
.unwrap();
assert_eq!(fork_block.status, BlockStatus::AcceptedOnL1);
let n_mints = 1;
for _ in 0..n_mints {
fork_devnet.mint(Felt::ONE, 1).await; // dummy data
}
let events = get_events_follow_continuation_token(
&fork_devnet,
EventFilter {
from_block: Some(BlockId::Tag(BlockTag::L1Accepted)), // origin
to_block: None,
address: Some(STRK_ERC20_CONTRACT_ADDRESS),
keys: Some(vec![vec![get_selector_from_name("Transfer").unwrap()]]),
},
100, // chunk size
)
.await
.unwrap();
assert_eq!(events.len(), n_mints * 2 + EVENTS_IN_FORK_BLOCK);
}
#[tokio::test]
async fn get_events_from_forked_devnet_since_locally_present_accepted_on_l1() {
let fork_devnet = fork_mainnet_at(FORK_BLOCK_NUMBER).await.unwrap();
let n_mints = 1;
for _ in 0..n_mints {
fork_devnet.mint(Felt::ONE, 1).await; // dummy data
}
fork_devnet.accept_on_l1(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
let events = get_events_follow_continuation_token(
&fork_devnet,
EventFilter {
from_block: Some(BlockId::Tag(BlockTag::L1Accepted)),
to_block: None,
address: Some(STRK_ERC20_CONTRACT_ADDRESS),
keys: Some(vec![vec![get_selector_from_name("Transfer").unwrap()]]),
},
100, // chunk size
)
.await
.unwrap();
assert_eq!(events.len(), n_mints * 2);
}
#[tokio::test]
/// This is to prevent a bug which appeared specifically if block_id is block hash
async fn get_events_from_forked_devnet_by_block_hash_with_all_events_present_locally() {
let fork_devnet = fork_mainnet_at(FORK_BLOCK_NUMBER).await.unwrap();
let first_block_after_fork = fork_devnet.get_latest_block_with_tx_hashes().await.unwrap();
let n_mints = 3;
for _ in 0..n_mints {
fork_devnet.mint(Felt::ONE, 10).await; // dummy data
}
let latest_block = fork_devnet.get_latest_block_with_tx_hashes().await.unwrap();
let chunk_size = 100; // to force pagination
let events = get_events_follow_continuation_token(
&fork_devnet,
EventFilter {
from_block: Some(BlockId::Hash(first_block_after_fork.block_hash)),
to_block: Some(BlockId::Hash(latest_block.block_hash)),
address: Some(STRK_ERC20_CONTRACT_ADDRESS),
keys: Some(vec![vec![get_selector_from_name("Transfer").unwrap()]]),
},
chunk_size,
)
.await
.unwrap();
assert_eq!(events.len(), n_mints * 2);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/lib.rs | tests/integration/lib.rs | #![cfg(test)]
mod common;
mod general_integration_tests;
mod general_rpc_tests;
mod get_transaction_by_block_id_and_index;
mod get_transaction_by_hash;
mod get_transaction_receipt_by_hash;
mod test_abort_blocks;
mod test_accepting_blocks_on_l1;
mod test_account_impersonation;
mod test_account_selection;
mod test_advancing_time;
mod test_advancing_time_on_fork;
mod test_balance;
mod test_blocks_generation;
mod test_call;
mod test_deploy;
mod test_dump_and_load;
mod test_estimate_fee;
mod test_estimate_message_fee;
mod test_fork;
mod test_gas_modification;
mod test_get_block_txs_count;
mod test_get_class;
mod test_get_class_hash_at;
mod test_get_events;
mod test_messaging;
mod test_minting;
mod test_old_state;
mod test_restart;
mod test_restrictive_mode;
mod test_simulate_transactions;
mod test_subscription_to_blocks;
mod test_subscription_to_events;
mod test_subscription_to_new_tx_receipts;
mod test_subscription_to_new_txs;
mod test_subscription_to_reorg;
mod test_subscription_to_tx_status;
mod test_subscription_with_invalid_block_id;
mod test_trace;
mod test_transaction_handling;
mod test_v3_transactions;
mod test_websocket;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_messaging.rs | tests/integration/test_messaging.rs | //! This module tests the messaging feature from the starknet-server perspective.
//!
//! The message contract `cairo_0_l1l2_contract` associates a balance to a user (ContractAddress)
//! and contains the following entrypoints:
//! * increase_balance -> increases the balance of a user (contract address) for the given amount.
//! * get_balance -> gets the balance of a user.
//! * withdraw -> withdraw from a user the given amount, sending the amount to a l2->l1 message.
//! * deposit -> deposit the given amount from a l1->l2 message (l1 handler function).
use std::sync::Arc;
use alloy::hex::FromHex;
use alloy::primitives::{Address, U256};
use serde_json::{Value, json};
use starknet_rs_accounts::{
Account, AccountError, ConnectedAccount, ExecutionEncoding, SingleOwnerAccount,
};
use starknet_rs_core::types::{
BlockId, BlockTag, Call, ExecuteInvocation, ExecutionResult, Felt, FunctionCall,
InvokeTransactionReceipt, InvokeTransactionResult, L1HandlerTransactionTrace,
TransactionExecutionStatus, TransactionReceipt, TransactionReceiptWithBlockInfo,
TransactionTrace,
};
use starknet_rs_core::utils::{UdcUniqueness, get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider};
use starknet_rs_signers::LocalWallet;
use crate::assert_eq_prop;
use crate::common::background_anvil::BackgroundAnvil;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
CHAIN_ID, DEFAULT_ETH_ACCOUNT_PRIVATE_KEY, L1_HANDLER_SELECTOR, MESSAGING_L1_CONTRACT_ADDRESS,
MESSAGING_L2_CONTRACT_ADDRESS, MESSAGING_WHITELISTED_L1_CONTRACT,
};
use crate::common::errors::RpcError;
use crate::common::utils::{
UniqueAutoDeletableFile, assert_contains, assert_tx_succeeded_accepted, felt_to_u256,
get_messaging_contract_artifacts, get_messaging_lib_artifacts, new_contract_factory,
send_ctrl_c_signal_and_wait,
};
const DUMMY_L1_ADDRESS: Felt =
Felt::from_hex_unchecked("0xc662c410c0ecf747543f5ba90660f6abebd9c8c4");
const MESSAGE_WITHDRAW_OPCODE: Felt = Felt::ZERO;
/// Differs from MESSAGING_WHITELISTED_L1_CONTRACT: that address is hardcoded in the cairo0 l1l2
/// contract relying on it. This address is provided as an argument to the cairo1 l1l2 contract.
const MESSAGING_L1_ADDRESS: &str = "0x5fbdb2315678afecb367f032d93f642f64180aa3";
/// Withdraws the given amount from a user and sends it in a l2->l1 message.
async fn withdraw<A: ConnectedAccount + Send + Sync + 'static>(
account: A,
contract_address: Felt,
user: Felt,
amount: Felt,
l1_address: Felt,
) -> Result<InvokeTransactionResult, AccountError<<A as Account>::SignError>> {
let invoke_calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("withdraw").unwrap(),
calldata: vec![user, amount, l1_address],
}];
account.execute_v3(invoke_calls).send().await
}
/// Increases the balance for the given user.
async fn increase_balance<A: ConnectedAccount + Send + Sync + 'static>(
account: A,
contract_address: Felt,
user: Felt,
amount: Felt,
) -> Result<(), anyhow::Error> {
let invoke_calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![user, amount],
}];
account
.execute_v3(invoke_calls)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.map_err(|err| anyhow::anyhow!("invoke error {:?}", err))?;
Ok(())
}
/// Gets the balance for the given user.
async fn get_balance(
devnet: &BackgroundDevnet,
contract_address: Felt,
user: Felt,
) -> Result<Vec<Felt>, anyhow::Error> {
let call = FunctionCall {
contract_address,
entry_point_selector: get_selector_from_name("get_balance").unwrap(),
calldata: vec![user],
};
let result = devnet.json_rpc_client.call(call, BlockId::Tag(BlockTag::PreConfirmed)).await?;
Ok(result)
}
/// Withdraws the given amount from a user and send this amount in a l2->l1 message
/// using a library syscall instead of the contract with storage directly.
async fn withdraw_from_lib<A: ConnectedAccount + Send + Sync + 'static>(
account: A,
contract_address: Felt,
user: Felt,
amount: Felt,
l1_address: Felt,
lib_class_hash: Felt,
) -> Result<InvokeTransactionResult, AccountError<<A as Account>::SignError>> {
let invoke_calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("withdraw_from_lib").unwrap(),
calldata: vec![user, amount, l1_address, lib_class_hash],
}];
account.execute_v3(invoke_calls).send().await
}
/// Returns the deployment address
async fn deploy_l2_msg_contract(
account: Arc<SingleOwnerAccount<JsonRpcClient<HttpTransport>, LocalWallet>>,
) -> Result<Felt, anyhow::Error> {
// Declare l1l2 contract with storage (meant to be deployed).
let (sierra_class, casm_class_hash) = get_messaging_contract_artifacts();
let sierra_class_hash = sierra_class.class_hash();
account.declare_v3(Arc::new(sierra_class), casm_class_hash).send().await?;
// deploy instance of class
let contract_factory = new_contract_factory(sierra_class_hash, account.clone());
let salt = Felt::from_hex_unchecked("0x123");
let constructor_calldata = vec![];
let contract_address = get_udc_deployed_address(
salt,
sierra_class_hash,
&UdcUniqueness::NotUnique,
&constructor_calldata,
);
contract_factory.deploy_v3(constructor_calldata, salt, false).nonce(Felt::ONE).send().await?;
Ok(contract_address)
}
/// Sets up a `BackgroundDevnet` with the message l1-l2 contract deployed.
/// Returns (devnet instance, account used for deployment, l1-l2 contract address).
async fn setup_devnet(
devnet_args: &[&str],
) -> Result<
(BackgroundDevnet, Arc<SingleOwnerAccount<JsonRpcClient<HttpTransport>, LocalWallet>>, Felt),
anyhow::Error,
> {
let devnet = BackgroundDevnet::spawn_with_additional_args(devnet_args).await?;
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
let contract_address = deploy_l2_msg_contract(account.clone()).await?;
Ok((devnet, account, contract_address))
}
fn assert_accepted_l1_handler_trace(trace: &TransactionTrace) -> Result<(), anyhow::Error> {
match trace {
TransactionTrace::L1Handler(L1HandlerTransactionTrace {
function_invocation: ExecuteInvocation::Success(invocation),
..
}) => {
assert_eq_prop!(
invocation.contract_address.to_hex_string(),
MESSAGING_L2_CONTRACT_ADDRESS
)?;
assert_eq_prop!(invocation.entry_point_selector.to_hex_string(), L1_HANDLER_SELECTOR)?;
assert_eq_prop!(invocation.calldata[0].to_hex_string(), MESSAGING_L1_CONTRACT_ADDRESS)
}
other => anyhow::bail!("Invalid trace: {other:?}"),
}
}
/// Assert all funds of the given user are withdrawn. Simulate message flushing.
async fn assert_withdrawn(
devnet: &BackgroundDevnet,
from_address: Felt,
to_address: Felt,
user: Felt,
amount: Felt,
) -> Result<(), anyhow::Error> {
let balance = get_balance(devnet, from_address, user).await?;
assert_eq_prop!(balance, [Felt::ZERO])?;
let resp_body =
devnet.send_custom_rpc("devnet_postmanFlush", json!({ "dry_run": true })).await?;
let expected_resp = json!({
"messages_to_l1": [
{
"from_address": from_address,
"to_address": to_address,
"payload": [MESSAGE_WITHDRAW_OPCODE, user, amount]
}
],
"messages_to_l2": [],
"generated_l2_transactions": [],
"l1_provider": "dry run"
});
assert_eq_prop!(resp_body, expected_resp)
}
#[tokio::test]
async fn can_send_message_to_l1() {
let (devnet, account, l1l2_contract_address) =
setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
let user = Felt::ONE;
// Set balance to 1 for user.
let user_balance = Felt::ONE;
increase_balance(account.clone(), l1l2_contract_address, user, user_balance).await.unwrap();
assert_eq!(get_balance(&devnet, l1l2_contract_address, user).await.unwrap(), [user_balance]);
// We don't actually send a message to L1 in this test.
let l1_address = DUMMY_L1_ADDRESS;
// Withdraw the 1 amount in a l2->l1 message.
withdraw(account, l1l2_contract_address, user, user_balance, l1_address).await.unwrap();
assert_withdrawn(&devnet, l1l2_contract_address, l1_address, user, user_balance).await.unwrap();
}
#[tokio::test]
async fn can_send_message_to_l1_from_library_syscall() {
let (devnet, account, l1l2_contract_address) =
setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
// Declare l1l2 lib with only one function to send messages.
// Its class hash can then be ignored, it's hardcoded in the contract.
let (sierra_class, casm_class_hash) = get_messaging_lib_artifacts();
let lib_sierra_class_hash = sierra_class.class_hash();
account
.declare_v3(Arc::new(sierra_class), casm_class_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
let user = Felt::ONE;
// Set balance to 1 for user.
let user_balance = Felt::ONE;
increase_balance(Arc::clone(&account), l1l2_contract_address, user, user_balance)
.await
.unwrap();
assert_eq!(get_balance(&devnet, l1l2_contract_address, user).await.unwrap(), [user_balance]);
// We don't actually send a message to the L1 in this test.
let l1_address = DUMMY_L1_ADDRESS;
// Withdraw the 1 amount in an l2->l1 message.
withdraw_from_lib(
Arc::clone(&account),
l1l2_contract_address,
user,
user_balance,
l1_address,
lib_sierra_class_hash,
)
.await
.unwrap();
assert_withdrawn(&devnet, l1l2_contract_address, l1_address, user, user_balance).await.unwrap();
}
#[tokio::test]
async fn mock_message_to_l2_creates_a_tx_with_desired_effect() {
let (devnet, account, l1l2_contract_address) =
setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
let user = Felt::ONE;
// Set balance to 1 for user.
let user_balance = Felt::ONE;
increase_balance(account, l1l2_contract_address, user, user_balance).await.unwrap();
assert_eq!(get_balance(&devnet, l1l2_contract_address, user).await.unwrap(), [user_balance]);
// Use postman to send a message to l2 without l1 - the message increments user balance
let increment_amount = Felt::from_hex_unchecked("0xff");
let body: serde_json::Value = devnet
.send_custom_rpc(
"devnet_postmanSendMessageToL2",
json!({
"l1_contract_address": MESSAGING_L1_ADDRESS,
"l2_contract_address": l1l2_contract_address,
"entry_point_selector": get_selector_from_name("deposit").unwrap(),
"payload": [user, increment_amount],
"paid_fee_on_l1": "0x1234",
"nonce": "0x1"
}),
)
.await
.unwrap();
let tx_hash_hex = body.get("transaction_hash").unwrap().as_str().unwrap();
let tx_hash = Felt::from_hex_unchecked(tx_hash_hex);
assert_tx_succeeded_accepted(&tx_hash, &devnet.json_rpc_client).await.unwrap();
// assert state changed
assert_eq!(
get_balance(&devnet, l1l2_contract_address, user).await.unwrap(),
[user_balance + increment_amount]
);
// assert tx and receipt retrievable and correct
let expected_calldata =
vec![Felt::from_hex_unchecked(MESSAGING_L1_ADDRESS), user, increment_amount];
match devnet.json_rpc_client.get_transaction_by_hash(tx_hash).await {
Ok(starknet_rs_core::types::Transaction::L1Handler(tx)) => {
assert_eq!(tx.transaction_hash, tx_hash);
assert_eq!(tx.calldata, expected_calldata);
}
other => panic!("Error in fetching tx: {other:?}"),
}
match devnet.json_rpc_client.get_transaction_receipt(tx_hash).await {
Ok(TransactionReceiptWithBlockInfo {
receipt: TransactionReceipt::L1Handler(receipt),
..
}) => {
assert_eq!(receipt.transaction_hash, tx_hash);
assert_eq!(receipt.execution_result.status(), TransactionExecutionStatus::Succeeded);
}
other => panic!("Error in fetching receipt: {other:?}"),
}
}
#[tokio::test]
async fn can_deploy_l1_messaging_contract() {
let anvil = BackgroundAnvil::spawn().await.unwrap();
let (devnet, _, _) = setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
let body = devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.expect("deploy l1 messaging contract failed");
assert_eq!(
body.get("messaging_contract_address").unwrap().as_str().unwrap(),
MESSAGING_L1_ADDRESS
);
}
#[tokio::test]
async fn should_fail_on_loading_l1_messaging_contract_if_not_deployed() {
let anvil = BackgroundAnvil::spawn().await.unwrap();
let devnet = BackgroundDevnet::spawn().await.unwrap();
let error = devnet
.send_custom_rpc(
"devnet_postmanLoad",
json!({ "network_url": anvil.url, "messaging_contract_address": MESSAGING_L1_ADDRESS }),
)
.await
.unwrap_err();
assert_eq!(
error,
RpcError {
code: -1,
message: format!(
"Alloy error: The specified address ({MESSAGING_L1_ADDRESS}) contains no contract."
)
.into(),
data: None
}
);
}
#[tokio::test]
async fn can_load_an_already_deployed_l1_messaging_contract() {
let anvil = BackgroundAnvil::spawn().await.unwrap();
let devnet = BackgroundDevnet::spawn().await.unwrap();
let body = devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.expect("deploy l1 messaging contract failed");
assert_eq!(
body.get("messaging_contract_address").unwrap().as_str().unwrap(),
MESSAGING_L1_ADDRESS
);
let second_devnet = BackgroundDevnet::spawn().await.unwrap();
for address_key in [
"messaging_contract_address", // preferred key
"address", // legacy key
] {
let load_result = second_devnet
.send_custom_rpc(
"devnet_postmanLoad",
json!({ "network_url": anvil.url, address_key: MESSAGING_L1_ADDRESS }),
)
.await
.unwrap();
assert_eq!(
load_result.get("messaging_contract_address").unwrap().as_str().unwrap(),
MESSAGING_L1_ADDRESS
);
}
}
const MNEMONIC_FROM_SEED_42: &str =
"pen brief eager pepper brass detect problem vital physical tent assume damp";
const ACCOUNT_0_PRIVATE_KEY_WITH_SEED_42: &str =
"0x3c741b302cb3ea9163539c7fc72d4e40264aa03cfb638d79860d86865c3d0db4";
const EXPECTED_MESSAGING_CONTRACT_ADDRESS_WITH_SEED_42: &str =
"0xca945eebf408d4a73e5d330fc8f6b55cd1e419ff";
#[tokio::test]
async fn setup_anvil_incorrect_eth_private_key() {
let anvil = BackgroundAnvil::spawn_with_additional_args_and_custom_signer(
&[],
MNEMONIC_FROM_SEED_42,
ACCOUNT_0_PRIVATE_KEY_WITH_SEED_42,
)
.await
.unwrap();
let (devnet, _, _) = setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
let body = devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.unwrap_err();
assert_contains(&body.message, "Insufficient funds for gas * price + value.").unwrap();
let body = devnet
.send_custom_rpc(
"devnet_postmanLoad",
json!({
"network_url": anvil.url,
"deployer_account_private_key": DEFAULT_ETH_ACCOUNT_PRIVATE_KEY
}),
)
.await
.unwrap_err();
assert_contains(&body.message, "Insufficient funds for gas * price + value.").unwrap();
}
#[tokio::test]
async fn deploy_l1_messaging_contract_with_custom_key() {
let anvil = BackgroundAnvil::spawn_with_additional_args_and_custom_signer(
&[],
MNEMONIC_FROM_SEED_42,
ACCOUNT_0_PRIVATE_KEY_WITH_SEED_42,
)
.await
.unwrap();
let (devnet, _, _) = setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
let body = devnet
.send_custom_rpc(
"devnet_postmanLoad",
json!({
"network_url": anvil.url,
"deployer_account_private_key": ACCOUNT_0_PRIVATE_KEY_WITH_SEED_42
}),
)
.await
.expect("deploy l1 messaging contract failed");
assert_eq!(
body.get("messaging_contract_address").unwrap().as_str().unwrap(),
EXPECTED_MESSAGING_CONTRACT_ADDRESS_WITH_SEED_42
);
}
#[tokio::test]
async fn can_consume_from_l2() {
let (devnet, account, l1l2_contract_address) =
setup_devnet(&["--account-class", "cairo1"]).await.unwrap();
let user = Felt::ONE;
// Set balance to 1 for user.
let user_balance = Felt::ONE;
increase_balance(account.clone(), l1l2_contract_address, user, user_balance).await.unwrap();
assert_eq!(get_balance(&devnet, l1l2_contract_address, user).await.unwrap(), [user_balance]);
// We don't need valid l1 address as we don't use L1 node.
let l1_address = DUMMY_L1_ADDRESS;
// Withdraw the 1 amount in a l2->l1 message.
withdraw(account, l1l2_contract_address, user, user_balance, l1_address).await.unwrap();
assert_eq!(get_balance(&devnet, l1l2_contract_address, user).await.unwrap(), [Felt::ZERO]);
let body = devnet
.send_custom_rpc(
"devnet_postmanConsumeMessageFromL2",
json!({
"from_address": l1l2_contract_address,
"to_address": l1_address,
"payload": ["0x0","0x1","0x1"],
}),
)
.await
.expect("consume message from l2 failed");
assert_eq!(
body.get("message_hash").unwrap().as_str().unwrap(),
"0xac5356289f98e5012f8efcabb9f7ad3adaa43f81ac47b6311d2c23ca01590bd0"
);
}
#[tokio::test]
async fn can_interact_with_l1() {
let dump_file = UniqueAutoDeletableFile::new("can_interact_with_l1");
let anvil = BackgroundAnvil::spawn().await.unwrap();
let (devnet, sn_account, sn_l1l2_contract) = setup_devnet(&[
"--account-class",
"cairo1",
"--dump-path",
&dump_file.path,
"--dump-on",
"exit",
])
.await
.unwrap();
// Load l1 messaging contract.
let body: serde_json::Value = devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.expect("deploy l1 messaging contract failed");
assert_eq!(
body.get("messaging_contract_address").unwrap().as_str().unwrap(),
MESSAGING_L1_ADDRESS
);
// Deploy the L1L2 testing contract on L1 (on L2 it's already pre-deployed).
let l1_messaging_address = Address::from_hex(MESSAGING_L1_ADDRESS).unwrap();
let eth_l1l2_address = anvil.deploy_l1l2_contract(l1_messaging_address).await.unwrap();
let eth_l1l2_address_hex = format!("{eth_l1l2_address:#x}");
let eth_l1l2_address_felt = Felt::from_hex_unchecked(ð_l1l2_address_hex);
let user_sn = Felt::ONE;
let user_eth: U256 = U256::ONE;
// Set balance to 1 for the user 1 on L2.
let user_balance = Felt::ONE;
increase_balance(sn_account.clone(), sn_l1l2_contract, user_sn, user_balance).await.unwrap();
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [user_balance]);
// Withdraw the amount 1 from user 1 balance on L2 to send it on L1 with a l2->l1 message.
withdraw(sn_account, sn_l1l2_contract, user_sn, user_balance, eth_l1l2_address_felt)
.await
.unwrap();
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ZERO]);
// Flush to send the messages.
devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.expect("flush failed");
// Check that the balance is 0 on L1 before consuming the message.
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
assert_eq!(user_balance_eth, U256::ZERO);
let sn_l1l2_contract_u256 = felt_to_u256(sn_l1l2_contract);
// Consume the message to increase the balance.
anvil
.withdraw_l1l2(eth_l1l2_address, sn_l1l2_contract_u256, user_eth, U256::ONE)
.await
.unwrap();
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
assert_eq!(user_balance_eth, U256::ONE);
// Send back the amount 1 to the user 1 on L2.
anvil.deposit_l1l2(eth_l1l2_address, sn_l1l2_contract_u256, user_eth, U256::ONE).await.unwrap();
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
// Balances on both layers is 0 at this point.
assert_eq!(user_balance_eth, U256::ZERO);
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ZERO]);
// Flush messages to have MessageToL2 executed.
let flush_resp = devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.unwrap();
let generated_l2_txs = flush_resp["generated_l2_transactions"].as_array().unwrap();
assert_eq!(generated_l2_txs.len(), 1); // expect this to be the only tx
let generated_l2_tx = Felt::from_hex_unchecked(generated_l2_txs[0].as_str().unwrap());
// Ensure the balance is back to 1 on L2.
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ONE]);
let l1_handler_trace = devnet.json_rpc_client.trace_transaction(generated_l2_tx).await.unwrap();
assert_accepted_l1_handler_trace(&l1_handler_trace).unwrap();
send_ctrl_c_signal_and_wait(&devnet.process).await;
// Assert traces of L1Handler with loaded devnets
let loaded_devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--account-class",
"cairo1",
])
.await
.unwrap();
let l1_handler_trace_loaded =
loaded_devnet.json_rpc_client.trace_transaction(generated_l2_tx).await.unwrap();
assert_accepted_l1_handler_trace(&l1_handler_trace_loaded).unwrap();
}
#[tokio::test]
async fn assert_l1_handler_tx_can_be_dumped_and_loaded() {
let dump_file = UniqueAutoDeletableFile::new("dump-with-l1-handler");
let (dumping_devnet, account, l1l2_contract_address) = setup_devnet(&[
"--account-class",
"cairo1",
"--dump-on",
"exit",
"--dump-path",
&dump_file.path,
])
.await
.unwrap();
// Set balance for user
let user = Felt::ONE;
let user_balance = Felt::ONE;
increase_balance(Arc::clone(&account), l1l2_contract_address, user, user_balance)
.await
.unwrap();
assert_eq!(
get_balance(&dumping_devnet, l1l2_contract_address, user).await.unwrap(),
[user_balance]
);
// Use postman to send a message to l2 without l1 - the message increments user balance
let increment_amount = Felt::from(0xff);
dumping_devnet
.send_custom_rpc(
"devnet_postmanSendMessageToL2",
json!({
"l1_contract_address": MESSAGING_WHITELISTED_L1_CONTRACT,
"l2_contract_address": l1l2_contract_address,
"entry_point_selector": get_selector_from_name("deposit").unwrap(),
"payload": [user, increment_amount],
"paid_fee_on_l1": "0x1234",
"nonce": "0x1"
}),
)
.await
.unwrap();
assert_eq!(
get_balance(&dumping_devnet, l1l2_contract_address, user).await.unwrap(),
[user_balance + increment_amount]
);
send_ctrl_c_signal_and_wait(&dumping_devnet.process).await;
let loading_devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--account-class",
"cairo1",
])
.await
.unwrap();
assert_eq!(
get_balance(&loading_devnet, l1l2_contract_address, user).await.unwrap(),
[user_balance + increment_amount]
);
}
#[tokio::test]
async fn test_correct_message_order() {
let anvil = BackgroundAnvil::spawn_with_additional_args(&["--block-time", "1"]).await.unwrap();
let (devnet, sn_account, sn_l1l2_contract) = setup_devnet(&[]).await.unwrap();
// Load l1 messaging contract.
let load_resp: serde_json::Value = devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.expect("deploy l1 messaging contract failed");
assert_eq!(
load_resp.get("messaging_contract_address").unwrap().as_str().unwrap(),
MESSAGING_L1_ADDRESS
);
// Deploy the L1L2 testing contract on L1 (on L2 it's already pre-deployed).
let l1_messaging_address = Address::from_hex(MESSAGING_L1_ADDRESS).unwrap();
let eth_l1l2_address = anvil.deploy_l1l2_contract(l1_messaging_address).await.unwrap();
let eth_l1l2_address_hex = format!("{eth_l1l2_address:#x}");
let eth_l1l2_address_felt = Felt::from_hex_unchecked(ð_l1l2_address_hex);
let user_sn = Felt::ONE;
let user_eth: U256 = U256::ONE;
// Set balance for the user on L2.
let init_balance = 5_u64;
increase_balance(sn_account.clone(), sn_l1l2_contract, user_sn, init_balance.into())
.await
.unwrap();
// Withdraw the set amount from user 1 balance on L2 to send it on L1 with a l2->l1 message.
withdraw(sn_account, sn_l1l2_contract, user_sn, init_balance.into(), eth_l1l2_address_felt)
.await
.unwrap();
// Flush to send the messages.
devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.expect("flush failed");
let sn_l1l2_contract_u256 = felt_to_u256(sn_l1l2_contract);
// Consume the message to increase the L1 balance.
anvil
.withdraw_l1l2(eth_l1l2_address, sn_l1l2_contract_u256, user_eth, U256::from(init_balance))
.await
.unwrap();
// Send back an amount of 1 to the user on L2. Do it n times to have n transactions,
// for the purpose of message order testing (n = init_balance)
for _ in 0..init_balance {
anvil
.deposit_l1l2(eth_l1l2_address, sn_l1l2_contract_u256, user_eth, U256::ONE)
.await
.unwrap();
}
// Flush messages to have MessageToL2 executed.
let flush_resp = devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.unwrap();
println!("Flush response: {flush_resp:#}");
let generated_l2_txs = flush_resp["messages_to_l2"].as_array().unwrap();
let flushed_message_nonces: Vec<_> = generated_l2_txs
.iter()
.map(|msg| msg["nonce"].as_str().unwrap())
.map(|nonce| u64::from_str_radix(nonce.strip_prefix("0x").unwrap(), 16).unwrap())
.collect();
let expected_nonces: Vec<_> = (0..init_balance).collect();
assert_eq!(flushed_message_nonces, expected_nonces);
}
#[tokio::test]
/// Here we test if the devnet_postmanLoad method call is indeed dumped and then used in a load.
async fn test_dumpability_of_messaging_contract_loading() {
let dump_file = UniqueAutoDeletableFile::new("dump");
let devnet_args = ["--dump-path", &dump_file.path, "--dump-on", "exit"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let anvil = BackgroundAnvil::spawn().await.unwrap();
devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.unwrap();
// assert loadability while Anvil is still alive
devnet.send_custom_rpc("devnet_dump", Value::Null).await.unwrap();
devnet.send_custom_rpc("devnet_load", json!({ "path": dump_file.path })).await.unwrap();
// assert loading fails if anvil not alive
send_ctrl_c_signal_and_wait(&anvil.process).await;
match devnet.send_custom_rpc("devnet_load", json!({ "path": dump_file.path })).await {
Err(RpcError { .. }) => {}
other => panic!("Unexpected response: {other:?}"),
};
}
#[tokio::test]
async fn flushing_only_new_messages_after_restart() {
let anvil = BackgroundAnvil::spawn().await.unwrap();
let (devnet, sn_account, sn_l1l2_contract) = setup_devnet(&[]).await.unwrap();
// Load l1 messaging contract.
let load_resp = devnet
.send_custom_rpc("devnet_postmanLoad", json!({ "network_url": anvil.url }))
.await
.unwrap();
assert_eq!(
load_resp.get("messaging_contract_address").unwrap().as_str().unwrap(),
MESSAGING_L1_ADDRESS
);
// Deploy the L1L2 testing contract on L1 (on L2 it's already pre-deployed).
let l1_messaging_address = Address::from_hex(MESSAGING_L1_ADDRESS).unwrap();
let eth_l1l2_address = anvil.deploy_l1l2_contract(l1_messaging_address).await.unwrap();
let eth_l1l2_address_hex = format!("{eth_l1l2_address:#x}");
let eth_l1l2_address_felt = Felt::from_hex_unchecked(ð_l1l2_address_hex);
let user_sn = Felt::ONE;
let user_eth: U256 = U256::ONE;
// Set balance to for the user 1 on L2.
let user_balance = Felt::TWO;
increase_balance(sn_account.clone(), sn_l1l2_contract, user_sn, user_balance).await.unwrap();
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [user_balance]);
// Withdraw on L2 to send it to L1 with a l2->l1 message.
withdraw(sn_account.clone(), sn_l1l2_contract, user_sn, user_balance, eth_l1l2_address_felt)
.await
.unwrap();
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ZERO]);
// Flush to send the messages.
devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.unwrap();
// Check that the balance is 0 on L1 before consuming the message.
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
assert_eq!(user_balance_eth, U256::ZERO);
let sn_l1l2_contract_u256 = felt_to_u256(sn_l1l2_contract);
// Consume the message to increase the balance.
anvil
.withdraw_l1l2(
eth_l1l2_address,
sn_l1l2_contract_u256,
user_eth,
felt_to_u256(user_balance),
)
.await
.unwrap();
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
assert_eq!(user_balance_eth, felt_to_u256(user_balance));
// Send back the amount 1 to the user 1 on L2.
let deposit_amount = U256::ONE;
anvil
.deposit_l1l2(eth_l1l2_address, sn_l1l2_contract_u256, user_eth, deposit_amount)
.await
.unwrap();
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
assert_eq!(user_balance_eth, U256::ONE); // 2 - 1
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ZERO]);
// Flush messages to have MessageToL2 executed.
devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.unwrap();
let user_balance_eth = anvil.get_balance_l1l2(eth_l1l2_address, user_eth).await.unwrap();
assert_eq!(user_balance_eth, deposit_amount);
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ONE]);
// Restart Devnet, l1-l2 messaging should be intact
devnet.restart().await;
// Make sure flushing doesn't process old messages
let flush_after_restart =
devnet.send_custom_rpc("devnet_postmanFlush", json!({})).await.unwrap();
assert_eq!(flush_after_restart["messages_to_l1"], json!([]));
assert_eq!(flush_after_restart["messages_to_l2"], json!([]));
// Redeploy
let sn_l1l2_contract = deploy_l2_msg_contract(sn_account).await.unwrap();
let sn_l1l2_contract_u256 = felt_to_u256(sn_l1l2_contract);
assert_eq!(get_balance(&devnet, sn_l1l2_contract, user_sn).await.unwrap(), [Felt::ZERO]);
// Trigger a new action to return funds to L2
anvil
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | true |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_estimate_message_fee.rs | tests/integration/test_estimate_message_fee.rs | use std::sync::Arc;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{BlockId, BlockTag, EthAddress, Felt, MsgFromL1, StarknetError};
use starknet_rs_core::utils::{UdcUniqueness, get_udc_deployed_address};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{CHAIN_ID, L1_HANDLER_SELECTOR, MESSAGING_WHITELISTED_L1_CONTRACT};
use crate::common::utils::{get_messaging_contract_artifacts, new_contract_factory};
#[tokio::test]
async fn estimate_message_fee() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
// get class
let (contract_artifact, casm_hash) = get_messaging_contract_artifacts();
let contract_artifact = Arc::new(contract_artifact);
let class_hash = contract_artifact.class_hash();
// declare class
account.declare_v3(contract_artifact, casm_hash).nonce(Felt::ZERO).send().await.unwrap();
// deploy instance of class
let contract_factory = new_contract_factory(class_hash, account.clone());
let salt = Felt::from_hex_unchecked("0x123");
let constructor_calldata = vec![];
let contract_address = get_udc_deployed_address(
salt,
class_hash,
&UdcUniqueness::NotUnique,
&constructor_calldata,
);
contract_factory
.deploy_v3(constructor_calldata, salt, false)
.nonce(Felt::ONE)
.send()
.await
.expect("Cannot deploy");
let res = devnet
.json_rpc_client
.estimate_message_fee(
MsgFromL1 {
from_address: EthAddress::from_hex(MESSAGING_WHITELISTED_L1_CONTRACT).unwrap(),
to_address: contract_address,
entry_point_selector: Felt::from_hex_unchecked(L1_HANDLER_SELECTOR),
payload: [(1_u32).into(), (10_u32).into()].to_vec(),
},
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap();
assert_eq!(res.l1_gas_consumed, 16030);
assert_eq!(res.l2_gas_consumed, 0);
}
#[tokio::test]
async fn estimate_message_fee_contract_not_found() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let err = devnet
.json_rpc_client
.estimate_message_fee(
MsgFromL1 {
from_address: EthAddress::from_hex(MESSAGING_WHITELISTED_L1_CONTRACT).unwrap(),
to_address: Felt::ONE,
entry_point_selector: Felt::from_hex_unchecked(L1_HANDLER_SELECTOR),
payload: [(1_u32).into(), (10_u32).into()].to_vec(),
},
BlockId::Tag(BlockTag::Latest),
)
.await
.expect_err("Error expected");
match err {
ProviderError::StarknetError(StarknetError::ContractNotFound) => (),
_ => panic!("Invalid error: {err:?}"),
}
}
#[tokio::test]
async fn estimate_message_fee_block_not_found() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let err = devnet
.json_rpc_client
.estimate_message_fee(
MsgFromL1 {
from_address: EthAddress::from_hex(MESSAGING_WHITELISTED_L1_CONTRACT).unwrap(),
to_address: Felt::ONE,
entry_point_selector: Felt::from_hex_unchecked(L1_HANDLER_SELECTOR),
payload: [(1_u32).into(), (10_u32).into()].to_vec(),
},
BlockId::Number(101),
)
.await
.expect_err("Error expected");
match err {
ProviderError::StarknetError(StarknetError::BlockNotFound) => (),
_ => panic!("Invalid error: {err:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_to_blocks.rs | tests/integration/test_subscription_to_blocks.rs | use std::collections::HashMap;
use std::time::Duration;
use serde_json::json;
use starknet_core::constants::ETH_ERC20_CONTRACT_ADDRESS;
use starknet_rs_core::types::{BlockId, BlockTag};
use starknet_rs_providers::Provider;
use tokio::net::TcpStream;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, connect_async};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::MAINNET_HTTPS_URL;
use crate::common::errors::RpcError;
use crate::common::utils::{
SubscriptionId, assert_no_notifications, receive_notification, subscribe_new_heads, unsubscribe,
};
async fn receive_block(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
subscription_id: SubscriptionId,
) -> Result<serde_json::Value, anyhow::Error> {
receive_notification(ws, "starknet_subscriptionNewHeads", subscription_id).await
}
#[tokio::test]
async fn subscribe_to_new_block_heads_happy_path() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_heads(&mut ws, json!({})).await.unwrap();
// test with multiple blocks created, number 0 was origin, so we start at 1
for block_i in 1..=2 {
let created_block_hash = devnet.create_block().await.unwrap();
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_block["block_hash"], json!(created_block_hash));
assert_eq!(notification_block["block_number"], json!(block_i));
}
}
#[tokio::test]
async fn should_not_receive_block_notification_if_not_subscribed() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
devnet.create_block().await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn multiple_block_subscribers_happy_path() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let n_subscribers = 5;
let mut subscribers = HashMap::new();
for _ in 0..n_subscribers {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_heads(&mut ws, json!({})).await.unwrap();
subscribers.insert(subscription_id, ws);
}
assert_eq!(subscribers.len(), n_subscribers); // assert all IDs are different
let created_block_hash = devnet.create_block().await.unwrap();
for (subscription_id, mut ws) in subscribers {
let notification_block = receive_block(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_block["block_hash"], json!(created_block_hash));
assert_eq!(notification_block["block_number"], json!(1));
}
}
#[tokio::test]
async fn subscription_to_an_old_block_by_number_should_notify_of_all_blocks_up_to_latest() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let n_blocks = 5;
for _ in 0..n_blocks {
devnet.create_block().await.unwrap();
}
// request notifications for all blocks starting with genesis
let subscription_id =
subscribe_new_heads(&mut ws, json!({ "block_id": BlockId::Number(0) })).await.unwrap();
for block_i in 0..=n_blocks {
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_block["block_number"], json!(block_i));
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn subscription_to_an_old_block_by_hash_should_notify_of_all_blocks_up_to_latest() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let genesis_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let n_blocks = 5;
for _ in 0..n_blocks {
devnet.create_block().await.unwrap();
}
// request notifications for all blocks starting with genesis
let subscription_id =
subscribe_new_heads(&mut ws, json!({ "block_id": BlockId::Hash(genesis_block.block_hash)}))
.await
.unwrap();
let starting_block = 0;
for block_i in starting_block..=n_blocks {
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_block["block_number"], json!(block_i));
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn assert_latest_block_is_default() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws_latest, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut ws_default, _) = connect_async(devnet.ws_url()).await.unwrap();
// create two subscriptions: one to latest, one without block (thus defaulting)
let subscription_id_latest =
subscribe_new_heads(&mut ws_latest, json!({ "block_id": "latest" })).await.unwrap();
let subscription_id_default = subscribe_new_heads(&mut ws_default, json!({})).await.unwrap();
assert_ne!(subscription_id_latest, subscription_id_default);
devnet.create_block().await.unwrap();
let notification_block_latest =
receive_block(&mut ws_latest, subscription_id_latest).await.unwrap();
assert_no_notifications(&mut ws_latest).await.unwrap();
let notification_block_default =
receive_block(&mut ws_default, subscription_id_default).await.unwrap();
assert_no_notifications(&mut ws_default).await.unwrap();
assert_eq!(notification_block_latest, notification_block_default);
}
#[tokio::test]
async fn test_multiple_subscribers_one_unsubscribes() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let n_subscribers = 3;
let mut subscribers = HashMap::new();
for _ in 0..n_subscribers {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_heads(&mut ws, json!({})).await.unwrap();
subscribers.insert(subscription_id, ws);
}
assert_eq!(subscribers.len(), n_subscribers); // assert all IDs are different
// randomly choose one subscriber for unsubscription
let unsubscriber_id = subscribers.keys().next().cloned().expect("Should have at least one");
// unsubscribe
let mut unsubscriber_ws = subscribers.remove(&unsubscriber_id).unwrap();
let unsubscription_resp = unsubscribe(&mut unsubscriber_ws, unsubscriber_id).await.unwrap();
assert_eq!(unsubscription_resp, json!({ "jsonrpc": "2.0", "id": 0, "result": true }));
// create block and assert only subscribers are notified
let created_block_hash = devnet.create_block().await.unwrap();
for (subscription_id, mut ws) in subscribers {
let notification_block = receive_block(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_block["block_hash"], json!(created_block_hash));
}
assert_no_notifications(&mut unsubscriber_ws).await.unwrap();
}
#[tokio::test]
async fn test_unsubscribing_invalid_id() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let unsubscription_resp = unsubscribe(&mut ws, "123".to_string()).await.unwrap();
assert_eq!(
unsubscription_resp,
json!({
"jsonrpc": "2.0",
"id": 0,
"error": {
"code": 66,
"message": "Invalid subscription id",
}
})
);
}
#[tokio::test]
async fn read_only_methods_do_not_generate_notifications() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
subscribe_new_heads(&mut ws, json!({})).await.unwrap();
devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), ETH_ERC20_CONTRACT_ADDRESS)
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_notifications_in_block_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_heads(&mut ws, json!({})).await.unwrap();
let dummy_address = 0x1;
devnet.mint(dummy_address, 1).await;
assert_no_notifications(&mut ws).await.unwrap();
let created_block_hash = devnet.create_block().await.unwrap();
let notification_block = receive_block(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_block["block_hash"], json!(created_block_hash));
assert_eq!(notification_block["block_number"], json!(1));
}
#[tokio::test]
async fn test_notifications_on_periodic_block_generation() {
let interval = 3;
let devnet_args = ["--block-generation-on", &interval.to_string()];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_heads(&mut ws, json!({})).await.unwrap();
// this assertion is skipped due to CI instability
// assert_no_notifications(&mut ws).await;
// should be enough time for Devnet to mine a single new block
tokio::time::sleep(Duration::from_secs(interval + 1)).await;
let notification_block = receive_block(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_block["block_number"], json!(1));
// this assertion is skipped due to CI instability
// assert_no_notifications(&mut ws).await;
}
#[tokio::test]
async fn test_fork_subscription_to_blocks_starting_from_origin() {
// Setup original devnet with some blocks
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
// Create some blocks in origin
let n_origin_blocks = 3;
let mut origin_block_hashes = Vec::new();
for _ in 0..n_origin_blocks {
origin_block_hashes.push(origin_devnet.create_block().await.unwrap());
}
// Fork the devnet
let fork_devnet = origin_devnet.fork().await.unwrap();
// Create some blocks in the forked devnet before subscribing
let n_fork_blocks_before_subscription = 2;
let mut fork_block_hashes_before_subscription = Vec::new();
for _ in 0..n_fork_blocks_before_subscription {
let block_hash = fork_devnet.create_block().await.unwrap();
fork_block_hashes_before_subscription.push(block_hash);
}
// Subscribe to blocks starting from genesis (block 0)
let (mut ws, _) = connect_async(fork_devnet.ws_url()).await.unwrap();
let subscription_id =
subscribe_new_heads(&mut ws, json!({ "block_id": BlockId::Number(0) })).await.unwrap();
// We should receive notifications for all blocks from origin (0 to n_origin_blocks)
for block_i in 0..=n_origin_blocks {
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_block["block_number"], json!(block_i));
// Check if the block hash matches for non-genesis blocks
if block_i > 0 {
let expected_hash = origin_block_hashes[block_i - 1];
assert_eq!(notification_block["block_hash"], json!(expected_hash));
}
}
// Devnet creates an empty block after forking, so we receive one more block notification
let empty_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
let empty_block_number = n_origin_blocks + 1;
assert_eq!(empty_block["block_number"], json!(empty_block_number));
// We should also receive notifications for blocks created in the forked devnet before
// subscription
for (i, expected_hash) in fork_block_hashes_before_subscription.iter().enumerate() {
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
let expected_block_number = n_origin_blocks + i + 2; // +1 for genesis, +1 for empty block
assert_eq!(notification_block["block_number"], json!(expected_block_number));
assert_eq!(notification_block["block_hash"], json!(expected_hash));
}
// Create additional blocks in the forked devnet after subscription and verify notifications
let n_fork_blocks_after_subscription = 2;
for i in 0..n_fork_blocks_after_subscription {
let created_block_hash = fork_devnet.create_block().await.unwrap();
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
// Verify the new block notification
assert_eq!(notification_block["block_hash"], json!(created_block_hash));
// Block number calculation: origin blocks + empty block + pre-subscription blocks + new
// blocks
let expected_block_number = n_origin_blocks + 1 + n_fork_blocks_before_subscription + i + 1;
assert_eq!(notification_block["block_number"], json!(expected_block_number));
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_fork_subscription_to_blocks_by_hash() {
// Setup original devnet with some blocks
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
// Create some blocks in origin
let n_origin_blocks = 3;
let mut origin_blocks = Vec::new();
// Get genesis block
let genesis_block = origin_devnet.get_latest_block_with_tx_hashes().await.unwrap();
origin_blocks.push(genesis_block.clone());
// Create blocks and store their info
for _ in 0..n_origin_blocks {
let block_hash = origin_devnet.create_block().await.unwrap();
let block = origin_devnet
.get_confirmed_block_with_tx_hashes(&BlockId::Hash(block_hash))
.await
.unwrap();
origin_blocks.push(block);
}
// Fork the devnet
let fork_devnet = origin_devnet.fork().await.unwrap();
// Pick a block in the middle to start subscription from
let start_block_idx = 1; // Start from the first non-genesis block
let start_block = &origin_blocks[start_block_idx];
// Subscribe to blocks starting from this specific block
let (mut ws, _) = connect_async(fork_devnet.ws_url()).await.unwrap();
let subscription_id =
subscribe_new_heads(&mut ws, json!({ "block_id": BlockId::Hash(start_block.block_hash) }))
.await
.unwrap();
// We should receive notifications for all blocks from start_block to latest
for (i, block) in origin_blocks.iter().enumerate().skip(start_block_idx) {
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_block["block_number"], json!(i));
assert_eq!(notification_block["block_hash"], json!(block.block_hash));
}
// Devnet creates an empty block after forking, so we receive one more block notification
let empty_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
let empty_block_number = n_origin_blocks + 1;
assert_eq!(empty_block["block_number"], json!(empty_block_number));
// Create additional blocks in the forked devnet and verify notifications
let n_fork_blocks = 2;
for i in 0..n_fork_blocks {
let created_block_hash = fork_devnet.create_block().await.unwrap();
let notification_block = receive_block(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_block["block_hash"], json!(created_block_hash));
assert_eq!(notification_block["block_number"], json!(n_origin_blocks + i + 2)); // +1 for empty block
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_fork_subscription_to_old_blocks_should_fail() {
// Setup original devnet with some blocks
let origin_url = MAINNET_HTTPS_URL;
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&["--fork-network", origin_url])
.await
.unwrap();
let latest_block_number =
fork_devnet.get_latest_block_with_tx_hashes().await.unwrap().block_number;
// Ensure we have enough blocks to properly test the out-of-range condition
assert!(
latest_block_number >= 1025,
"Test requires at least 1025 blocks to validate out-of-range behavior, but got {}",
latest_block_number
);
let (mut ws, _) = connect_async(fork_devnet.ws_url()).await.unwrap();
// Pick a block outside range (1025 blocks back from latest)
let subscription_error = subscribe_new_heads(
&mut ws,
json!({ "block_id": BlockId::Number(latest_block_number - 1025) }),
)
.await
.unwrap_err();
let rpc_error = subscription_error.downcast::<RpcError>().unwrap();
assert_eq!(
rpc_error,
RpcError { code: 68, message: "Cannot go back more than 1024 blocks".into(), data: None }
);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/get_transaction_by_block_id_and_index.rs | tests/integration/get_transaction_by_block_id_and_index.rs | use starknet_rs_core::types::{
BlockId, BlockTag, Felt, InvokeTransaction, StarknetError, Transaction,
};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
#[tokio::test]
async fn get_transaction_by_block_id_and_index_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let minting_hash = devnet.mint(Felt::ONE, 1).await;
let result = devnet
.json_rpc_client
.get_transaction_by_block_id_and_index(BlockId::Tag(BlockTag::Latest), 0)
.await
.unwrap();
if let Transaction::Invoke(InvokeTransaction::V3(tx)) = result {
assert_eq!(tx.transaction_hash, minting_hash);
} else {
panic!("Could not unpack the transaction from {result:?}");
}
}
#[tokio::test]
async fn get_transaction_by_block_id_and_index_wrong_index() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
devnet.mint(Felt::ONE, 1).await;
let result = devnet
.json_rpc_client
.get_transaction_by_block_id_and_index(BlockId::Tag(BlockTag::Latest), 1)
.await
.unwrap_err();
match result {
ProviderError::StarknetError(StarknetError::InvalidTransactionIndex) => (),
_ => panic!("Invalid error: {result:?}"),
}
}
#[tokio::test]
async fn get_transaction_by_block_id_and_index_wrong_block() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let result = devnet
.json_rpc_client
.get_transaction_by_block_id_and_index(BlockId::Number(1), 1)
.await
.unwrap_err();
match result {
ProviderError::StarknetError(StarknetError::BlockNotFound) => (),
_ => panic!("Invalid error: {result:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_minting.rs | tests/integration/test_minting.rs | use anyhow::anyhow;
use serde_json::json;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::Felt;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
CHAIN_ID, PREDEPLOYED_ACCOUNT_ADDRESS, PREDEPLOYED_ACCOUNT_INITIAL_BALANCE,
};
use crate::common::utils::{FeeUnit, get_simple_contract_artifacts};
use crate::{assert_eq_prop, assert_prop};
static DUMMY_ADDRESS: &str = "0x42";
static DUMMY_AMOUNT: u128 = 42;
async fn increase_balance_happy_path(
address: &str,
init_amount: u128,
mint_amount: u128,
unit: FeeUnit,
) -> Result<(), anyhow::Error> {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let mut resp_body: serde_json::Value = devnet
.send_custom_rpc(
"devnet_mint",
json!({
"address": address,
"amount": mint_amount,
"unit": unit,
}),
)
.await?;
// tx hash is not constant so we just assert its general form
let tx_hash_value = resp_body["tx_hash"].take();
let tx_hash = tx_hash_value
.as_str()
.ok_or(anyhow!("failed to parse transaction hash"))?
.starts_with("0x");
assert_prop!(tx_hash, "Transaction hash does not start with '0x'")?;
let final_balance = Felt::from(init_amount) + Felt::from(mint_amount);
let expected_resp_body = json!({
"new_balance": final_balance.to_biguint().to_string(),
"unit": unit,
"tx_hash": null
});
assert_eq_prop!(resp_body, expected_resp_body)?;
let new_balance =
devnet.get_balance_latest(&Felt::from_hex_unchecked(address), unit).await.unwrap();
assert_eq_prop!(final_balance, new_balance)
}
#[tokio::test]
async fn increase_balance_of_undeployed_address_wei() {
increase_balance_happy_path(DUMMY_ADDRESS, 0, DUMMY_AMOUNT, FeeUnit::Wei).await.unwrap();
}
#[tokio::test]
async fn increase_balance_of_undeployed_address_fri() {
increase_balance_happy_path(DUMMY_ADDRESS, 0, DUMMY_AMOUNT, FeeUnit::Fri).await.unwrap();
}
#[tokio::test]
async fn increase_balance_of_undeployed_address_unit_not_specified() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let unit_not_specified = json!({ "address": DUMMY_ADDRESS, "amount": DUMMY_AMOUNT });
let mut resp_body: serde_json::Value =
devnet.send_custom_rpc("devnet_mint", unit_not_specified).await.unwrap();
let tx_hash_value = resp_body["tx_hash"].take();
// tx hash is not constant so we later just assert its general form
assert_eq!(
resp_body,
json!({
"new_balance": DUMMY_AMOUNT.to_string(),
"unit": "FRI",
"tx_hash": null
})
);
assert!(tx_hash_value.as_str().unwrap().starts_with("0x"));
}
#[tokio::test]
async fn increase_balance_of_predeployed_account() {
increase_balance_happy_path(
PREDEPLOYED_ACCOUNT_ADDRESS,
PREDEPLOYED_ACCOUNT_INITIAL_BALANCE,
DUMMY_AMOUNT,
FeeUnit::Wei,
)
.await
.unwrap()
}
#[tokio::test]
async fn increase_balance_of_predeployed_account_u256() {
increase_balance_happy_path(
PREDEPLOYED_ACCOUNT_ADDRESS,
PREDEPLOYED_ACCOUNT_INITIAL_BALANCE,
u128::MAX,
FeeUnit::Wei,
)
.await
.unwrap()
}
#[tokio::test]
async fn execute_v3_transaction_with_strk_token() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--initial-balance", "0"])
.await
.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let declare_result = predeployed_account
.declare_v3(std::sync::Arc::new(contract_class.clone()), casm_hash)
.send()
.await;
assert!(declare_result.is_err());
// 3. mint some FRI to the account
// Note: FeeUnit::Fri should be used for STRK tokens in this implementation
devnet.mint_unit(account_address, 1_000_000_000_000_000_000_000, FeeUnit::Fri).await;
let fri_balance = devnet.get_balance_latest(&account_address, FeeUnit::Fri).await.unwrap();
assert!(fri_balance > Felt::ZERO, "FRI balance should be positive after minting");
let declare_result =
predeployed_account.declare_v3(std::sync::Arc::new(contract_class), casm_hash).send().await;
assert!(declare_result.is_ok(), "Declare transaction should succeed after minting FRI tokens");
}
async fn reject_bad_minting_request(json_body: serde_json::Value) {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let rpc_error = devnet.send_custom_rpc("devnet_mint", json_body).await.unwrap_err();
assert_eq!(rpc_error.code, -32602, "Checking status of {rpc_error:?}");
}
#[tokio::test]
async fn reject_unknown_unit() {
reject_bad_minting_request(json!({
"address": DUMMY_ADDRESS,
"amount": DUMMY_AMOUNT,
"unit": "Satoshi"
}))
.await;
}
#[tokio::test]
async fn reject_negative_amount() {
reject_bad_minting_request(json!({ "address": DUMMY_ADDRESS, "amount": -1 })).await;
}
#[tokio::test]
async fn reject_missing_address() {
reject_bad_minting_request(json!({ "amount": DUMMY_AMOUNT })).await;
}
#[tokio::test]
async fn reject_missing_amount() {
reject_bad_minting_request(json!({ "address": DUMMY_ADDRESS })).await;
}
async fn reject_bad_json_rpc_request(devnet: &BackgroundDevnet, body: serde_json::Value) {
let rpc_error = devnet.send_custom_rpc("devnet_getAccountBalance", body).await.unwrap_err();
assert_eq!(rpc_error.code, -32602);
}
#[tokio::test]
async fn reject_if_no_params_when_querying() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
reject_bad_json_rpc_request(&devnet, json!({})).await;
}
#[tokio::test]
async fn reject_missing_address_when_querying() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
reject_bad_json_rpc_request(&devnet, json!({ "unit": "FRI" })).await;
}
#[tokio::test]
async fn reject_invalid_unit_when_querying() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
reject_bad_json_rpc_request(&devnet, json!({ "address": "0x1", "unit": "INVALID" })).await;
}
#[tokio::test]
async fn test_overflow_behavior() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// Sending a random too big value to a random address
let mint_err = devnet
.send_custom_rpc(
"devnet_mint",
serde_json::from_str(r#"{
"address": "0x1",
"amount": 72370055773322622139731865630429942408293740416025352524660990004945706024960,
"unit": "FRI"
}"#).unwrap()
)
.await
.unwrap_err();
// The complete error also contains the tx hash, which cannot be asserted in a stable way.
assert_eq!(
(
mint_err.code,
mint_err.message,
mint_err.data.unwrap()["revert_reason"].as_str().unwrap()
),
(
-1,
"Minting reverted".into(),
"The requested minting amount overflows the token contract's total_supply."
)
);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_to_reorg.rs | tests/integration/test_subscription_to_reorg.rs | use std::collections::{HashMap, HashSet};
use serde_json::json;
use starknet_rs_core::types::BlockId;
use tokio_tungstenite::connect_async;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::utils::{
SubscriptionId, assert_no_notifications, receive_rpc_via_ws, subscribe, unsubscribe,
};
#[tokio::test]
async fn reorg_notification_for_all_subscriptions() {
let devnet_args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
// create blocks for later abortion
let starting_block_hash = devnet.create_block().await.unwrap();
let ending_block_hash = devnet.create_block().await.unwrap();
let mut notifiable_subscribers = HashMap::new();
for (subscription_method, subscription_params) in [
("starknet_subscribeNewHeads", json!({})),
("starknet_subscribeTransactionStatus", json!({ "transaction_hash": "0x1" })),
("starknet_subscribeEvents", json!({})),
("starknet_subscribeNewTransactions", json!({})),
("starknet_subscribeNewTransactionReceipts", json!({})),
] {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id =
subscribe(&mut ws, subscription_method, subscription_params).await.unwrap();
notifiable_subscribers.insert(subscription_id, ws);
}
// assert that block-, tx_status- and event-subscribers got notified; unsubscribe them
devnet.abort_blocks(&BlockId::Hash(starting_block_hash)).await.unwrap();
for (subscription_id, ws) in notifiable_subscribers.iter_mut() {
let notification = receive_rpc_via_ws(ws).await.unwrap();
assert_eq!(
notification,
json!({
"jsonrpc": "2.0",
"method": "starknet_subscriptionReorg",
"params": {
"result": {
"starting_block_hash": starting_block_hash,
"starting_block_number": 1,
"ending_block_hash": ending_block_hash,
"ending_block_number": 2,
},
"subscription_id": subscription_id,
}
})
);
unsubscribe(ws, subscription_id.clone()).await.unwrap();
}
// now that all sockets are unsubscribed, abort a new block and assert no notifications
let additional_block_hash = devnet.create_block().await.unwrap();
devnet.abort_blocks(&BlockId::Hash(additional_block_hash)).await.unwrap();
for (_, mut ws) in notifiable_subscribers {
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn socket_with_n_subscriptions_should_get_n_reorg_notifications() {
let devnet_args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let created_block_hash = devnet.create_block().await.unwrap();
// Create one socket with n subscriptions.
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let mut subscription_ids = vec![];
for subscription_method in ["starknet_subscribeNewHeads", "starknet_subscribeEvents"] {
let subscription_id = subscribe(&mut ws, subscription_method, json!({})).await.unwrap();
subscription_ids.push(subscription_id);
}
// Trigger reorg.
devnet.abort_blocks(&BlockId::Hash(created_block_hash)).await.unwrap();
// Assert n reorg notifications received. The notifications only differ in subscription_id.
let mut notification_ids = HashSet::new();
for _ in subscription_ids.iter() {
let mut notification = receive_rpc_via_ws(&mut ws).await.unwrap();
// Reorg notifications may be received in any order. To assert one reorg subscription
// was received per subscription_id, we extract the IDs from notifications, store them
// in a set, and later assert equality with the set of expected subscription IDs.
// .take() method removes the property from serde_json::Value.
// This is intentional, because notifications do not come in deterministic order
// and we cant assert the exact notification id in the loop.
let notification_id = notification["params"]["subscription_id"]
.take()
.as_str()
.unwrap()
.parse::<SubscriptionId>()
.unwrap();
notification_ids.insert(notification_id);
assert_eq!(
notification,
json!({
"jsonrpc": "2.0",
"method": "starknet_subscriptionReorg",
"params": {
"result": {
"starting_block_hash": created_block_hash,
"starting_block_number": 1,
"ending_block_hash": created_block_hash,
"ending_block_number": 1,
},
"subscription_id": null,
}
})
);
}
assert_eq!(notification_ids, HashSet::from_iter(subscription_ids));
assert_no_notifications(&mut ws).await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_fork.rs | tests/integration/test_fork.rs | use std::str::FromStr;
use std::sync::Arc;
use starknet_rs_accounts::{
Account, AccountFactory, AccountFactoryError, ExecutionEncoding, OpenZeppelinAccountFactory,
SingleOwnerAccount,
};
use starknet_rs_core::types::{
BlockId, BlockTag, Call, ContractClass, DeclareTransaction, Felt, FunctionCall,
MaybePreConfirmedBlockWithTxHashes, StarknetError, Transaction,
};
use starknet_rs_core::utils::{
get_selector_from_name, get_storage_var_address, get_udc_deployed_address,
};
use starknet_rs_providers::{Provider, ProviderError};
use starknet_rs_signers::Signer;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_1_ACCOUNT_CONTRACT_0_8_0_SIERRA_PATH, ETH_ERC20_CONTRACT_CLASS_HASH,
INTEGRATION_GENESIS_BLOCK_HASH, INTEGRATION_SAFE_BLOCK, INTEGRATION_SEPOLIA_HTTP_URL,
MAINNET_HTTPS_URL, MAINNET_URL, STRK_ERC20_CONTRACT_CLASS_HASH,
};
use crate::common::utils::{
FeeUnit, assert_cairo1_classes_equal, assert_contains, assert_tx_succeeded_accepted,
declare_v3_deploy_v3, extract_json_rpc_error, get_block_reader_contract_artifacts,
get_contract_balance, get_simple_contract_artifacts, new_contract_factory,
send_ctrl_c_signal_and_wait,
};
#[tokio::test]
async fn test_fork_status() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let origin_devnet_config = origin_devnet.get_config().await;
assert_eq!(
origin_devnet_config["fork_config"],
serde_json::json!({ "url": null, "block_number": null })
);
let fork_devnet = origin_devnet.fork().await.unwrap();
let fork_devnet_config = fork_devnet.get_config().await;
let fork_devnet_fork_config = &fork_devnet_config["fork_config"];
assert_eq!(
url::Url::from_str(fork_devnet_fork_config["url"].as_str().unwrap()).unwrap(),
url::Url::from_str(&origin_devnet.url).unwrap()
);
assert_eq!(fork_devnet_fork_config["block_number"].as_i64().unwrap(), 0);
}
#[tokio::test]
async fn test_forking_sepolia_genesis_block() {
let fork_block = &INTEGRATION_SAFE_BLOCK.to_string();
let cli_args = ["--fork-network", INTEGRATION_SEPOLIA_HTTP_URL, "--fork-block", fork_block];
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let block_hash = BlockId::Hash(Felt::from_hex_unchecked(INTEGRATION_GENESIS_BLOCK_HASH));
let resp = &fork_devnet.json_rpc_client.get_block_with_tx_hashes(block_hash).await;
match resp {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(b)) => assert_eq!(b.block_number, 0),
_ => panic!("Unexpected resp: {resp:?}"),
};
}
#[tokio::test]
async fn test_getting_non_existent_block_from_origin() {
let fork_block = &INTEGRATION_SAFE_BLOCK.to_string();
let cli_args = ["--fork-network", INTEGRATION_SEPOLIA_HTTP_URL, "--fork-block", fork_block];
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let non_existent_block_hash = "0x123456";
let resp = &fork_devnet
.json_rpc_client
.get_block_with_tx_hashes(BlockId::Hash(Felt::from_hex_unchecked(non_existent_block_hash)))
.await;
match resp {
Err(ProviderError::StarknetError(StarknetError::BlockNotFound)) => (),
_ => panic!("Unexpected resp: {resp:?}"),
}
}
#[tokio::test]
async fn test_forking_local_genesis_block() {
let origin_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.unwrap();
let origin_devnet_genesis_block =
&origin_devnet.get_latest_block_with_tx_hashes().await.unwrap();
let block_hash = origin_devnet.create_block().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let resp_block_by_hash =
&fork_devnet.json_rpc_client.get_block_with_tx_hashes(BlockId::Hash(block_hash)).await;
match resp_block_by_hash {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(b)) => assert_eq!(b.block_number, 1),
_ => panic!("Unexpected resp: {resp_block_by_hash:?}"),
};
let resp_latest_block = &fork_devnet.get_latest_block_with_tx_hashes().await;
match resp_latest_block {
Ok(b) => {
assert_eq!(b.block_number, 2);
assert_ne!(b.block_hash, origin_devnet_genesis_block.block_hash);
}
_ => panic!("Unexpected resp: {resp_latest_block:?}"),
};
}
#[tokio::test]
async fn test_forked_account_balance() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
// new origin block
let dummy_address = Felt::ONE;
let mint_amount = 100;
origin_devnet.mint(dummy_address, mint_amount).await;
let fork_devnet = origin_devnet.fork().await.unwrap();
// new fork block
fork_devnet.mint(dummy_address, mint_amount).await;
for block_i in 0..=1 {
let block_id = BlockId::Number(block_i);
let balance = fork_devnet.get_balance_at_block(&dummy_address, block_id).await.unwrap();
let expected_balance = (block_i as u128 * mint_amount).into();
assert_eq!(balance, expected_balance);
}
// not using get_balance_at_block=2: requires forking with --state-archive-capacity full
let final_balance = fork_devnet.get_balance_latest(&dummy_address, FeeUnit::Fri).await.unwrap();
let expected_final_balance = (2_u128 * mint_amount).into();
assert_eq!(final_balance, expected_final_balance);
}
#[tokio::test]
/// Using a fork of a real network because Devnet no longer accepts Cairo 0 class declaration
async fn test_getting_cairo0_class_from_fork() {
let forked_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--fork-network", MAINNET_URL])
.await
.unwrap();
let class_hash = Felt::from_hex_unchecked(
"0x0523be5e7088bf4226d4fdb28c6a19d4d3b93118f7263849a6d8912bf503d672",
);
let _retrieved_class = forked_devnet
.json_rpc_client
.get_class(BlockId::Tag(BlockTag::Latest), class_hash)
.await
.unwrap();
// assert_eq!(retrieved_class, ContractClass::Legacy(contract_class.compress().unwrap()));
// TODO For now, successfully unwrapping the retrieved class serves as proof of correctness.
// Currently asserting cairo0 artifacts is failing; related: https://github.com/0xSpaceShard/starknet-devnet/pull/380
}
#[tokio::test]
async fn test_getting_cairo1_class_from_origin_and_fork() {
let origin_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.unwrap();
let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&origin_devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let initial_value = Felt::from(10_u32);
let ctor_args = vec![initial_value];
let (class_hash, contract_address) =
declare_v3_deploy_v3(&predeployed_account, contract_class.clone(), casm_hash, &ctor_args)
.await
.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let retrieved_class_hash = fork_devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.unwrap();
assert_eq!(retrieved_class_hash, class_hash);
let expected_sierra = ContractClass::Sierra(contract_class);
let retrieved_class_by_hash = fork_devnet
.json_rpc_client
.get_class(BlockId::Tag(BlockTag::Latest), class_hash)
.await
.unwrap();
assert_cairo1_classes_equal(&retrieved_class_by_hash, &expected_sierra).unwrap();
let retrieved_class_by_address = fork_devnet
.json_rpc_client
.get_class_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.unwrap();
assert_cairo1_classes_equal(&retrieved_class_by_address, &expected_sierra).unwrap();
}
#[tokio::test]
async fn test_origin_declare_deploy_fork_invoke() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
origin_devnet.clone_provider(),
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
));
let (contract_class, casm_class_hash) = get_simple_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(contract_class), casm_class_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
// deploy the contract
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
let initial_value = Felt::from(10_u32);
let ctor_args = vec![initial_value];
contract_factory
.deploy_v3(ctor_args.clone(), Felt::ZERO, false)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
Felt::ZERO,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&ctor_args,
);
// assert correctly deployed
let origin_balance = get_contract_balance(&origin_devnet, contract_address).await.unwrap();
assert_eq!(origin_balance, initial_value);
let fork_devnet = origin_devnet.fork().await.unwrap();
let fork_balance = get_contract_balance(&fork_devnet, contract_address).await.unwrap();
assert_eq!(fork_balance, initial_value);
let fork_predeployed_account = SingleOwnerAccount::new(
fork_devnet.clone_provider(),
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// invoke on forked devnet
let increment = Felt::from(5_u32);
let contract_invoke = vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![increment, Felt::ZERO],
}];
let invoke_result = fork_predeployed_account
.execute_v3(contract_invoke.clone())
.l1_gas(0)
.l1_data_gas(1e3 as u64)
.l2_gas(1e7 as u64)
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&invoke_result.transaction_hash, &fork_devnet.json_rpc_client)
.await
.unwrap();
// assert origin intact and fork changed
let origin_balance = get_contract_balance(&origin_devnet, contract_address).await.unwrap();
assert_eq!(origin_balance, initial_value);
let fork_balance = get_contract_balance(&fork_devnet, contract_address).await.unwrap();
assert_eq!(fork_balance, initial_value + increment);
}
#[tokio::test]
async fn test_deploying_account_with_class_not_present_on_origin() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let (signer, _) = origin_devnet.get_first_predeployed_account().await;
let nonexistent_class_hash = Felt::from_hex_unchecked("0x123");
let factory = OpenZeppelinAccountFactory::new(
nonexistent_class_hash,
constants::CHAIN_ID,
signer,
fork_devnet.clone_provider(),
)
.await
.unwrap();
let salt = Felt::from_hex_unchecked("0x123");
let deployment = factory
.deploy_v3(salt)
.l1_gas(1e6 as u64)
.l1_data_gas(1e6 as u64)
.l2_gas(1e6 as u64)
.send()
.await;
match deployment {
Err(AccountFactoryError::Provider(ProviderError::StarknetError(
StarknetError::ClassHashNotFound,
))) => (),
unexpected => panic!("Unexpected resp: {unexpected:?}"),
}
}
#[tokio::test]
/// For this test to make sense, origin must have a class not by default present in the fork.
/// If https://github.com/0xSpaceShard/starknet-devnet/issues/373 is addressed,
/// both origin and fork have both of our default cairo0 and cairo1 classes, so using them for
/// this test wouldn't make sense, as we couldn't be sure that the class used in account
/// deployment is indeed coming from the origin.
async fn test_deploying_account_with_class_present_on_origin() {
let origin_devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--state-archive-capacity",
"full",
"--account-class-custom",
CAIRO_1_ACCOUNT_CONTRACT_0_8_0_SIERRA_PATH,
])
.await
.unwrap();
let (signer, _) = origin_devnet.get_first_predeployed_account().await;
// fork, but first create a forkable origin block
origin_devnet.create_block().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
// deploy account using class from origin, relying on precalculated hash
let account_hash = "0x00f7f9cd401ad39a09f095001d31f0ad3fdc2f4e532683a84a8a6c76150de858";
let factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(account_hash),
constants::CHAIN_ID,
signer,
fork_devnet.clone_provider(),
)
.await
.unwrap();
let salt = Felt::from_hex_unchecked("0x123");
let deployment =
factory.deploy_v3(salt).l1_gas(1e6 as u64).l1_data_gas(1e6 as u64).l2_gas(1e6 as u64);
let deployment_address = deployment.address();
fork_devnet.mint(deployment_address, 1e18 as u128).await;
deployment.send().await.unwrap();
}
#[tokio::test]
async fn test_get_nonce_if_contract_not_deployed() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let dummy_address = Felt::ONE;
match fork_devnet.json_rpc_client.get_nonce(BlockId::Tag(BlockTag::Latest), dummy_address).await
{
Err(ProviderError::StarknetError(StarknetError::ContractNotFound)) => (),
unexpected => panic!("Unexpected resp: {unexpected:?}"),
}
}
#[tokio::test]
async fn test_get_nonce_if_contract_deployed_on_origin() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let (_, account_address) = origin_devnet.get_first_predeployed_account().await;
let nonce = fork_devnet
.json_rpc_client
.get_nonce(BlockId::Tag(BlockTag::Latest), account_address)
.await
.unwrap();
assert_eq!(nonce, Felt::ZERO);
}
#[tokio::test]
async fn test_get_storage_if_contract_not_deployed() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let dummy_address = Felt::ONE;
let dummy_key = Felt::ONE;
match fork_devnet
.json_rpc_client
.get_storage_at(dummy_address, dummy_key, BlockId::Tag(BlockTag::Latest))
.await
{
Err(ProviderError::StarknetError(StarknetError::ContractNotFound)) => (),
unexpected => panic!("Unexpected resp: {unexpected:?}"),
}
}
#[tokio::test]
async fn test_get_storage_if_contract_deployed_on_origin() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
let dummy_key = Felt::ONE;
let dummy_value = fork_devnet
.json_rpc_client
.get_storage_at(account_address, dummy_key, BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
assert_eq!(dummy_value, Felt::ZERO);
let real_key = get_storage_var_address("Account_public_key", &[]).unwrap();
let real_value = fork_devnet
.json_rpc_client
.get_storage_at(account_address, real_key, BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
assert_eq!(real_value, signer.get_public_key().await.unwrap().scalar());
}
#[tokio::test]
async fn test_deploying_on_origin_calling_on_fork() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
// obtain account for deployment
let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&origin_devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let initial_value = Felt::from(10_u32);
let ctor_args = vec![initial_value];
let (_, contract_address) =
declare_v3_deploy_v3(&predeployed_account, contract_class.clone(), casm_hash, &ctor_args)
.await
.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let entry_point_selector = get_selector_from_name("get_balance").unwrap();
let call_result = fork_devnet
.json_rpc_client
.call(
FunctionCall { contract_address, entry_point_selector, calldata: vec![] },
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap();
assert_eq!(call_result, vec![initial_value]);
}
#[tokio::test]
async fn changes_in_origin_after_forking_block_should_not_affect_fork_state() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&origin_devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let initial_value = Felt::from(2_u32);
let ctor_args = vec![initial_value];
let (_, contract_address) =
declare_v3_deploy_v3(&predeployed_account, contract_class.clone(), casm_hash, &ctor_args)
.await
.unwrap();
let increment_value = Felt::from(19);
let invoke_result = predeployed_account
.execute_v3(vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![increment_value, Felt::ZERO],
}])
.l1_gas(0)
.l1_data_gas(1e3 as u64)
.l2_gas(1e7 as u64)
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&invoke_result.transaction_hash, &origin_devnet.json_rpc_client)
.await
.unwrap();
let latest_origin_block_number = origin_devnet.json_rpc_client.block_number().await.unwrap();
assert_eq!(latest_origin_block_number, 3); // declare, deploy, invoke
let fork_block_number = latest_origin_block_number - 1;
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--fork-network",
&origin_devnet.url,
"--fork-block",
&fork_block_number.to_string(),
])
.await
.unwrap();
// Assert fork intact and origin changed
let fork_balance = get_contract_balance(&fork_devnet, contract_address).await.unwrap();
assert_eq!(fork_balance, initial_value);
let origin_balance = get_contract_balance(&origin_devnet, contract_address).await.unwrap();
assert_eq!(origin_balance, initial_value + increment_value);
}
#[tokio::test]
async fn test_fork_using_origin_token_contract() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let address = Felt::ONE;
let mint_amount = 1000_u128;
origin_devnet.mint(address, mint_amount).await;
let fork_devnet = origin_devnet.fork().await.unwrap();
let fork_balance = fork_devnet.get_balance_latest(&address, FeeUnit::Fri).await.unwrap();
assert_eq!(fork_balance, Felt::from(mint_amount));
}
#[tokio::test]
async fn test_fork_if_origin_dies() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
send_ctrl_c_signal_and_wait(&origin_devnet.process).await;
let address = Felt::ONE;
match fork_devnet.json_rpc_client.get_nonce(BlockId::Tag(BlockTag::Latest), address).await {
Err(provider_error) => {
let received_error = extract_json_rpc_error(provider_error).unwrap();
assert_eq!(received_error.code, -1);
assert_contains(
&received_error.message,
"Failed to read from state: Error in communication with forking origin",
)
.unwrap();
assert_contains(&received_error.message, "Connection refused").unwrap();
assert_contains(&received_error.message, &format!("url: \"{}/\"", origin_devnet.url))
.unwrap();
assert_eq!(received_error.data, None);
}
unexpected => panic!("Got unexpected resp: {unexpected:?}"),
}
}
#[tokio::test]
async fn test_block_count_increased() {
// latest block has number 0
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
// create two blocks
origin_devnet.mint(0x1, 1).await; // dummy data
let forking_block_hash = origin_devnet.create_block().await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
// create another block on origin - shouldn't affect fork - asserted later
origin_devnet.create_block().await.unwrap();
let block_after_fork =
fork_devnet.json_rpc_client.get_block_with_tx_hashes(BlockId::Number(2)).await;
match block_after_fork {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(b)) => {
assert_eq!((b.block_hash, b.block_number), (forking_block_hash, 2))
}
_ => panic!("Unexpected resp: {block_after_fork:?}"),
};
let new_fork_block_hash = fork_devnet.create_block().await.unwrap();
let new_fork_block =
fork_devnet.json_rpc_client.get_block_with_tx_hashes(BlockId::Tag(BlockTag::Latest)).await;
match new_fork_block {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(b)) => {
assert_eq!((b.block_hash, b.block_number), (new_fork_block_hash, 4));
}
_ => panic!("Unexpected resp: {new_fork_block:?}"),
};
}
#[tokio::test]
async fn test_block_count_increased_on_state() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&origin_devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_block_reader_contract_artifacts();
let (_, contract_address) =
declare_v3_deploy_v3(&predeployed_account, contract_class, casm_hash, &[]).await.unwrap();
let fork_devnet = origin_devnet.fork().await.unwrap();
let contract_call = FunctionCall {
contract_address,
entry_point_selector: get_selector_from_name("get_block_number").unwrap(),
calldata: vec![],
};
let first_fork_block_number = fork_devnet
.json_rpc_client
.call(contract_call.clone(), BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
assert_eq!(first_fork_block_number, [Felt::from(4_u8)]); // origin block + declare + deploy
fork_devnet.create_block().await.unwrap();
let second_fork_block_number = fork_devnet
.json_rpc_client
.call(contract_call, BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
assert_eq!(second_fork_block_number, [Felt::from(5_u8)]); // origin block + declare + deploy
}
#[tokio::test]
async fn test_forking_https() {
let origin_url = MAINNET_HTTPS_URL;
let fork_block = 2;
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--fork-network",
origin_url,
"--fork-block",
&fork_block.to_string(),
])
.await
.unwrap();
fork_devnet
.json_rpc_client
// -1 to force fetching from origin
.get_block_with_tx_hashes(BlockId::Number(fork_block - 1))
.await
.unwrap();
}
#[tokio::test]
async fn test_forked_devnet_uses_different_contract_class_for_predeployed_tokens() {
let origin_url = MAINNET_URL;
let fork_block = 668276; // data taken from https://github.com/0xSpaceShard/starknet-devnet/issues/587
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--fork-network",
origin_url,
"--fork-block",
&fork_block.to_string(),
])
.await
.unwrap();
assert_ne!(
Felt::from_hex_unchecked(
fork_devnet.get_config().await["eth_erc20_class_hash"].as_str().unwrap()
),
ETH_ERC20_CONTRACT_CLASS_HASH
);
assert_ne!(
Felt::from_hex_unchecked(
fork_devnet.get_config().await["strk_erc20_class_hash"].as_str().unwrap()
),
STRK_ERC20_CONTRACT_CLASS_HASH
);
}
#[tokio::test]
async fn test_forked_devnet_new_block_has_parent_hash_of_the_origin_block() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let origin_block_hash = origin_devnet.create_block().await.unwrap();
let forked_devnet = origin_devnet.fork().await.unwrap();
let latest_block = forked_devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_block.parent_hash, origin_block_hash);
forked_devnet.create_block().await.unwrap();
let previous_block_hash = latest_block.block_hash;
let latest_block = forked_devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ne!(latest_block.parent_hash, origin_block_hash);
assert_eq!(latest_block.parent_hash, previous_block_hash);
}
#[tokio::test]
async fn test_tx_info_available_from_origin() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let address = Felt::ONE;
let mint_amount = 123;
let mint_tx_hash = origin_devnet.mint(address, mint_amount).await;
let latest_origin_block = origin_devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_origin_block.block_number, 1);
let forked_devnet = origin_devnet.fork().await.unwrap();
forked_devnet.json_rpc_client.get_transaction_by_hash(mint_tx_hash).await.unwrap();
forked_devnet.json_rpc_client.get_transaction_status(mint_tx_hash).await.unwrap();
forked_devnet.json_rpc_client.get_transaction_receipt(mint_tx_hash).await.unwrap();
forked_devnet.json_rpc_client.trace_transaction(mint_tx_hash).await.unwrap();
for block_id in [
BlockId::Number(latest_origin_block.block_number),
BlockId::Hash(latest_origin_block.block_hash),
] {
forked_devnet
.json_rpc_client
.get_transaction_by_block_id_and_index(block_id, 0)
.await
.unwrap();
}
}
#[tokio::test]
/// Adding of new declare v1 txs is no longer supported, but fetching old ones still is.
async fn test_fetching_declare_tx_v1_from_origin() {
let forked_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--fork-network", MAINNET_URL])
.await
.unwrap();
let tx_hash = Felt::from_hex_unchecked(
"0xd1085f209ddfe060c0f6d544942473e0eaed4c5292b413af8e197b6b7270c0",
);
match forked_devnet.json_rpc_client.get_transaction_by_hash(tx_hash).await {
Ok(Transaction::Declare(DeclareTransaction::V1(_))) => (),
other => panic!("Invalid tx resp: {other:?}"),
};
}
#[tokio::test]
async fn test_call_at_block_not_present_in_origin() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let forked_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--fork-network", &origin_devnet.url])
.await
.unwrap();
for non_existent_block_id in [BlockId::Hash(Felt::ONE), BlockId::Number(2)] {
let call_result = forked_devnet
.json_rpc_client
.call(
FunctionCall {
contract_address: Felt::ONE, // dummy
entry_point_selector: get_selector_from_name("dummy").unwrap(),
calldata: vec![],
},
non_existent_block_id,
)
.await;
match call_result {
Err(ProviderError::StarknetError(StarknetError::BlockNotFound)) => (),
other => panic!("Unexpected result: {other:?}"),
}
}
}
#[tokio::test]
async fn get_block_accepted_on_l1_from_origin() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
origin_devnet.accept_on_l1(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
// Forked Devnet introducs an origin block of its own. Forking by default from origin latest.
let forked_devnet =
BackgroundDevnet::spawn_with_additional_args(&["--fork-network", &origin_devnet.url])
.await
.unwrap();
let latest_block = forked_devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_block.block_number, 1);
// Should be on origin.
let l1_accepted_block = forked_devnet.get_l1_accepted_block_with_tx_hashes().await.unwrap();
assert_eq!(l1_accepted_block.block_number, 0);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_v3_transactions.rs | tests/integration/test_v3_transactions.rs | use std::sync::Arc;
use starknet_rs_accounts::{
Account, AccountDeploymentV3, AccountError, AccountFactory, ConnectedAccount, DeclarationV3,
ExecutionEncoding, ExecutionV3, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{
BlockId, BlockTag, Call, ExecutionResult, Felt, FlattenedSierraClass, InvokeTransactionResult,
StarknetError, U256,
};
use starknet_rs_core::utils::{get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider, ProviderError};
use starknet_rs_signers::LocalWallet;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_0_ACCOUNT_CONTRACT_HASH, STRK_ERC20_CONTRACT_ADDRESS, TOO_BIG_CONTRACT_SIERRA_PATH,
UDC_CONTRACT_ADDRESS,
};
use crate::common::utils::{
FeeUnit, LocalFee, assert_contains, assert_tx_succeeded_accepted,
get_deployable_account_signer, get_flattened_sierra_contract_and_casm_hash,
get_simple_contract_artifacts,
};
enum Action {
Declaration(Arc<FlattenedSierraClass>, Felt),
AccountDeployment(Felt),
Execution(Vec<Call>),
}
#[tokio::test]
async fn deploy_account_to_an_address_with_insufficient_balance_should_fail() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let signer = get_deployable_account_signer();
let factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
constants::CHAIN_ID,
signer,
devnet.clone_provider(),
)
.await
.unwrap();
match factory.deploy_v3(Felt::THREE).send().await.unwrap_err() {
starknet_rs_accounts::AccountFactoryError::Provider(ProviderError::StarknetError(
StarknetError::InsufficientAccountBalance,
)) => {}
other => panic!("Unexpected error: {:?}", other),
};
}
#[tokio::test]
async fn declare_deploy_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (sierra_artifact, casm_hash) = get_simple_contract_artifacts();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let declare_transaction =
account.declare_v3(Arc::new(sierra_artifact), casm_hash).send().await.unwrap();
assert_tx_succeeded_accepted(&declare_transaction.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
devnet
.json_rpc_client
.get_class(BlockId::Tag(BlockTag::Latest), declare_transaction.class_hash)
.await
.unwrap();
let salt = Felt::from_hex_unchecked("0x123");
let constructor_arg = Felt::from(10);
let deploy_call = vec![Call {
to: UDC_CONTRACT_ADDRESS,
selector: get_selector_from_name("deployContract").unwrap(),
calldata: vec![
declare_transaction.class_hash,
salt,
Felt::ZERO, // unique
Felt::ONE, // constructor length
constructor_arg, // constructor arguments
],
}];
let contract_address = get_udc_deployed_address(
salt,
declare_transaction.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&[constructor_arg],
);
let deploy_transaction = account.execute_v3(deploy_call).send().await.unwrap();
assert_tx_succeeded_accepted(&deploy_transaction.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let class_hash_of_contract = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.unwrap();
assert_eq!(declare_transaction.class_hash, class_hash_of_contract);
}
#[tokio::test]
async fn declare_from_an_account_with_insufficient_strk_tokens_balance() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (sierra_artifact, casm_hash) = get_simple_contract_artifacts();
let sierra_artifact = Arc::new(sierra_artifact);
let declaration = account.declare_v3(sierra_artifact.clone(), casm_hash);
let estimate_fee = declaration.estimate_fee().await.unwrap();
let account_strk_balance =
devnet.get_balance_by_tag(&account_address, FeeUnit::Fri, BlockTag::Latest).await.unwrap();
// transfer balance of the account without the amount of fee
let amount_to_transfer =
account_strk_balance - Felt::from(estimate_fee.overall_fee) + Felt::ONE;
let amount_to_transfer = U256::from(amount_to_transfer);
let invoke_txn_result = account
.execute_v3(vec![Call {
to: STRK_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
amount_to_transfer.low().into(),
amount_to_transfer.high().into(),
],
}])
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&invoke_txn_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let account_strk_balance =
devnet.get_balance_by_tag(&account_address, FeeUnit::Fri, BlockTag::Latest).await.unwrap();
assert!(Felt::from(estimate_fee.overall_fee) > account_strk_balance);
match declaration.send().await.unwrap_err() {
starknet_rs_accounts::AccountError::Provider(ProviderError::StarknetError(
StarknetError::InsufficientAccountBalance,
)) => {}
other => panic!("Unexpected error: {:?}", other),
}
}
#[tokio::test]
async fn invoke_with_insufficient_gas_price_and_or_gas_units_should_fail() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
transaction_with_less_gas_units_and_or_less_gas_price_should_return_error_or_be_accepted_as_reverted(
Action::Execution(vec![Call {
to: STRK_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
Felt::ONE, // low part of uint256
Felt::ZERO, // high part of uint256
],
}]),
Some(&account),
Option::<&OpenZeppelinAccountFactory<LocalWallet, JsonRpcClient<HttpTransport>>>::None,
)
.await.unwrap();
}
#[tokio::test]
async fn deploy_account_with_insufficient_gas_price_and_or_gas_units_should_fail() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let signer = get_deployable_account_signer();
let factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
constants::CHAIN_ID,
signer,
devnet.clone_provider(),
)
.await
.unwrap();
let salt = Felt::THREE;
devnet.mint_unit(factory.deploy_v3(salt).address(), 1e18 as u128, FeeUnit::Fri).await;
transaction_with_less_gas_units_and_or_less_gas_price_should_return_error_or_be_accepted_as_reverted(
Action::AccountDeployment(salt),
Option::<&SingleOwnerAccount<JsonRpcClient<HttpTransport>, LocalWallet>>::None,
Some(&factory),
)
.await.unwrap()
}
#[tokio::test]
async fn redeclaration_has_to_fail() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (sierra_artifact, casm_hash) = get_simple_contract_artifacts();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let sierra_artifact = Arc::new(sierra_artifact);
let declaration = account.declare_v3(sierra_artifact.clone(), casm_hash);
let fee: LocalFee = declaration.estimate_fee().await.unwrap().into();
declaration.send().await.unwrap();
// redeclaration
match declaration
.l1_data_gas(fee.l1_data_gas)
.l2_gas(fee.l2_gas)
.l1_gas(fee.l1_gas)
.send()
.await
.unwrap_err()
{
AccountError::Provider(ProviderError::StarknetError(
StarknetError::ClassAlreadyDeclared,
)) => {}
other => panic!("Unexpected error {:?}", other),
}
}
#[tokio::test]
async fn declare_with_insufficient_gas_price_and_or_gas_units_should_fail() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (sierra_artifact, casm_hash) = get_simple_contract_artifacts();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let sierra_artifact = Arc::new(sierra_artifact);
transaction_with_less_gas_units_and_or_less_gas_price_should_return_error_or_be_accepted_as_reverted(
Action::Declaration(sierra_artifact, casm_hash),
Some(&account),
Option::<&OpenZeppelinAccountFactory<LocalWallet, JsonRpcClient<HttpTransport>>>::None,
)
.await.unwrap();
}
#[tokio::test]
async fn deploy_account_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let signer = get_deployable_account_signer();
let factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
constants::CHAIN_ID,
signer,
devnet.clone_provider(),
)
.await
.unwrap();
let deploy_v3 = factory.deploy_v3(Felt::THREE);
let account_address = deploy_v3.address();
devnet.mint_unit(account_address, 1e18 as u128, FeeUnit::Fri).await;
let result = deploy_v3.send().await.unwrap();
assert_tx_succeeded_accepted(&result.transaction_hash, &devnet.json_rpc_client).await.unwrap();
}
/// This function sets the gas price and/or gas units to a value that is less than the estimated
/// then sends the transaction. The expected result is that the transaction will either fail or
/// be accepted as reverted.
async fn transaction_with_less_gas_units_and_or_less_gas_price_should_return_error_or_be_accepted_as_reverted<
A: ConnectedAccount + Sync,
F: AccountFactory + Sync,
>(
transaction_action: Action,
account: Option<&A>,
account_factory: Option<&F>,
) -> Result<(), anyhow::Error> {
let estimate_fee = match &transaction_action {
Action::Declaration(sierra_class, casm_hash) => DeclarationV3::new(
sierra_class.clone(),
*casm_hash,
account.ok_or(anyhow::anyhow!("Account not found"))?,
)
.estimate_fee()
.await
.map_err(|e| anyhow::Error::msg(e.to_string()))?,
Action::AccountDeployment(salt) => AccountDeploymentV3::new(
*salt,
account_factory.ok_or(anyhow::anyhow!("Account Factory is None"))?,
)
.estimate_fee()
.await
.map_err(|e| anyhow::Error::msg(e.to_string()))?,
Action::Execution(calls) => {
ExecutionV3::new(calls.clone(), account.ok_or(anyhow::anyhow!("Account not found"))?)
.estimate_fee()
.await
.map_err(|e| anyhow::Error::msg(e.to_string()))?
}
};
let LocalFee {
l2_gas, l2_gas_price, l1_data_gas, l1_gas, l1_data_gas_price, l1_gas_price, ..
} = LocalFee::from(estimate_fee);
for (l2, l2_price) in [
(l2_gas - 1, l2_gas_price),
(l2_gas, l2_gas_price - 1),
(l2_gas - 1, l2_gas_price - 1),
(l2_gas - 1, 0),
(0, l2_gas_price),
] {
match &transaction_action {
Action::Declaration(sierra_class, casm_hash) => {
let declaration =
DeclarationV3::new(sierra_class.clone(), *casm_hash, account.unwrap())
.l1_data_gas(l1_data_gas)
.l1_data_gas_price(l1_data_gas_price)
.l1_gas(l1_gas)
.l1_gas_price(l1_gas_price)
.l2_gas(l2)
.l2_gas_price(l2_price);
match declaration.send().await.unwrap_err() {
starknet_rs_accounts::AccountError::Provider(ProviderError::StarknetError(
StarknetError::InsufficientResourcesForValidate,
)) => {}
other => anyhow::bail!("Unexpected error {:?}", other),
}
}
Action::AccountDeployment(salt) => {
let account_deployment = AccountDeploymentV3::new(*salt, account_factory.unwrap())
.l1_data_gas(l1_data_gas)
.l1_data_gas_price(l1_data_gas_price)
.l1_gas(l1_gas)
.l1_gas_price(l1_gas_price)
.l2_gas(l2)
.l2_gas_price(l2_price);
match account_deployment.send().await.unwrap_err() {
starknet_rs_accounts::AccountFactoryError::Provider(
ProviderError::StarknetError(
StarknetError::InsufficientResourcesForValidate,
),
) => {}
other => anyhow::bail!("Unexpected error {:?}", other),
}
}
Action::Execution(calls) => {
let execution = ExecutionV3::new(calls.clone(), account.unwrap())
.l1_data_gas(l1_data_gas)
.l1_data_gas_price(l1_data_gas_price)
.l1_gas(l1_gas)
.l1_gas_price(l1_gas_price)
.l2_gas(l2)
.l2_gas_price(l2_price);
let transaction_result = execution.send().await;
match transaction_result {
Ok(InvokeTransactionResult { transaction_hash }) => {
let receipt = account
.ok_or(anyhow::anyhow!("Account not found"))?
.provider()
.get_transaction_receipt(transaction_hash)
.await?;
let execution_result = receipt.receipt.execution_result();
match execution_result {
ExecutionResult::Reverted { reason } => {
assert_contains(reason.as_str(), "Insufficient max L2Gas").unwrap();
}
other => anyhow::bail!("Unexpected result: {:?}", other),
}
}
Err(starknet_rs_accounts::AccountError::Provider(
ProviderError::StarknetError(
StarknetError::InsufficientResourcesForValidate,
),
)) => {}
Err(error) => anyhow::bail!("Unexpected error {:?}", error),
}
}
};
}
Ok(())
}
#[tokio::test]
async fn test_rejection_of_too_big_class_declaration() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::New,
);
let (contract_class, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(TOO_BIG_CONTRACT_SIERRA_PATH);
match account.declare_v3(Arc::new(contract_class), casm_hash).send().await {
Err(AccountError::Provider(ProviderError::StarknetError(
StarknetError::ContractClassSizeIsTooLarge,
))) => (),
other => panic!("Unexpected result: {other:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_estimate_fee.rs | tests/integration/test_estimate_fee.rs | use std::sync::Arc;
use starknet_core::constants::ENTRYPOINT_NOT_FOUND_ERROR_ENCODED;
use starknet_rs_accounts::{
Account, AccountError, AccountFactory, AccountFactoryError, ConnectedAccount, ExecutionEncoder,
ExecutionEncoding, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{
BlockId, BlockTag, BroadcastedDeclareTransactionV3, BroadcastedInvokeTransactionV3,
BroadcastedTransaction, Call, DataAvailabilityMode, FeeEstimate, Felt, FunctionCall,
ResourceBounds, ResourceBoundsMapping, StarknetError, TransactionExecutionErrorData,
};
use starknet_rs_core::utils::{
UdcUniqueness, cairo_short_string_to_felt, get_selector_from_name, get_udc_deployed_address,
};
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider, ProviderError};
use starknet_rs_signers::{LocalWallet, Signer};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
CAIRO_0_ACCOUNT_CONTRACT_HASH, CAIRO_1_CONTRACT_PATH, CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH,
CAIRO_1_VERSION_ASSERTER_SIERRA_PATH, CHAIN_ID, ETH_ERC20_CONTRACT_ADDRESS,
QUERY_VERSION_OFFSET, UDC_CONTRACT_ADDRESS,
};
use crate::common::utils::{
LocalFee, assert_contains, assert_tx_reverted, assert_tx_succeeded_accepted,
extract_message_error, extract_nested_error, get_deployable_account_signer,
get_flattened_sierra_contract_and_casm_hash, get_simple_contract_artifacts,
new_contract_factory,
};
fn assert_fee_estimation(fee_estimation: &FeeEstimate) {
let calculated_overall_fee = fee_estimation.l1_data_gas_consumed as u128
* fee_estimation.l1_data_gas_price
+ fee_estimation.l2_gas_consumed as u128 * fee_estimation.l2_gas_price
+ fee_estimation.l1_gas_consumed as u128 * fee_estimation.l1_gas_price;
assert_eq!(calculated_overall_fee, fee_estimation.overall_fee);
assert!(fee_estimation.overall_fee > 0, "Checking fee_estimation: {fee_estimation:?}");
}
#[tokio::test]
async fn estimate_fee_of_deploy_account() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// define the key of the new account - dummy value
let new_account_signer = get_deployable_account_signer();
let account_factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
CHAIN_ID,
new_account_signer.clone(),
devnet.clone_provider(),
)
.await
.unwrap();
let new_account_nonce = Felt::ZERO;
// fund address
let salt = Felt::from_hex_unchecked("0x123");
let deployment = account_factory.deploy_v3(salt);
let deployment_address = deployment.address();
let fee_estimation = account_factory
.deploy_v3(salt)
.gas_estimate_multiplier(1.0)
.gas_price_estimate_multiplier(1.0)
.nonce(new_account_nonce)
.estimate_fee()
.await
.unwrap();
assert_fee_estimation(&fee_estimation);
// fund the account before deployment
let mint_amount = fee_estimation.overall_fee * 2;
devnet.mint(deployment_address, mint_amount).await;
let fee = LocalFee::from(fee_estimation);
// try sending with insufficient resource bounds
let unsuccessful_deployment_tx = account_factory
.deploy_v3(salt)
.l1_data_gas(fee.l1_data_gas)
.l1_gas(fee.l1_gas)
.l2_gas(fee.l2_gas - 1)
.nonce(new_account_nonce)
.send()
.await;
match unsuccessful_deployment_tx {
Err(AccountFactoryError::Provider(ProviderError::StarknetError(
StarknetError::InsufficientResourcesForValidate,
))) => (),
other => panic!("Unexpected result: {other:?}"),
};
// try sending with sufficient gas bounds
let successful_deployment = account_factory
.deploy_v3(salt)
.gas_estimate_multiplier(1.1)
.gas_price_estimate_multiplier(1.1)
.nonce(new_account_nonce)
.send()
.await
.expect("Should deploy with sufficient fee");
assert_tx_succeeded_accepted(&successful_deployment.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn estimate_fee_of_invalid_deploy_account() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let new_account_signer = get_deployable_account_signer();
let invalid_class_hash = Felt::from_hex_unchecked("0x123");
let account_factory = OpenZeppelinAccountFactory::new(
invalid_class_hash,
CHAIN_ID,
new_account_signer,
devnet.clone_provider(),
)
.await
.unwrap();
let salt = Felt::from_hex_unchecked("0x123");
let deployment = account_factory.deploy_v3(salt);
match deployment.estimate_fee().await {
Err(AccountFactoryError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(err),
))) if err.transaction_index == 0 => {
assert_contains(
&format!("{:?}", err.execution_error),
&format!(
"Class with hash {} is not declared.",
invalid_class_hash.to_fixed_hex_string()
),
)
.unwrap();
}
other => panic!("Unexpected response: {other:?}"),
}
}
#[tokio::test]
async fn estimate_fee_of_declare_v3() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_CONTRACT_PATH);
let flattened_contract_artifact = Arc::new(flattened_contract_artifact);
// declare class
let account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
);
// two times in a row should produce the same result
let mut fee_estimations: Vec<FeeEstimate> = vec![];
for _ in 0..2 {
let fee_estimation = account
.declare_v3(Arc::clone(&flattened_contract_artifact), casm_hash)
.nonce(Felt::ZERO)
.gas_estimate_multiplier(1.0)
.gas_price_estimate_multiplier(1.0)
.estimate_fee()
.await
.unwrap();
assert_fee_estimation(&fee_estimation);
fee_estimations.push(fee_estimation);
}
assert_eq!(fee_estimations[0], fee_estimations[1]);
let fee_estimation = &fee_estimations[0];
let fee = LocalFee::from(fee_estimation.clone());
// try sending with insufficient resource bounds
let unsuccessful_declare_tx = account
.declare_v3(Arc::clone(&flattened_contract_artifact), casm_hash)
.nonce(Felt::ZERO)
.l1_gas(fee.l1_gas)
.l1_data_gas(fee.l1_data_gas)
.l2_gas(fee.l2_gas - 1)
.send()
.await;
match unsuccessful_declare_tx {
Err(AccountError::Provider(ProviderError::StarknetError(
StarknetError::InsufficientResourcesForValidate,
))) => (),
other => panic!("Unexpected result: {other:?}"),
};
// try sending with sufficient gas bounds
let successful_declare_tx = account
.declare_v3(Arc::clone(&flattened_contract_artifact), casm_hash)
.nonce(Felt::ZERO)
.l1_gas((fee.l1_gas as f64 * 1.1) as u64)
.l1_data_gas((fee.l1_data_gas as f64 * 1.1) as u64)
.l2_gas((fee.l2_gas as f64 * 1.1) as u64)
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&successful_declare_tx.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn estimate_fee_of_invoke() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
// get class
let (contract_artifact, casm_hash) = get_simple_contract_artifacts();
let contract_artifact = Arc::new(contract_artifact);
let class_hash = contract_artifact.class_hash();
// declare class
let declaration_result =
account.declare_v3(contract_artifact, casm_hash).nonce(Felt::ZERO).send().await.unwrap();
assert_eq!(declaration_result.class_hash, class_hash);
// deploy instance of class
let contract_factory = new_contract_factory(class_hash, account.clone());
let salt = Felt::from_hex_unchecked("0x123");
let constructor_calldata = vec![Felt::ZERO];
let contract_address = get_udc_deployed_address(
salt,
class_hash,
&UdcUniqueness::NotUnique,
&constructor_calldata,
);
contract_factory
.deploy_v3(constructor_calldata, salt, false)
.send()
.await
.expect("Cannot deploy");
// prepare the call used in estimation and actual invoke
let invoke_calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![Felt::from(100_u128), Felt::ONE], // increment amount
}];
// estimate the fee
let fee_estimation = account.execute_v3(invoke_calls.clone()).estimate_fee().await.unwrap();
assert_fee_estimation(&fee_estimation);
// prepare the call used in checking the balance
let call = FunctionCall {
contract_address,
entry_point_selector: get_selector_from_name("get_balance").unwrap(),
calldata: vec![],
};
// invoke with insufficient resource bounds
let unsuccessful_invoke_tx = account
.execute_v3(invoke_calls.clone())
.gas_estimate_multiplier(0.9)
.gas_price_estimate_multiplier(1.0)
.send()
.await
.unwrap();
let balance_after_insufficient =
devnet.json_rpc_client.call(call.clone(), BlockId::Tag(BlockTag::Latest)).await.unwrap();
assert_eq!(balance_after_insufficient, vec![Felt::ZERO]);
assert_tx_reverted(
&unsuccessful_invoke_tx.transaction_hash,
&devnet.json_rpc_client,
&["Insufficient max L2Gas"],
)
.await
.unwrap();
// invoke with sufficient resource bounds
let fee = LocalFee::from(fee_estimation);
account
.execute_v3(invoke_calls)
.l1_gas(fee.l1_gas)
.l1_data_gas(fee.l1_data_gas)
.l2_gas(fee.l2_gas)
.send()
.await
.unwrap();
let balance_after_sufficient =
devnet.json_rpc_client.call(call, BlockId::Tag(BlockTag::Latest)).await.unwrap();
assert_eq!(balance_after_sufficient, vec![Felt::from(101_u128)]);
}
#[tokio::test]
async fn message_available_if_estimation_reverts() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
// declare class
let declaration_result =
account.declare_v3(Arc::new(flattened_contract_artifact), casm_hash).send().await.unwrap();
assert_eq!(declaration_result.class_hash, class_hash);
// deploy instance of class
let contract_factory = new_contract_factory(class_hash, account.clone());
let salt = Felt::from_hex_unchecked("0x123");
let constructor_calldata = vec![];
let contract_address = get_udc_deployed_address(
salt,
class_hash,
&UdcUniqueness::NotUnique,
&constructor_calldata,
);
contract_factory
.deploy_v3(constructor_calldata, salt, false)
.send()
.await
.expect("Cannot deploy");
let panic_reason = cairo_short_string_to_felt("custom little reason").unwrap();
let calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("create_panic").unwrap(),
calldata: vec![panic_reason],
}];
let invoke_err = account
.execute_v3(calls.clone())
.nonce(account.get_nonce().await.unwrap())
.estimate_fee()
.await
.unwrap_err();
match invoke_err {
AccountError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(TransactionExecutionErrorData {
transaction_index: 0,
execution_error,
..
}),
)) => {
let account_error = extract_nested_error(&execution_error).unwrap();
let contract_error = extract_nested_error(&account_error.error).unwrap();
let inner_error = extract_nested_error(&contract_error.error).unwrap();
let error_msg = extract_message_error(&inner_error.error).unwrap();
assert_contains(error_msg, &panic_reason.to_hex_string()).unwrap();
}
other => panic!("Invalid err: {other:?}"),
};
}
#[tokio::test]
async fn using_query_version_if_estimating() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_VERSION_ASSERTER_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
// declare class
let declaration_result =
account.declare_v3(Arc::new(flattened_contract_artifact), casm_hash).send().await.unwrap();
assert_eq!(declaration_result.class_hash, class_hash);
// deploy instance of class
let contract_factory = new_contract_factory(class_hash, account.clone());
let salt = Felt::from_hex_unchecked("0x123");
let constructor_calldata = vec![];
let contract_address = get_udc_deployed_address(
salt,
class_hash,
&UdcUniqueness::NotUnique,
&constructor_calldata,
);
contract_factory
.deploy_v3(constructor_calldata, salt, false)
.send()
.await
.expect("Cannot deploy");
let expected_version = QUERY_VERSION_OFFSET + Felt::THREE;
let calls = vec![Call {
to: contract_address,
selector: get_selector_from_name("assert_version").unwrap(),
calldata: vec![expected_version],
}];
match account.execute_v3(calls).estimate_fee().await {
Ok(_) => (),
other => panic!("Unexpected result: {other:?}"),
}
}
async fn broadcasted_invoke_v3_for_estimation(
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
signer: &LocalWallet,
to_address: Felt,
selector: Felt,
calldata: &[Felt],
nonce: Felt,
) -> Result<BroadcastedTransaction, anyhow::Error> {
let calls = vec![Call { to: to_address, selector, calldata: calldata.to_vec() }];
let calldata = account.encode_calls(&calls);
let execution_v3 = account.execute_v3(calls);
let l1_gas_consumed = 0;
let l1_gas_price = 0;
let l1_data_gas_consumed = 0;
let l1_data_gas_price = 0;
let l2_gas_consumed = 0;
let l2_gas_price = 0;
let prepared_invoke = execution_v3
.nonce(nonce)
.l1_gas(l1_gas_consumed)
.l2_gas(l2_gas_consumed)
.l1_data_gas(l1_data_gas_consumed)
.l1_gas_price(l1_gas_price)
.l1_data_gas_price(l1_data_gas_price)
.l2_gas_price(l2_gas_price)
.tip(0)
.prepared()?;
let is_query = false;
let signature = signer.sign_hash(&prepared_invoke.transaction_hash(is_query)).await?;
Ok(BroadcastedTransaction::Invoke(BroadcastedInvokeTransactionV3 {
resource_bounds: ResourceBoundsMapping {
l1_gas: ResourceBounds {
max_amount: l1_gas_consumed,
max_price_per_unit: l1_gas_price,
},
l1_data_gas: ResourceBounds {
max_amount: l1_data_gas_consumed,
max_price_per_unit: l1_data_gas_price,
},
l2_gas: ResourceBounds {
max_amount: l2_gas_consumed,
max_price_per_unit: l2_gas_price,
},
},
signature: vec![signature.r, signature.s],
nonce,
sender_address: account.address(),
calldata,
is_query,
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
}))
}
#[tokio::test]
/// estimate fee of declare + deploy (invoke udc)
async fn estimate_fee_of_multiple_txs() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--account-class", "cairo0"])
.await
.expect("Could not start Devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::Legacy,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
// get class
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let contract_class = Arc::new(contract_class);
let class_hash = contract_class.class_hash();
let declaration_nonce = Felt::ZERO;
let l1_gas = 0;
let l1_gas_price = 0;
let prepared_declaration = account
.declare_v3(contract_class.clone(), casm_hash)
.l1_gas(l1_gas)
.l1_gas_price(l1_gas_price)
.l2_gas(0)
.l2_gas_price(0)
.l1_data_gas(0)
.l1_data_gas_price(0)
.nonce(declaration_nonce)
.tip(0)
.prepared()
.unwrap();
let query_only = false;
let declaration_signature =
signer.sign_hash(&prepared_declaration.transaction_hash(query_only)).await.unwrap();
devnet
.json_rpc_client
.estimate_fee(
[
BroadcastedTransaction::Declare(BroadcastedDeclareTransactionV3 {
signature: vec![declaration_signature.r, declaration_signature.s],
nonce: declaration_nonce,
sender_address: account_address,
contract_class,
is_query: query_only,
compiled_class_hash: casm_hash,
resource_bounds: ResourceBoundsMapping {
l1_gas: ResourceBounds {
max_amount: l1_gas,
max_price_per_unit: l1_gas_price,
},
l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l1_data_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
},
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
}),
broadcasted_invoke_v3_for_estimation(
&account,
&signer,
UDC_CONTRACT_ADDRESS,
get_selector_from_name("deploy_contract").unwrap(),
&[
class_hash,
Felt::from_hex_unchecked("0x123"), // salt
Felt::ZERO, // unique
Felt::ONE, // ctor args len
Felt::ZERO, // ctor args - [initial_balance]
],
Felt::ONE,
)
.await
.unwrap(),
],
[], // simulation_flags
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap()
.iter()
.for_each(assert_fee_estimation);
}
#[tokio::test]
async fn estimate_fee_of_multiple_txs_with_second_failing() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
CHAIN_ID,
ExecutionEncoding::New,
);
let non_existent_selector = get_selector_from_name("nonExistentMethod").unwrap();
let err = devnet
.json_rpc_client
.estimate_fee(
[
broadcasted_invoke_v3_for_estimation(
&account,
&signer,
ETH_ERC20_CONTRACT_ADDRESS,
get_selector_from_name("transfer").unwrap(),
&[
Felt::ONE, // recipient
Felt::from(1_000_000_000), // low part of uint256
Felt::ZERO, // high part of uint256
],
Felt::ZERO, // original nonce
)
.await
.unwrap(),
broadcasted_invoke_v3_for_estimation(
&account,
&signer,
ETH_ERC20_CONTRACT_ADDRESS,
non_existent_selector,
&[],
Felt::ONE, // nonce incremented after 1st tx
)
.await
.unwrap(),
],
[], // simulation_flags
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap_err();
match err {
ProviderError::StarknetError(StarknetError::TransactionExecutionError(
TransactionExecutionErrorData { transaction_index, execution_error },
)) => {
assert_eq!(transaction_index, 1);
assert_contains(
&format!("{:?}", execution_error),
&ENTRYPOINT_NOT_FOUND_ERROR_ENCODED.to_hex_string(),
)
.unwrap();
}
_ => panic!("Unexpected error: {err}"),
};
}
#[tokio::test]
async fn estimate_fee_of_multiple_failing_txs_should_return_index_of_the_first_failing_transaction()
{
let devnet = BackgroundDevnet::spawn().await.expect("Could not start devnet");
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::New,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
let estimate_fee_resource_bounds = ResourceBoundsMapping {
l1_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l1_data_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
};
// call non existent method in UDC
let calls = vec![Call {
to: UDC_CONTRACT_ADDRESS,
selector: get_selector_from_name("no_such_method").unwrap(),
calldata: vec![
class_hash,
Felt::from_hex_unchecked("0x123"), // salt
Felt::ZERO,
Felt::ZERO,
],
}];
let calldata = account.encode_calls(&calls);
let is_query = true;
let nonce_data_availability_mode = DataAvailabilityMode::L1;
let fee_data_availability_mode = DataAvailabilityMode::L1;
let expected_error = devnet
.json_rpc_client
.estimate_fee(
[
BroadcastedTransaction::Declare(BroadcastedDeclareTransactionV3 {
sender_address: account_address,
compiled_class_hash: casm_hash,
signature: vec![],
nonce: Felt::ZERO,
contract_class: Arc::new(flattened_contract_artifact.clone()),
resource_bounds: estimate_fee_resource_bounds.clone(),
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
}),
BroadcastedTransaction::Invoke(BroadcastedInvokeTransactionV3 {
sender_address: account_address,
calldata,
signature: vec![],
nonce: Felt::ONE,
resource_bounds: estimate_fee_resource_bounds.clone(),
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode,
fee_data_availability_mode,
is_query,
}),
],
[],
account.block_id(),
)
.await
.unwrap_err();
match expected_error {
ProviderError::StarknetError(StarknetError::TransactionExecutionError(
TransactionExecutionErrorData { transaction_index, execution_error },
)) => {
assert_eq!(transaction_index, 0);
assert_contains(&format!("{:?}", execution_error), "invalid signature").unwrap();
}
other => panic!("Unexpected error: {:?}", other),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_abort_blocks.rs | tests/integration/test_abort_blocks.rs | use serde_json::json;
use starknet_rs_core::types::{BlockId, BlockTag, Felt, StarknetError};
use starknet_rs_providers::{Provider, ProviderError};
use crate::assert_eq_prop;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::errors::RpcError;
use crate::common::utils::{FeeUnit, assert_contains, to_hex_felt};
static DUMMY_ADDRESS: u128 = 1;
static DUMMY_AMOUNT: u128 = 1;
async fn abort_blocks_error(
devnet: &BackgroundDevnet,
starting_block_id: &BlockId,
expected_message_substring: &str,
) -> Result<(), anyhow::Error> {
let aborted_blocks_error: RpcError = devnet
.send_custom_rpc("devnet_abortBlocks", json!({ "starting_block_id" : starting_block_id }))
.await
.unwrap_err();
assert_contains(&aborted_blocks_error.message, expected_message_substring)
}
async fn assert_block_aborted(
devnet: &BackgroundDevnet,
block_hash: &Felt,
) -> Result<(), anyhow::Error> {
let err = devnet
.send_custom_rpc(
"starknet_getBlockWithTxHashes",
json!({ "block_id": {"block_hash": to_hex_felt(block_hash)} }),
)
.await
.unwrap_err();
assert_eq_prop!(err, RpcError { code: 24, message: "Block not found".into(), data: None })
}
async fn assert_txs_aborted(
devnet: &BackgroundDevnet,
tx_hashes: &[Felt],
) -> Result<(), anyhow::Error> {
for tx_hash in tx_hashes {
match devnet.json_rpc_client.get_transaction_by_hash(tx_hash).await {
Err(ProviderError::StarknetError(StarknetError::TransactionHashNotFound)) => (),
other => anyhow::bail!("Unexpected tx response for {tx_hash:#x}: {other:?}"),
}
}
Ok(())
}
#[tokio::test]
async fn abort_latest_block_with_hash() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let genesis_block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
let new_block_hash = devnet.create_block().await.unwrap();
let aborted_blocks = devnet.abort_blocks(&BlockId::Hash(new_block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![new_block_hash]);
// Check if the genesis block is still ACCEPTED_ON_L2
let genesis_block_after_abort = &devnet
.send_custom_rpc(
"starknet_getBlockWithTxHashes",
json!({ "block_id": {"block_hash": to_hex_felt(&genesis_block_hash)} }),
)
.await
.unwrap();
assert_eq!(genesis_block_after_abort["status"], "ACCEPTED_ON_L2".to_string());
assert_block_aborted(&devnet, &new_block_hash).await.unwrap();
abort_blocks_error(
&devnet,
&BlockId::Hash(genesis_block_hash),
"Genesis block can't be aborted",
)
.await
.unwrap();
}
#[tokio::test]
async fn abort_two_blocks() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let first_block_hash = devnet.create_block().await.unwrap();
let second_block_hash = devnet.create_block().await.unwrap();
let aborted_blocks = devnet.abort_blocks(&BlockId::Hash(first_block_hash)).await.unwrap();
assert_eq!(json!(aborted_blocks), json!([second_block_hash, first_block_hash]));
assert_block_aborted(&devnet, &first_block_hash).await.unwrap();
assert_block_aborted(&devnet, &second_block_hash).await.unwrap();
}
#[tokio::test]
async fn abort_block_with_transaction() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let mint_hash = devnet.mint(Felt::ONE, 100).await;
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let aborted_blocks =
devnet.abort_blocks(&BlockId::Hash(latest_block.block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![latest_block.block_hash]);
assert_block_aborted(&devnet, &latest_block.block_hash).await.unwrap();
assert_txs_aborted(&devnet, &[mint_hash]).await.unwrap();
}
#[tokio::test]
async fn query_aborted_block_by_number_should_fail() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let new_block_hash = devnet.create_block().await.unwrap();
let aborted_blocks = devnet.abort_blocks(&BlockId::Hash(new_block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![new_block_hash]);
assert_block_aborted(&devnet, &new_block_hash).await.unwrap();
let rpc_error = devnet
.send_custom_rpc(
"starknet_getBlockWithTxHashes",
json!({ "block_id": {"block_number": 1} }),
)
.await
.unwrap_err();
assert_eq!(rpc_error.message, "Block not found")
}
#[tokio::test]
async fn block_abortion_should_affect_state() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
// State setup
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let first_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let second_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let balance_before_abortion =
devnet.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(balance_before_abortion.to_string(), (2 * DUMMY_AMOUNT).to_string());
// Block abortion - latest block only
let aborted_blocks =
devnet.abort_blocks(&BlockId::Hash(second_block.block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![second_block.block_hash]);
// Aborting the second mint should halve the balance
let balance =
devnet.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(balance.to_string(), DUMMY_AMOUNT.to_string());
let aborted_blocks = devnet.abort_blocks(&BlockId::Hash(first_block.block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![first_block.block_hash]);
// Aborting the first mint should make the balance 0
let balance_after_all_aborted =
devnet.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(balance_after_all_aborted.to_string(), "0");
// Re-gain balance
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let balance =
devnet.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(balance.to_string(), DUMMY_AMOUNT.to_string());
}
#[tokio::test]
async fn block_abortion_should_affect_block_number() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
/// Assert `devnet` currently has `latest` and `pre_confirmed` as its block numbers.
async fn assert_block_number(devnet: &BackgroundDevnet, latest: u64, pre_confirmed: u64) {
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_block.block_number, latest);
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
assert_eq!(pre_confirmed_block.block_number, pre_confirmed);
}
// State setup
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let first_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let second_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_block_number(&devnet, 2, 3).await;
// Block abortion - latest block only
let aborted_blocks =
devnet.abort_blocks(&BlockId::Hash(second_block.block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![second_block.block_hash]);
assert_block_number(&devnet, 1, 2).await;
let aborted_blocks = devnet.abort_blocks(&BlockId::Hash(first_block.block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![first_block.block_hash]);
assert_block_number(&devnet, 0, 1).await;
// Re-gain balance
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
assert_block_number(&devnet, 1, 2).await;
}
#[tokio::test]
async fn abort_blocks_without_state_archive_capacity() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let new_block_hash = devnet.create_block().await.unwrap();
abort_blocks_error(
&devnet,
&BlockId::Hash(new_block_hash),
"The abort blocks feature requires state-archive-capacity set to full",
)
.await
.unwrap();
}
#[tokio::test]
async fn abort_same_block_twice() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let first_block_hash = devnet.create_block().await.unwrap();
let second_block_hash = devnet.create_block().await.unwrap();
let aborted_blocks = devnet.abort_blocks(&BlockId::Hash(first_block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![second_block_hash, first_block_hash]);
abort_blocks_error(&devnet, &BlockId::Hash(first_block_hash), "No block found").await.unwrap();
abort_blocks_error(&devnet, &BlockId::Hash(second_block_hash), "No block found").await.unwrap();
}
#[tokio::test]
/// The purpose of this test to prevent a bug which overwrote the list of aborted blocks with newly
/// aborted blocks, thus forgetting old abortions.
async fn abort_same_block_twice_if_blocks_aborted_on_two_occasions() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let first_block_hash = devnet.create_block().await.unwrap();
let second_block_hash = devnet.create_block().await.unwrap();
let first_aborted_blocks =
devnet.abort_blocks(&BlockId::Hash(second_block_hash)).await.unwrap();
assert_eq!(first_aborted_blocks, vec![second_block_hash]);
let second_aborted_blocks =
devnet.abort_blocks(&BlockId::Hash(first_block_hash)).await.unwrap();
assert_eq!(second_aborted_blocks, vec![first_block_hash]);
abort_blocks_error(&devnet, &BlockId::Hash(first_block_hash), "No block found").await.unwrap();
abort_blocks_error(&devnet, &BlockId::Hash(second_block_hash), "No block found").await.unwrap();
}
#[tokio::test]
async fn abort_block_after_fork() {
let origin_devnet: BackgroundDevnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let fork_devnet = origin_devnet.fork_with_full_state_archive().await.unwrap();
let fork_block_hash = fork_devnet.create_block().await.unwrap();
let aborted_blocks = fork_devnet.abort_blocks(&BlockId::Hash(fork_block_hash)).await.unwrap();
assert_eq!(aborted_blocks, vec![fork_block_hash]);
abort_blocks_error(&fork_devnet, &BlockId::Hash(fork_block_hash), "No block found")
.await
.unwrap();
}
#[tokio::test]
async fn abort_latest_blocks() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
for _ in 0..3 {
devnet.create_block().await.unwrap();
}
for _ in 0..3 {
devnet.abort_blocks(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
}
abort_blocks_error(&devnet, &BlockId::Tag(BlockTag::Latest), "Genesis block can't be aborted")
.await
.unwrap();
}
#[tokio::test]
async fn abort_pre_confirmed_block() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--state-archive-capacity",
"full",
"--block-generation-on",
"demand",
])
.await
.expect("Could not start Devnet");
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
devnet.create_block().await.unwrap();
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let pre_confirmed_balance = devnet
.get_balance_by_tag(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri, BlockTag::PreConfirmed)
.await
.unwrap();
assert_eq!(pre_confirmed_balance, (2 * DUMMY_AMOUNT).into());
devnet.abort_blocks(&BlockId::Tag(BlockTag::PreConfirmed)).await.unwrap();
let latest_balance =
devnet.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(latest_balance, DUMMY_AMOUNT.into());
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_accepting_blocks_on_l1.rs | tests/integration/test_accepting_blocks_on_l1.rs | use starknet_rs_core::types::{
BlockId, BlockStatus, BlockTag, Felt, MaybePreConfirmedBlockWithTxHashes,
SequencerTransactionStatus, StarknetError,
};
use starknet_rs_providers::{Provider, ProviderError};
use crate::assert_eq_prop;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::errors::RpcError;
/// Returns the hash of the dummy tx
async fn send_dummy_tx(devnet: &BackgroundDevnet) -> Felt {
devnet.mint(Felt::ONE, 1).await // dummy data
}
/// Asserts blocks and txs are accepted on L1. `block_hashes` are expected in reverse chronological
/// and `tx_hashes` in chronological order.
async fn assert_accepted_on_l1(
devnet: &BackgroundDevnet,
block_hashes: &[Felt],
tx_hashes: &[Felt],
) -> Result<(), anyhow::Error> {
for block_hash in block_hashes {
match devnet.json_rpc_client.get_block_with_tx_hashes(BlockId::Hash(*block_hash)).await {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(block)) => {
assert_eq_prop!(block.status, BlockStatus::AcceptedOnL1)?;
}
other => anyhow::bail!("Unexpected block: {other:?}"),
}
}
for tx_hash in tx_hashes {
let tx_status = devnet.json_rpc_client.get_transaction_status(tx_hash).await.unwrap();
assert_eq_prop!(tx_status.finality_status(), SequencerTransactionStatus::AcceptedOnL1)?;
}
Ok(())
}
async fn assert_latest_accepted_on_l2(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let latest_block = devnet.get_latest_block_with_tx_hashes().await?;
assert_eq_prop!(latest_block.status, BlockStatus::AcceptedOnL2)?;
for tx_hash in latest_block.transactions {
let tx_status = devnet.json_rpc_client.get_transaction_status(tx_hash).await?;
assert_eq_prop!(tx_status.finality_status(), SequencerTransactionStatus::AcceptedOnL2)?;
}
Ok(())
}
#[tokio::test]
async fn should_convert_accepted_on_l2_with_id_latest() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mut tx_hashes = vec![];
let origin_block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
let mut block_hashes = vec![origin_block_hash];
for _ in 0..2 {
let tx_hash = send_dummy_tx(&devnet).await;
tx_hashes.push(tx_hash);
let block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
block_hashes.push(block_hash);
}
block_hashes.reverse(); // the hashes are in reverse chronological order
let accepted_block_hashes = devnet.accept_on_l1(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
assert_eq!(accepted_block_hashes, block_hashes);
assert_accepted_on_l1(&devnet, &block_hashes, &tx_hashes).await.unwrap();
}
#[tokio::test]
async fn should_convert_all_txs_in_block_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
let mut tx_hashes = vec![];
let origin_block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
for _ in 0..2 {
let tx_hash = send_dummy_tx(&devnet).await;
tx_hashes.push(tx_hash);
}
let generated_block_hash = devnet.create_block().await.unwrap();
let block_hashes = vec![generated_block_hash, origin_block_hash];
let accepted_block_hashes = devnet.accept_on_l1(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
assert_eq!(accepted_block_hashes, block_hashes);
assert_accepted_on_l1(&devnet, &block_hashes, &tx_hashes).await.unwrap();
}
#[tokio::test]
async fn should_convert_accepted_on_l2_with_numeric_id() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let origin_block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
let mut block_hashes = vec![origin_block_hash];
let tx_hash = send_dummy_tx(&devnet).await;
let block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
block_hashes.push(block_hash);
// Extra tx that won't be accepted on l1
send_dummy_tx(&devnet).await;
block_hashes.reverse(); // the hashes are in reverse chronological order
let accepted_block_hashes = devnet.accept_on_l1(&BlockId::Number(1)).await.unwrap();
assert_eq!(accepted_block_hashes, block_hashes);
assert_accepted_on_l1(&devnet, &block_hashes, &[tx_hash]).await.unwrap();
assert_latest_accepted_on_l2(&devnet).await.unwrap();
}
#[tokio::test]
async fn should_convert_accepted_on_l2_with_hash_id() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let origin_block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
let mut block_hashes = vec![origin_block_hash];
let tx_hash = send_dummy_tx(&devnet).await;
let block_hash = devnet.get_latest_block_with_tx_hashes().await.unwrap().block_hash;
block_hashes.push(block_hash);
// Extra tx that won't be accepted on l1
send_dummy_tx(&devnet).await;
block_hashes.reverse(); // the hashes are in reverse chronological order
let accepted_block_hashes = devnet.accept_on_l1(&BlockId::Hash(block_hash)).await.unwrap();
assert_eq!(accepted_block_hashes, block_hashes);
assert_accepted_on_l1(&devnet, &block_hashes, &[tx_hash]).await.unwrap();
assert_latest_accepted_on_l2(&devnet).await.unwrap();
}
#[tokio::test]
async fn block_tag_l1_accepted_should_return_last_accepted_on_l1() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let origin_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let created_block_hash = devnet.create_block().await.unwrap();
let accepted = devnet.accept_on_l1(&BlockId::Hash(created_block_hash)).await.unwrap();
assert_eq!(accepted, vec![created_block_hash, origin_block.block_hash]);
let l1_accepted_block = devnet.get_l1_accepted_block_with_tx_hashes().await.unwrap();
assert_eq!(l1_accepted_block.block_hash, created_block_hash);
// Creating a new block should not affect the response
let latest_block_hash = devnet.create_block().await.unwrap();
let l1_accepted_block = devnet.get_l1_accepted_block_with_tx_hashes().await.unwrap();
assert_eq!(l1_accepted_block.block_hash, created_block_hash);
assert_ne!(l1_accepted_block.block_hash, latest_block_hash);
}
#[tokio::test]
async fn origin_block_should_be_acceptable_on_l1() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mut origin_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let accepted = devnet.accept_on_l1(&BlockId::Hash(origin_block.block_hash)).await.unwrap();
assert_eq!(accepted, vec![origin_block.block_hash]);
let l1_accepted_block = devnet.get_l1_accepted_block_with_tx_hashes().await.unwrap();
origin_block.status = BlockStatus::AcceptedOnL1;
assert_eq!(origin_block, l1_accepted_block);
}
#[tokio::test]
async fn block_tag_l1_accepted_should_error_if_no_blocks_accepted_on_l1() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let err = devnet.get_l1_accepted_block_with_tx_hashes().await.unwrap_err();
match err.downcast::<ProviderError>().unwrap() {
ProviderError::StarknetError(StarknetError::BlockNotFound) => (),
other => panic!("Unexpected error: {other:?}"),
}
}
#[tokio::test]
async fn should_fail_if_accepting_already_accepted_on_l1() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
devnet.accept_on_l1(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
let err = devnet.accept_on_l1(&BlockId::Tag(BlockTag::Latest)).await.unwrap_err();
assert_eq!(
err,
RpcError { code: -1, message: "Block already accepted on L1".into(), data: None }
);
}
#[tokio::test]
async fn should_fail_if_accepting_pre_confirmed() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
let tx_hash = send_dummy_tx(&devnet).await;
let err = devnet.accept_on_l1(&BlockId::Tag(BlockTag::PreConfirmed)).await.unwrap_err();
assert_eq!(
err,
RpcError {
code: -1,
message: "Pre-confirmed block cannot be accepted on L1".into(),
data: None
}
);
let tx = devnet.json_rpc_client.get_transaction_status(tx_hash).await.unwrap();
assert_eq!(tx.finality_status(), SequencerTransactionStatus::PreConfirmed);
// Assert genesis still latest
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_block.block_number, 0);
// Assert pre_confirmed intact
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
assert_eq!(pre_confirmed_block.transactions, vec![tx_hash]);
}
#[tokio::test]
async fn should_fail_if_accepting_rejected() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.unwrap();
send_dummy_tx(&devnet).await;
let aborted_blocks = devnet.abort_blocks(&BlockId::Tag(BlockTag::Latest)).await.unwrap();
assert_eq!(aborted_blocks.len(), 1);
let aborted_block_hash = aborted_blocks[0];
let err = devnet.accept_on_l1(&BlockId::Hash(aborted_block_hash)).await.unwrap_err();
assert_eq!(err, RpcError { code: -1, message: "No block found".into(), data: None });
}
#[tokio::test]
async fn should_fail_if_invalid_block_id() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
for unacceptable_block_id in [BlockId::Hash(Felt::ONE), BlockId::Number(1)] {
let err = devnet.accept_on_l1(&unacceptable_block_id).await.unwrap_err();
assert_eq!(err, RpcError { code: -1, message: "No block found".into(), data: None });
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_dump_and_load.rs | tests/integration/test_dump_and_load.rs | use std::path::Path;
use std::time;
use serde_json::json;
use starknet_rs_providers::Provider;
use crate::assert_eq_prop;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
FeeUnit, UniqueAutoDeletableFile, new_contract_factory, send_ctrl_c_signal_and_wait,
};
static DUMMY_ADDRESS: u128 = 1;
static DUMMY_AMOUNT: u128 = 1;
use std::sync::Arc;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{DeclareTransaction, Felt, InvokeTransaction, Transaction};
use crate::common::utils::get_events_contract_artifacts;
async fn dump_load_dump_load(mode: &str) -> Result<(), anyhow::Error> {
let dump_file =
UniqueAutoDeletableFile::new(("dump_load_dump_load_on_".to_owned() + mode).as_str());
for _ in 0..2 {
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
mode,
])
.await?;
devnet_dump.create_block().await.unwrap();
devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
send_ctrl_c_signal_and_wait(&devnet_dump.process).await;
}
let devnet_load = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
mode,
])
.await?;
let last_block = devnet_load.get_latest_block_with_tx_hashes().await?;
assert_eq_prop!(last_block.block_number, 4)
}
#[tokio::test]
async fn dump_load_dump_load_without_path() {
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&["--dump-on", "request"])
.await
.expect("Could not start Devnet");
for _ in 0..2 {
devnet_dump.create_block().await.unwrap();
devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
}
let dump_rpc = devnet_dump.send_custom_rpc("devnet_dump", json!({})).await.unwrap().to_string();
let dump_file = UniqueAutoDeletableFile::new("dump_load_dump_load_on_request_nofile");
std::fs::write(&dump_file.path, dump_rpc).expect("Failed to write dump file");
let devnet_load = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"request",
])
.await
.expect("Could not start Devnet");
let last_block = devnet_load.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(last_block.block_number, 4);
let loaded_balance =
devnet_load.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(loaded_balance, Felt::from(DUMMY_AMOUNT * 2));
}
#[tokio::test]
async fn dump_load_dump_load_on_exit() {
dump_load_dump_load("exit").await.unwrap();
}
#[tokio::test]
async fn dump_load_dump_load_on_transaction() {
dump_load_dump_load("block").await.unwrap();
}
#[tokio::test]
async fn dump_wrong_cli_parameters_path() {
let devnet_dump =
BackgroundDevnet::spawn_with_additional_args(&["--dump-path", "///", "--dump-on", "block"])
.await;
assert!(devnet_dump.is_err());
}
#[tokio::test]
async fn dump_and_load_blocks_generation_on_demand() {
let modes = vec!["exit", "block"];
for mode in modes {
let dump_file =
UniqueAutoDeletableFile::new(("dump_load_dump_load_on_".to_owned() + mode).as_str());
let total_iterations = 2;
for _ in 0..total_iterations {
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
mode,
"--block-generation-on",
"demand",
])
.await
.expect("Could not start Devnet");
devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
devnet_dump.create_block().await.unwrap();
send_ctrl_c_signal_and_wait(&devnet_dump.process).await;
}
let devnet_load = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
mode,
"--block-generation-on",
"demand",
])
.await
.expect("Could not start Devnet");
let last_block = devnet_load.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(last_block.block_number, total_iterations);
assert_eq!(last_block.transactions.len(), total_iterations as usize);
}
}
#[tokio::test]
async fn mint_dump_on_transaction_and_load() {
// dump after transaction
let dump_file = UniqueAutoDeletableFile::new("dump_on_transaction");
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"block",
])
.await
.expect("Could not start Devnet");
let mint_tx_hash_1 = devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let mint_tx_hash_2 = devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
// load transaction from file and check transaction hash
let devnet_load =
BackgroundDevnet::spawn_with_additional_args(&["--dump-path", &dump_file.path])
.await
.expect("Could not start Devnet");
let loaded_tx_1 =
devnet_load.json_rpc_client.get_transaction_by_hash(mint_tx_hash_1).await.unwrap();
if let Transaction::Invoke(InvokeTransaction::V3(tx)) = loaded_tx_1 {
assert_eq!(tx.transaction_hash, mint_tx_hash_1);
} else {
panic!("Could not unpack the transaction from {loaded_tx_1:?}");
}
let loaded_tx_2 =
devnet_load.json_rpc_client.get_transaction_by_hash(mint_tx_hash_2).await.unwrap();
if let Transaction::Invoke(InvokeTransaction::V3(tx)) = loaded_tx_2 {
assert_eq!(tx.transaction_hash, mint_tx_hash_2);
} else {
panic!("Could not unpack the transaction from {loaded_tx_2:?}");
}
}
#[tokio::test]
async fn mint_dump_on_exit_and_load() {
// dump on exit
let dump_file = UniqueAutoDeletableFile::new("dump_on_exit");
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
dump_file.path.as_str(),
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
let devnet_dump_pid = devnet_dump.process.id();
let mint_tx_hash = devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
send_ctrl_c_signal_and_wait(&devnet_dump.process).await;
// load transaction from file and check transaction hash
let devnet_load =
BackgroundDevnet::spawn_with_additional_args(&["--dump-path", &dump_file.path])
.await
.expect("Could not start Devnet");
let devnet_load_pid = devnet_load.process.id();
assert_ne!(devnet_dump_pid, devnet_load_pid); // if PID's are different SIGINT signal worked
let loaded_transaction =
devnet_load.json_rpc_client.get_transaction_by_hash(mint_tx_hash).await.unwrap();
if let Transaction::Invoke(InvokeTransaction::V3(tx)) = loaded_transaction {
assert_eq!(tx.transaction_hash, mint_tx_hash);
} else {
panic!("Could not unpack the transaction from {loaded_transaction:?}");
}
}
#[tokio::test]
async fn declare_deploy() {
let dump_file = UniqueAutoDeletableFile::new("dump_declare_deploy");
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"block",
])
.await
.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (cairo_1_contract, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await
.unwrap();
let predeployed_account = Arc::new(predeployed_account);
// deploy the contract
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
let deploy_result = contract_factory
.deploy_v3(vec![], Felt::ZERO, false)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
// load transaction from file and check transactions hashes
let devnet_load =
BackgroundDevnet::spawn_with_additional_args(&["--dump-path", &dump_file.path])
.await
.expect("Could not start Devnet");
// check declare transaction
let loaded_declare = devnet_load
.json_rpc_client
.get_transaction_by_hash(declaration_result.transaction_hash)
.await
.unwrap();
if let Transaction::Declare(DeclareTransaction::V3(tx)) = loaded_declare {
assert_eq!(tx.transaction_hash, declaration_result.transaction_hash);
} else {
panic!("Could not unpack the transaction from {loaded_declare:?}");
}
// check deploy transaction
let loaded_deploy = devnet_load
.json_rpc_client
.get_transaction_by_hash(deploy_result.transaction_hash)
.await
.unwrap();
if let Transaction::Invoke(InvokeTransaction::V3(tx)) = loaded_deploy {
assert_eq!(tx.transaction_hash, deploy_result.transaction_hash);
} else {
panic!("Could not unpack the transaction from {loaded_deploy:?}");
}
}
#[tokio::test]
async fn dump_without_transaction() {
// dump on exit
let dump_file = UniqueAutoDeletableFile::new("dump_without_transaction");
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
send_ctrl_c_signal_and_wait(&devnet_dump.process).await;
// file should not be created if there are no transactions
if Path::new(&dump_file.path).exists() {
panic!(
"Could find the dump file but there were no transactions to dump {}",
&dump_file.path
);
}
}
#[tokio::test]
async fn dump_endpoint_fail_with_no_mode_set() {
let devnet_dump = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let rpc_error = devnet_dump.send_custom_rpc("devnet_dump", json!({})).await.unwrap_err();
assert!(rpc_error.message.contains("Please provide --dump-on mode"));
}
#[tokio::test]
async fn dump_endpoint_fail_with_wrong_request() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let err = devnet.send_custom_rpc("devnet_dump", json!({ "test": "" })).await.unwrap_err();
assert_eq!(err.code, -32602);
}
#[tokio::test]
async fn dump_endpoint_fail_with_wrong_file_name() {
let dump_file = UniqueAutoDeletableFile::new("dump_wrong_file_name");
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let err = devnet.send_custom_rpc("devnet_dump", json!({ "path": "///" })).await.unwrap_err();
assert!(err.message.contains("I/O error"));
}
#[tokio::test]
async fn load_endpoint_fail_with_wrong_request() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let err = devnet.send_custom_rpc("devnet_load", json!({ "test": "" })).await.unwrap_err();
assert_eq!(err.code, -32602);
}
#[tokio::test]
async fn load_endpoint_fail_with_wrong_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let err = devnet
.send_custom_rpc("devnet_load", json!({ "path": "load_file_name" }))
.await
.unwrap_err();
assert!(err.message.contains("file does not exist"));
}
#[tokio::test]
async fn dump_load_endpoints_transaction_and_state_after_load_is_valid() {
// check if the dump with the default path "dump_endpoint" works as expected when json body
// is empty, later check if the dump with the custom path "dump_endpoint_custom_path"
// works
let dump_file = UniqueAutoDeletableFile::new("dump_endpoint");
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
let mint_tx_hash = devnet_dump.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
devnet_dump.send_custom_rpc("devnet_dump", json!({})).await.unwrap();
assert!(Path::new(&dump_file.path).exists());
let dump_file_custom = UniqueAutoDeletableFile::new("dump_endpoint_custom_path");
devnet_dump
.send_custom_rpc("devnet_dump", json!({ "path": dump_file_custom.path }))
.await
.unwrap();
assert!(Path::new(&dump_file_custom.path).exists());
// load and re-execute from "dump_endpoint" file and check if transaction and state of the
// blockchain is valid
let devnet_load = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
devnet_load.send_custom_rpc("devnet_load", json!({ "path": dump_file.path })).await.unwrap();
let balance_result =
devnet_load.get_balance_latest(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri).await.unwrap();
assert_eq!(balance_result, Felt::from(DUMMY_AMOUNT));
let loaded_transaction =
devnet_load.json_rpc_client.get_transaction_by_hash(mint_tx_hash).await.unwrap();
if let Transaction::Invoke(InvokeTransaction::V3(tx)) = loaded_transaction {
assert_eq!(tx.transaction_hash, mint_tx_hash);
} else {
panic!("Could not unpack the transaction from {loaded_transaction:?}");
}
}
#[tokio::test]
async fn mint_and_dump_and_load_on_same_devnet() {
let dump_file = UniqueAutoDeletableFile::new("dump");
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-on",
"exit",
"--dump-path",
&dump_file.path,
])
.await
.unwrap();
let unit = FeeUnit::Wei;
devnet.mint_unit(DUMMY_ADDRESS, DUMMY_AMOUNT, unit).await;
let balance_before_dump = devnet.get_balance_latest(&DUMMY_ADDRESS.into(), unit).await.unwrap();
assert_eq!(balance_before_dump, Felt::from(DUMMY_AMOUNT));
devnet.send_custom_rpc("devnet_dump", json!({ "path": dump_file.path })).await.unwrap();
devnet.mint_unit(DUMMY_ADDRESS, DUMMY_AMOUNT, unit).await;
let balance_after_dump = devnet.get_balance_latest(&DUMMY_ADDRESS.into(), unit).await.unwrap();
assert_eq!(balance_after_dump, balance_before_dump + Felt::from(DUMMY_AMOUNT));
devnet.send_custom_rpc("devnet_load", json!({ "path": dump_file.path })).await.unwrap();
let balance_after_load = devnet.get_balance_latest(&DUMMY_ADDRESS.into(), unit).await.unwrap();
assert_eq!(balance_after_load, balance_before_dump);
devnet.mint_unit(DUMMY_ADDRESS, DUMMY_AMOUNT, unit).await;
let balance_after_mint_on_loaded =
devnet.get_balance_latest(&DUMMY_ADDRESS.into(), unit).await.unwrap();
assert_eq!(balance_after_mint_on_loaded, balance_after_load + Felt::from(DUMMY_AMOUNT));
}
#[tokio::test]
async fn set_time_with_later_block_generation_dump_and_load() {
let dump_file = UniqueAutoDeletableFile::new("dump_set_time");
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
// set time in past without block generation
let past_time = 1;
devnet_dump
.send_custom_rpc("devnet_setTime", json!({ "time": past_time, "generate_block": false }))
.await
.unwrap();
// wait 1 second
tokio::time::sleep(time::Duration::from_secs(1)).await;
devnet_dump.create_block().await.unwrap();
devnet_dump.get_latest_block_with_tx_hashes().await.unwrap();
// dump and load
send_ctrl_c_signal_and_wait(&devnet_dump.process).await;
// load and assert
let devnet_load =
BackgroundDevnet::spawn_with_additional_args(&["--dump-path", &dump_file.path])
.await
.expect("Could not start Devnet");
let latest_block = devnet_load.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_block.block_number, 1);
assert_eq!(latest_block.timestamp, past_time);
}
#[tokio::test]
async fn test_dumping_after_restart() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--dump-on", "request"]).await.unwrap();
// mint, restart, assert dump empty
let address = Felt::ONE;
let mint_amount = 100;
devnet.mint(address, mint_amount).await;
devnet.restart().await;
let dump_resp = devnet.send_custom_rpc("devnet_dump", serde_json::Value::Null).await.unwrap();
assert_eq!(dump_resp, json!([]));
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_get_class.rs | tests/integration/test_get_class.rs | use std::sync::Arc;
use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
use starknet_core::CasmContractClass;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::chain_id;
use starknet_rs_core::types::{BlockId, BlockTag, ContractClass, Felt, StarknetError};
use starknet_rs_providers::jsonrpc::JsonRpcError;
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH, PREDEPLOYED_ACCOUNT_ADDRESS};
use crate::common::utils::{
assert_cairo1_classes_equal, get_events_contract_artifacts,
get_flattened_sierra_contract_and_casm_hash,
};
#[tokio::test]
async fn test_getting_class_at() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
devnet
.json_rpc_client
.get_class_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.unwrap();
}
#[tokio::test]
async fn test_getting_class() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let retrieved_hash = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.unwrap();
devnet.json_rpc_client.get_class(BlockId::Tag(BlockTag::Latest), retrieved_hash).await.unwrap();
}
#[tokio::test]
async fn test_getting_class_of_declared_cairo1_contract() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
chain_id::SEPOLIA,
ExecutionEncoding::New,
));
let (contract_class, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(contract_class.clone()), casm_class_hash)
.send()
.await
.unwrap();
let retrieved_class = devnet
.json_rpc_client
.get_class(BlockId::Tag(BlockTag::Latest), declaration_result.class_hash)
.await
.unwrap();
assert_cairo1_classes_equal(&retrieved_class, &ContractClass::Sierra(contract_class)).unwrap();
}
#[tokio::test]
async fn test_getting_class_at_invalid_address() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked("0x22");
let err = devnet
.json_rpc_client
.get_class_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.expect_err("Should have failed");
match err {
ProviderError::StarknetError(StarknetError::ContractNotFound) => (),
_ => panic!("Invalid error: {err:?}"),
}
}
#[tokio::test]
async fn test_getting_class_with_blocks_on_demand() {
let devnet_args = ["--state-archive-capacity", "full", "--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
chain_id::SEPOLIA,
ExecutionEncoding::New,
));
let (contract_class, casm_class_hash) = get_events_contract_artifacts();
let original_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(contract_class.clone()), casm_class_hash)
.send()
.await
.unwrap();
// getting class at the following block IDs should NOT be successful
let declaration_block_number = BlockId::Number(original_block.block_number + 1);
for (block_id, expected_err) in [
(BlockId::Number(original_block.block_number), StarknetError::ClassHashNotFound),
(BlockId::Hash(original_block.block_hash), StarknetError::ClassHashNotFound),
(BlockId::Tag(BlockTag::Latest), StarknetError::ClassHashNotFound),
(declaration_block_number, StarknetError::BlockNotFound),
] {
let retrieved =
devnet.json_rpc_client.get_class(block_id, declaration_result.class_hash).await;
match retrieved {
Err(ProviderError::StarknetError(err)) => assert_eq!(err, expected_err),
other => panic!("Unexpected response at block_id={block_id:?}: {other:?}"),
}
}
// getting class at the following block IDs should be successful even before block creation
let expected_class = ContractClass::Sierra(contract_class);
for block_id in [BlockId::Tag(BlockTag::PreConfirmed)] {
let retrieved_class = devnet
.json_rpc_client
.get_class(block_id, declaration_result.class_hash)
.await
.unwrap();
assert_cairo1_classes_equal(&retrieved_class, &expected_class).unwrap();
}
let declaration_block_hash = devnet.create_block().await.unwrap();
// getting class at the following block IDs should be successful after block creation
for block_id in [
BlockId::Tag(BlockTag::Latest),
BlockId::Tag(BlockTag::PreConfirmed),
declaration_block_number,
BlockId::Hash(declaration_block_hash),
] {
let retrieved_class = devnet
.json_rpc_client
.get_class(block_id, declaration_result.class_hash)
.await
.unwrap();
assert_cairo1_classes_equal(&retrieved_class, &expected_class).unwrap();
}
}
#[tokio::test]
async fn test_getting_class_after_block_abortion() {
let devnet_args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
chain_id::SEPOLIA,
ExecutionEncoding::New,
));
let (contract_class, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(contract_class.clone()), casm_class_hash)
.send()
.await
.unwrap();
let abortable_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
devnet.abort_blocks(&BlockId::Hash(abortable_block.block_hash)).await.unwrap();
// Getting class at the following block IDs should NOT be successful after abortion; these
// blocks exist, but their states don't contain the class.
for (block_id, expected_err) in [
// this block's state is invalidated
(BlockId::Number(abortable_block.block_number), StarknetError::BlockNotFound),
(BlockId::Hash(abortable_block.block_hash), StarknetError::BlockNotFound),
(BlockId::Tag(BlockTag::Latest), StarknetError::ClassHashNotFound),
(BlockId::Tag(BlockTag::PreConfirmed), StarknetError::ClassHashNotFound),
] {
let retrieved =
devnet.json_rpc_client.get_class(block_id, declaration_result.class_hash).await;
match retrieved {
Err(ProviderError::StarknetError(err)) => assert_eq!(err, expected_err),
other => panic!("Unexpected response at block_id={block_id:?}: {other:?}"),
}
}
let latest_block_hash = devnet.create_block().await.unwrap();
// getting class at the following block IDs should NOT be successful after creating a block
// that has the same number that the aborted block had
for (block_id, expected_err) in [
(BlockId::Number(abortable_block.block_number), StarknetError::ClassHashNotFound),
(BlockId::Hash(abortable_block.block_hash), StarknetError::BlockNotFound),
(BlockId::Hash(latest_block_hash), StarknetError::ClassHashNotFound),
(BlockId::Tag(BlockTag::Latest), StarknetError::ClassHashNotFound),
(BlockId::Tag(BlockTag::PreConfirmed), StarknetError::ClassHashNotFound),
] {
let retrieved =
devnet.json_rpc_client.get_class(block_id, declaration_result.class_hash).await;
match retrieved {
Err(ProviderError::StarknetError(err)) => assert_eq!(err, expected_err),
other => panic!("Unexpected response at block_id={block_id:?}: {other:?}"),
}
}
}
#[tokio::test]
async fn getting_compiled_casm_for_cairo0_or_non_existing_hash_should_return_class_hash_not_found_error()
{
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--account-class", "cairo0"])
.await
.expect("Could not start Devnet");
let (_, account_address) = devnet.get_first_predeployed_account().await;
let block_id = BlockId::Tag(BlockTag::Latest);
let class_hash =
devnet.json_rpc_client.get_class_hash_at(block_id, account_address).await.unwrap();
// Felt::ONE is non existing class hash
for el in [class_hash, Felt::ONE] {
match get_compiled_casm(&devnet, el).await.unwrap_err() {
StarknetError::ClassHashNotFound => {}
other => panic!("Unexpected error {:?}", other),
}
}
}
#[tokio::test]
async fn getting_compiled_casm_for_cairo_1_should_succeed() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--account-class", "cairo1"])
.await
.expect("Could not start Devnet");
let (_, expected_casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH);
let (_, account_address) = devnet.get_first_predeployed_account().await;
let block_id = BlockId::Tag(BlockTag::Latest);
let class_hash =
devnet.json_rpc_client.get_class_hash_at(block_id, account_address).await.unwrap();
let casm = get_compiled_casm(&devnet, class_hash).await.unwrap();
assert_eq!(casm.hash(&HashVersion::V2).0, expected_casm_hash);
}
async fn get_compiled_casm(
devnet: &BackgroundDevnet,
class_hash: Felt,
) -> Result<CasmContractClass, StarknetError> {
devnet
.send_custom_rpc(
"starknet_getCompiledCasm",
serde_json::json!({ "class_hash": class_hash }),
)
.await
.map(|json_value| {
// Check done because `CasmContractClass` does not perfectly correspond to RPC spec
assert!(json_value.get("pythonic_hints").is_none());
serde_json::from_value::<CasmContractClass>(json_value).unwrap()
})
.map_err(|err| {
let json_rpc_error =
JsonRpcError { code: err.code, message: err.message.to_string(), data: err.data };
(&json_rpc_error).try_into().unwrap()
})
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_blocks_generation.rs | tests/integration/test_blocks_generation.rs | use std::sync::Arc;
use std::time;
use anyhow::anyhow;
use serde_json::json;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
BlockId, BlockStatus, BlockTag, Call, DeclaredClassItem, Felt, FunctionCall,
MaybePreConfirmedStateUpdate, NonceUpdate, StateUpdate, TransactionTrace,
};
use starknet_rs_core::utils::{
get_selector_from_name, get_storage_var_address, get_udc_deployed_address,
};
use starknet_rs_providers::Provider;
use starknet_rs_signers::Signer;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{self, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH};
use crate::common::utils::{
FeeUnit, UniqueAutoDeletableFile, assert_equal_elements, assert_tx_succeeded_accepted,
assert_tx_succeeded_pre_confirmed, get_contract_balance, get_contract_balance_by_block_id,
get_events_contract_artifacts, get_simple_contract_artifacts, new_contract_factory,
send_ctrl_c_signal_and_wait,
};
use crate::{assert_eq_prop, assert_prop};
static DUMMY_ADDRESS: u128 = 1;
static DUMMY_AMOUNT: u128 = 1;
async fn assert_pre_confirmed_state_update(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let pre_confirmed_state_update =
&devnet.json_rpc_client.get_state_update(BlockId::Tag(BlockTag::PreConfirmed)).await?;
assert_prop!(
matches!(pre_confirmed_state_update, MaybePreConfirmedStateUpdate::PreConfirmedUpdate(_)),
"Expected a pre-confirmed state update, but found: "
)
}
async fn assert_latest_state_update(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let latest_state_update =
&devnet.json_rpc_client.get_state_update(BlockId::Tag(BlockTag::Latest)).await?;
assert_prop!(
matches!(latest_state_update, MaybePreConfirmedStateUpdate::Update(_)),
"Expected an update state update, but found: "
)
}
async fn assert_latest_block_with_tx_hashes(
devnet: &BackgroundDevnet,
block_number: u64,
transactions: Vec<Felt>,
n_events: u64,
) -> Result<(), anyhow::Error> {
let latest_block = devnet.get_latest_block_with_tx_hashes().await?;
assert_eq_prop!(latest_block.block_number, block_number)?;
assert_eq_prop!(transactions, latest_block.transactions)?;
assert_eq_prop!(transactions.len(), latest_block.transaction_count as usize)?;
assert_eq_prop!(n_events, latest_block.event_count)?;
assert_eq_prop!(latest_block.status, BlockStatus::AcceptedOnL2)?;
for tx_hash in latest_block.transactions {
assert_tx_succeeded_accepted(&tx_hash, &devnet.json_rpc_client).await?;
}
Ok(())
}
async fn assert_pre_confirmed_block_with_tx_hashes(
devnet: &BackgroundDevnet,
tx_count: usize,
) -> Result<(), anyhow::Error> {
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await?;
assert_eq_prop!(pre_confirmed_block.transactions.len(), tx_count)?;
for tx_hash in pre_confirmed_block.transactions {
assert_tx_succeeded_pre_confirmed(&tx_hash, &devnet.json_rpc_client).await?;
}
Ok(())
}
async fn assert_latest_block_with_txs(
devnet: &BackgroundDevnet,
block_number: u64,
tx_count: usize,
) -> Result<(), anyhow::Error> {
let latest_block = devnet.get_latest_block_with_txs().await?;
assert_eq_prop!(latest_block.block_number, block_number)?;
assert_eq_prop!(latest_block.status, BlockStatus::AcceptedOnL2)?;
assert_eq_prop!(latest_block.transactions.len(), tx_count)?;
for tx in latest_block.transactions {
assert_tx_succeeded_accepted(tx.transaction_hash(), &devnet.json_rpc_client).await?;
}
Ok(())
}
async fn assert_pre_confirmed_block_with_txs(
devnet: &BackgroundDevnet,
tx_count: usize,
) -> Result<(), anyhow::Error> {
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_txs().await?;
assert_eq_prop!(pre_confirmed_block.transactions.len(), tx_count)?;
for tx in pre_confirmed_block.transactions {
assert_tx_succeeded_pre_confirmed(tx.transaction_hash(), &devnet.json_rpc_client).await?;
}
Ok(())
}
async fn assert_latest_block_with_receipts(
devnet: &BackgroundDevnet,
block_number: u64,
tx_count: usize,
) -> Result<(), anyhow::Error> {
let latest_block = &devnet
.send_custom_rpc("starknet_getBlockWithReceipts", json!({ "block_id": "latest" }))
.await?;
let latest_block_tx_count = latest_block["transactions"]
.as_array()
.ok_or(anyhow!("cannot convert block txs to array"))?
.len();
assert_eq_prop!(latest_block_tx_count, tx_count)?;
assert_eq_prop!(latest_block["block_number"], block_number)?;
assert_eq_prop!(latest_block["status"], "ACCEPTED_ON_L2")?;
for tx in latest_block["transactions"].as_array().unwrap() {
assert_tx_succeeded_accepted(
&Felt::from_hex_unchecked(
tx["receipt"]["transaction_hash"]
.as_str()
.ok_or(anyhow!("failed to parse transaction hash"))?,
),
&devnet.json_rpc_client,
)
.await?;
}
Ok(())
}
async fn assert_pre_confirmed_block_with_receipts(
devnet: &BackgroundDevnet,
tx_count: usize,
) -> Result<(), anyhow::Error> {
let pre_confirmed_block = &devnet
.send_custom_rpc("starknet_getBlockWithReceipts", json!({ "block_id": "pre_confirmed" }))
.await?;
assert_prop!(
pre_confirmed_block["status"].is_null(),
"expected preconfirmed block status to be null, got: "
)?;
let pre_confirmed_block_tx_count = pre_confirmed_block["transactions"]
.as_array()
.ok_or(anyhow!("failed to convert block transactions to array"))?
.len();
assert_eq_prop!(pre_confirmed_block_tx_count, tx_count)?;
for tx in pre_confirmed_block["transactions"].as_array().unwrap() {
let tx_hash = Felt::from_hex_unchecked(
tx["receipt"]["transaction_hash"]
.as_str()
.ok_or(anyhow!("failed to parse transaction hash"))?,
);
assert_tx_succeeded_pre_confirmed(&tx_hash, &devnet.json_rpc_client).await?;
}
Ok(())
}
async fn assert_balance(
devnet: &BackgroundDevnet,
expected: Felt,
tag: BlockTag,
) -> Result<(), anyhow::Error> {
let balance = devnet.get_balance_by_tag(&Felt::from(DUMMY_ADDRESS), FeeUnit::Fri, tag).await?;
assert_eq_prop!(balance, expected)
}
async fn assert_get_nonce(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let (_, account_address) = devnet.get_first_predeployed_account().await;
let pre_confirmed_block_nonce = devnet
.json_rpc_client
.get_nonce(BlockId::Tag(BlockTag::PreConfirmed), account_address)
.await?;
assert_eq_prop!(pre_confirmed_block_nonce, Felt::ZERO)?;
let latest_block_nonce =
devnet.json_rpc_client.get_nonce(BlockId::Tag(BlockTag::Latest), account_address).await?;
assert_eq_prop!(latest_block_nonce, Felt::ZERO)
}
async fn assert_get_storage_at(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let (_, account_address) = devnet.get_first_predeployed_account().await;
let key = Felt::ZERO;
let pre_confirmed_block_storage = devnet
.json_rpc_client
.get_storage_at(account_address, key, BlockId::Tag(BlockTag::PreConfirmed))
.await?;
assert_eq_prop!(pre_confirmed_block_storage, Felt::ZERO)?;
let latest_block_storage = devnet
.json_rpc_client
.get_storage_at(account_address, key, BlockId::Tag(BlockTag::Latest))
.await?;
assert_eq_prop!(latest_block_storage, Felt::ZERO)
}
async fn assert_get_class_hash_at(devnet: &BackgroundDevnet) -> Result<(), anyhow::Error> {
let (_, account_address) = devnet.get_first_predeployed_account().await;
let pre_confirmed_block_class_hash = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::PreConfirmed), account_address)
.await?;
let sierra_hash = Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH);
assert_eq_prop!(pre_confirmed_block_class_hash, sierra_hash)?;
let latest_block_class_hash = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), account_address)
.await?;
assert_eq_prop!(latest_block_class_hash, sierra_hash)
}
#[tokio::test]
async fn normal_mode_states_and_blocks() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let tx_count = 5;
let mut tx_hashes = Vec::new();
for _ in 0..tx_count {
let mint_hash = devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
tx_hashes.push(mint_hash);
}
assert_balance(&devnet, Felt::from(tx_count * DUMMY_AMOUNT), BlockTag::PreConfirmed)
.await
.unwrap();
assert_balance(&devnet, Felt::from(tx_count * DUMMY_AMOUNT), BlockTag::Latest).await.unwrap();
assert_pre_confirmed_block_with_tx_hashes(&devnet, 0).await.unwrap();
assert_pre_confirmed_block_with_txs(&devnet, 0).await.unwrap();
assert_pre_confirmed_block_with_receipts(&devnet, 0).await.unwrap();
assert_latest_block_with_tx_hashes(&devnet, 5, vec![tx_hashes.last().copied().unwrap()], 2)
.await
.unwrap();
assert_latest_block_with_txs(&devnet, 5, 1).await.unwrap();
assert_latest_block_with_receipts(&devnet, 5, 1).await.unwrap();
assert_pre_confirmed_state_update(&devnet).await.unwrap();
assert_latest_state_update(&devnet).await.unwrap();
}
#[tokio::test]
async fn blocks_on_demand_states_and_blocks() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
let tx_count = 5_usize;
let mut tx_hashes = Vec::new();
for _ in 0..tx_count {
let mint_hash = devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
tx_hashes.push(mint_hash);
}
assert_balance(&devnet, Felt::from(tx_count * DUMMY_AMOUNT as usize), BlockTag::PreConfirmed)
.await
.unwrap();
assert_balance(&devnet, Felt::ZERO, BlockTag::Latest).await.unwrap();
assert_pre_confirmed_block_with_tx_hashes(&devnet, tx_count).await.unwrap();
assert_pre_confirmed_block_with_txs(&devnet, tx_count).await.unwrap();
assert_pre_confirmed_block_with_receipts(&devnet, tx_count).await.unwrap();
assert_latest_block_with_tx_hashes(&devnet, 0, vec![], 0).await.unwrap();
assert_latest_block_with_txs(&devnet, 0, 0).await.unwrap();
assert_latest_block_with_receipts(&devnet, 0, 0).await.unwrap();
// create new block from pre_confirmed block
devnet.create_block().await.unwrap();
assert_balance(&devnet, Felt::from(tx_count * DUMMY_AMOUNT as usize), BlockTag::PreConfirmed)
.await
.unwrap();
assert_balance(&devnet, Felt::from(tx_count * DUMMY_AMOUNT as usize), BlockTag::Latest)
.await
.unwrap();
assert_pre_confirmed_block_with_tx_hashes(&devnet, 0).await.unwrap();
assert_pre_confirmed_block_with_txs(&devnet, 0).await.unwrap();
assert_pre_confirmed_block_with_receipts(&devnet, 0).await.unwrap();
assert_latest_block_with_tx_hashes(&devnet, 1, tx_hashes, 10).await.unwrap();
assert_latest_block_with_txs(&devnet, 1, tx_count).await.unwrap();
assert_latest_block_with_receipts(&devnet, 1, tx_count).await.unwrap();
assert_pre_confirmed_state_update(&devnet).await.unwrap();
assert_latest_state_update(&devnet).await.unwrap();
}
#[tokio::test]
async fn blocks_on_demand_declarations() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
predeployed_account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed));
// perform declarations
let classes_with_hash = [get_simple_contract_artifacts(), get_events_contract_artifacts()];
let mut declaration_results = vec![];
for (nonce, (class, casm_hash)) in classes_with_hash.iter().enumerate() {
let declaration_result = predeployed_account
.declare_v3(Arc::new(class.clone()), *casm_hash)
.nonce(Felt::from(nonce))
.send()
.await
.unwrap();
assert_tx_succeeded_pre_confirmed(
&declaration_result.transaction_hash,
&devnet.json_rpc_client,
)
.await
.unwrap();
declaration_results.push(declaration_result);
}
let declaration_block_hash = devnet.create_block().await.unwrap();
// assert individual tx state updates
let mut expected_block_declarations = vec![];
let mut expected_nonce = 1_u32;
for (declaration_result, (_, casm_hash)) in
declaration_results.iter().zip(classes_with_hash.iter())
{
let expected_declaration = DeclaredClassItem {
class_hash: declaration_result.class_hash,
compiled_class_hash: *casm_hash,
};
expected_block_declarations.push(expected_declaration.clone());
let tx_hash = declaration_result.transaction_hash;
match devnet.json_rpc_client.trace_transaction(tx_hash).await {
Ok(TransactionTrace::Declare(trace)) => {
let state_diff = trace.state_diff.unwrap();
assert_eq!(state_diff.declared_classes, vec![expected_declaration]);
assert_eq!(
state_diff.nonces,
vec![NonceUpdate {
contract_address: account_address,
nonce: Felt::from(expected_nonce)
}]
)
}
other => panic!("Unexpected response: {other:?}"),
}
expected_nonce += 1;
}
// assert block state update - should include diff of all txs from pre_confirmed block
let expected_block_nonce_update = vec![NonceUpdate {
contract_address: account_address,
nonce: Felt::from(classes_with_hash.len()),
}];
for block_id in [BlockId::Tag(BlockTag::Latest), BlockId::Hash(declaration_block_hash)] {
match devnet.json_rpc_client.get_state_update(block_id).await {
Ok(MaybePreConfirmedStateUpdate::Update(StateUpdate { state_diff, .. })) => {
assert_equal_elements(&state_diff.declared_classes, &expected_block_declarations)
.unwrap();
assert_equal_elements(&state_diff.nonces, &expected_block_nonce_update).unwrap()
}
other => panic!("Unexpected response: {other:?}"),
}
}
}
#[tokio::test]
async fn blocks_on_demand_invoke_and_call() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
let mut tx_hashes = Vec::new();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let mut predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
predeployed_account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed));
let (contract_class, casm_class_hash) = get_simple_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(contract_class), casm_class_hash)
.nonce(Felt::ZERO)
.send()
.await
.unwrap();
tx_hashes.push(declaration_result.transaction_hash);
// deploy the contract
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
let initial_value = Felt::from(10_u32);
let ctor_args = vec![initial_value];
let deploy_result = contract_factory
.deploy_v3(ctor_args.clone(), Felt::ZERO, false)
.nonce(Felt::ONE)
.send()
.await
.unwrap();
tx_hashes.push(deploy_result.transaction_hash);
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
Felt::ZERO,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&ctor_args,
);
let increment = Felt::from(5_u32);
let contract_invoke = vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![increment, Felt::ZERO],
}];
let increment_count = 2;
for i in 1..=increment_count {
let invoke_result = predeployed_account
.execute_v3(contract_invoke.clone())
.nonce(Felt::from(i + 1_u128))
.send()
.await
.unwrap();
assert_tx_succeeded_pre_confirmed(&invoke_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
tx_hashes.push(invoke_result.transaction_hash);
}
let expected_balance = initial_value + (increment * Felt::from(increment_count));
let contract_balance = get_contract_balance_by_block_id(
&devnet,
contract_address,
BlockId::Tag(BlockTag::PreConfirmed),
)
.await
.unwrap();
assert_eq!(contract_balance, expected_balance);
let contract_call = FunctionCall {
contract_address,
entry_point_selector: get_selector_from_name("get_balance").unwrap(),
calldata: vec![],
};
let latest_block_balance =
devnet.json_rpc_client.call(contract_call, BlockId::Tag(BlockTag::Latest)).await;
assert!(latest_block_balance.is_err());
devnet.create_block().await.unwrap();
assert_latest_block_with_tx_hashes(&devnet, 1, tx_hashes, 5).await.unwrap();
let contract_balance = get_contract_balance_by_block_id(
&devnet,
contract_address,
BlockId::Tag(BlockTag::PreConfirmed),
)
.await
.unwrap();
assert_eq!(contract_balance, expected_balance);
let contract_balance = get_contract_balance(&devnet, contract_address).await.unwrap();
assert_eq!(contract_balance, expected_balance);
}
#[tokio::test]
async fn blocks_on_interval() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "2"])
.await
.expect("Could not start Devnet");
// wait for one and a half interval
tokio::time::sleep(time::Duration::from_secs(3)).await;
let last_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
// first is genesis block, second block is generated after 1 second
assert_eq!(last_block.block_number, 1);
}
#[tokio::test]
async fn blocks_on_interval_transactions() {
let period = 6;
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--block-generation-on",
&period.to_string(),
])
.await
.expect("Could not start Devnet");
let tx_count = 3;
let mut tx_hashes = Vec::new();
for _ in 0..tx_count {
let mint_hash = devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
tx_hashes.push(mint_hash);
}
// wait for one and a half interval
tokio::time::sleep(time::Duration::from_secs(period * 3 / 2)).await;
// first is genesis block, second block is generated after transactions
assert_latest_block_with_tx_hashes(&devnet, 1, tx_hashes, 6).await.unwrap();
}
#[tokio::test]
async fn blocks_on_interval_dump_and_load() {
let mode = "exit";
let dump_file = UniqueAutoDeletableFile::new("interval_dump");
let devnet_dump = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
&dump_file.path,
"--dump-on",
mode,
"--block-generation-on",
"2",
])
.await
.expect("Could not start Devnet");
// wait for one and a half interval
tokio::time::sleep(time::Duration::from_secs(3)).await;
let last_block = devnet_dump.get_latest_block_with_tx_hashes().await.unwrap();
// first is genesis block, second block is generated after 1 second
assert_eq!(last_block.block_number, 1);
send_ctrl_c_signal_and_wait(&devnet_dump.process).await;
let devnet_load = BackgroundDevnet::spawn_with_additional_args(&[
"--dump-path",
dump_file.path.as_str(),
"--dump-on",
mode,
])
.await
.expect("Could not start Devnet");
let last_block_load = devnet_load.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(last_block.block_number, last_block_load.block_number);
}
#[tokio::test]
async fn get_nonce_of_first_predeployed_account_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
assert_get_nonce(&devnet).await.unwrap();
}
#[tokio::test]
async fn get_nonce_of_first_predeployed_account_block_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
assert_get_nonce(&devnet).await.unwrap();
}
#[tokio::test]
async fn get_storage_at_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
assert_get_storage_at(&devnet).await.unwrap();
}
#[tokio::test]
async fn get_storage_at_block_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
assert_get_storage_at(&devnet).await.unwrap();
}
#[tokio::test]
async fn get_class_hash_at_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
assert_get_class_hash_at(&devnet).await.unwrap();
}
#[tokio::test]
async fn get_class_hash_at_block_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
assert_get_class_hash_at(&devnet).await.unwrap();
}
#[tokio::test]
async fn get_data_by_specifying_latest_block_hash_and_number() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let block_ids =
[BlockId::Hash(latest_block.block_hash), BlockId::Number(latest_block.block_number)];
for block_id in &block_ids {
let nonce = devnet.json_rpc_client.get_nonce(block_id, account_address).await.unwrap();
assert_eq!(nonce, Felt::ZERO);
let class_hash =
devnet.json_rpc_client.get_class_hash_at(block_id, account_address).await.unwrap();
assert_eq!(class_hash, Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH));
let key = get_storage_var_address("Account_public_key", &[]).unwrap();
let storage =
devnet.json_rpc_client.get_storage_at(account_address, key, block_id).await.unwrap();
assert_eq!(storage, signer.get_public_key().await.unwrap().scalar());
}
}
#[tokio::test]
async fn should_get_block_with_receipts() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mint_hash = devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
// Sending a custom request to allow asserting property presence/absence. Starknet-rs impl of
// block receipt doesn't report extra properties.
let block_id = BlockId::Tag(BlockTag::Latest);
let block = devnet
.send_custom_rpc("starknet_getBlockWithReceipts", json!({ "block_id": block_id }))
.await
.unwrap();
assert_eq!(block["status"], json!(BlockStatus::AcceptedOnL2));
assert_eq!(block["block_number"], json!(1));
let txs = block["transactions"].as_array().unwrap();
assert_eq!(txs.len(), 1);
// This used to be a bug
let receipt = &txs[0]["receipt"];
assert!(receipt["block_number"].is_null());
assert!(receipt["block_hash"].is_null());
assert_eq!(receipt["transaction_hash"], json!(mint_hash));
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_advancing_time_on_fork.rs | tests/integration/test_advancing_time_on_fork.rs | use starknet_rs_accounts::{Account, AccountError, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
Call, Felt, StarknetError, TransactionExecutionStatus, TransactionStatus,
};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::{Provider, ProviderError};
use starknet_rs_signers::{LocalWallet, SigningKey};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
ImpersonationAction, assert_contains, declare_v3_deploy_v3, extract_message_error,
extract_nested_error, get_timestamp_asserter_contract_artifacts, increase_time,
};
#[tokio::test]
async fn tx_resource_estimation_fails_on_forked_devnet_with_impersonation_unless_time_incremented()
{
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let (signer, address) = origin_devnet.get_first_predeployed_account().await;
let origin_account = SingleOwnerAccount::new(
&origin_devnet.json_rpc_client,
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_timestamp_asserter_contract_artifacts();
let lock_interval = 86_400;
let ctor_args = &[Felt::from(lock_interval)];
let (_, contract_address) =
declare_v3_deploy_v3(&origin_account, contract_class, casm_hash, ctor_args).await.unwrap();
// Spawn a forked Devnet; use random seed to force predeployment of new accounts
let fork_args = ["--fork-network", &origin_devnet.url, "--seed", "18726"];
let forked_devnet = BackgroundDevnet::spawn_with_additional_args(&fork_args).await.unwrap();
// Create a new, dummy account, which should work after activating impersonation
let fork_account = SingleOwnerAccount::new(
&forked_devnet.json_rpc_client,
LocalWallet::from(SigningKey::from_secret_scalar(Felt::TWO)),
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
forked_devnet
.execute_impersonation_action(&ImpersonationAction::AutoImpersonate)
.await
.unwrap();
let time_check_selector = get_selector_from_name("check_time").unwrap();
let time_check_call =
Call { to: contract_address, selector: time_check_selector, calldata: vec![] };
// A failure is expected without time change.
let error =
fork_account.execute_v3(vec![time_check_call.clone()]).estimate_fee().await.unwrap_err();
match error {
AccountError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(error_data),
)) => {
assert_eq!(error_data.transaction_index, 0);
let root_error = extract_nested_error(&error_data.execution_error).unwrap();
assert_eq!(root_error.contract_address, fork_account.address());
assert_eq!(root_error.selector, get_selector_from_name("__execute__").unwrap());
// Currently the root error is twice mentioned, so we extract twice
let inner_error = extract_nested_error(&root_error.error).unwrap();
let inner_error = extract_nested_error(&inner_error.error).unwrap();
assert_eq!(inner_error.contract_address, contract_address);
assert_eq!(inner_error.selector, time_check_selector);
let message = extract_message_error(&inner_error.error).unwrap();
assert_contains(message, "Wait a bit more").unwrap();
}
other => panic!("Invalid error: {other:?}"),
}
// Increasing the system timestamp should make the estimation succeed
increase_time(&forked_devnet, lock_interval).await;
fork_account.execute_v3(vec![time_check_call]).estimate_fee().await.unwrap();
}
#[tokio::test]
async fn tx_execution_fails_on_forked_devnet_with_impersonation_unless_time_incremented() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let (signer, address) = origin_devnet.get_first_predeployed_account().await;
let origin_account = SingleOwnerAccount::new(
&origin_devnet.json_rpc_client,
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_timestamp_asserter_contract_artifacts();
let lock_interval = 86_400;
let ctor_args = &[Felt::from(lock_interval)];
let (_, contract_address) =
declare_v3_deploy_v3(&origin_account, contract_class, casm_hash, ctor_args).await.unwrap();
// Spawn a forked Devnet; use random seed to force predeployment of new accounts
let fork_args = ["--fork-network", &origin_devnet.url, "--seed", "18726"];
let forked_devnet = BackgroundDevnet::spawn_with_additional_args(&fork_args).await.unwrap();
// Create a new, dummy account, which should work after activating impersonation
let fork_account = SingleOwnerAccount::new(
&forked_devnet.json_rpc_client,
LocalWallet::from(SigningKey::from_secret_scalar(Felt::TWO)),
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
forked_devnet
.execute_impersonation_action(&ImpersonationAction::AutoImpersonate)
.await
.unwrap();
let time_check_selector = get_selector_from_name("check_time").unwrap();
let time_check_call =
Call { to: contract_address, selector: time_check_selector, calldata: vec![] };
// A failure is expected without time change.
let reverted_tx = fork_account
.execute_v3(vec![time_check_call.clone()])
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e7 as u64)
.send()
.await
.unwrap();
match forked_devnet.json_rpc_client.get_transaction_status(reverted_tx.transaction_hash).await {
Ok(TransactionStatus::AcceptedOnL2(tx_details)) => {
assert_eq!(tx_details.status(), TransactionExecutionStatus::Reverted);
assert_contains(tx_details.revert_reason().unwrap(), "Wait a bit more").unwrap();
}
other => panic!("Unexpected tx: {other:?}"),
}
// Increasing the system timestamp should make the tx succeed (and the implicit fee estimation)
increase_time(&forked_devnet, lock_interval).await;
fork_account.execute_v3(vec![time_check_call]).send().await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_get_class_hash_at.rs | tests/integration/test_get_class_hash_at.rs | use starknet_core::constants::CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH;
use starknet_rs_core::types::{BlockId, BlockTag, Felt, StarknetError};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::PREDEPLOYED_ACCOUNT_ADDRESS;
#[tokio::test]
async fn get_class_hash_at_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let retrieved_hash = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), contract_address)
.await
.unwrap();
assert_eq!(retrieved_hash, Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH));
}
#[tokio::test]
async fn get_class_hash_at_for_undeployed_address() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let undeployed_address = Felt::from_hex_unchecked("0x1234");
let err = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), undeployed_address)
.await
.expect_err("Should have failed");
match err {
ProviderError::StarknetError(StarknetError::ContractNotFound) => (),
_ => panic!("Invalid error: {err:?}"),
}
}
#[tokio::test]
async fn get_class_hash_at_by_block_number() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let result =
devnet.json_rpc_client.get_class_hash_at(BlockId::Number(0), contract_address).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn get_class_hash_at_by_block_hash() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let err = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Hash(Felt::ONE), contract_address)
.await
.expect_err("Should have failed");
match err {
ProviderError::StarknetError(StarknetError::BlockNotFound) => (),
_ => panic!("Invalid error: {err:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_account_selection.rs | tests/integration/test_account_selection.rs | use std::sync::Arc;
use serde_json::json;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{BlockId, BlockTag, Call, Felt, FunctionCall};
use starknet_rs_core::utils::{get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::Provider;
use starknet_rs_signers::LocalWallet;
use crate::assert_eq_prop;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
ARGENT_ACCOUNT_CLASS_HASH, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH,
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH, INTEGRATION_SEPOLIA_HTTP_URL,
};
use crate::common::utils::{
FeeUnit, assert_contains, assert_tx_succeeded_accepted, deploy_argent_account,
deploy_oz_account, get_simple_contract_artifacts, new_contract_factory,
};
pub async fn get_predeployed_accounts(
devnet: &BackgroundDevnet,
params: serde_json::Value,
) -> serde_json::Value {
devnet.send_custom_rpc("devnet_getPredeployedAccounts", params).await.unwrap()
}
#[tokio::test]
async fn spawnable_with_cairo0() {
BackgroundDevnet::spawn_with_additional_args(&["--account-class", "cairo0"]).await.unwrap();
}
#[tokio::test]
async fn spawnable_with_cairo1() {
BackgroundDevnet::spawn_with_additional_args(&["--account-class", "cairo1"]).await.unwrap();
}
#[tokio::test]
async fn spawnable_with_custom_account_cairo_1() {
let cli_args = ["--account-class-custom", CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH];
BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
}
/// Common body for tests defined below
async fn correct_artifact_test_body(
devnet_args: &[&str],
expected_hash_hex: &str,
) -> Result<(), anyhow::Error> {
let devnet = BackgroundDevnet::spawn_with_additional_args(devnet_args).await?;
let (_, account_address) = devnet.get_first_predeployed_account().await;
let retrieved_class_hash = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), account_address)
.await?;
let expected_hash = Felt::from_hex_unchecked(expected_hash_hex);
assert_eq_prop!(retrieved_class_hash, expected_hash)?;
let config = devnet.get_config().await;
let config_class_hash_hex = config["account_contract_class_hash"]
.as_str()
.ok_or(anyhow::anyhow!("contract class hash not found"))?;
let config_class_hash = Felt::from_hex_unchecked(config_class_hash_hex);
assert_eq_prop!(config_class_hash, expected_hash)
}
#[tokio::test]
async fn correct_cairo1_artifact() {
let cli_args = ["--account-class", "cairo1"];
correct_artifact_test_body(&cli_args, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH).await.unwrap();
}
#[tokio::test]
async fn correct_custom_artifact() {
let cli_args = ["--account-class-custom", CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH];
correct_artifact_test_body(&cli_args, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH).await.unwrap();
}
#[tokio::test]
async fn can_deploy_new_cairo1_oz_account() {
let cli_args = ["--account-class", "cairo1"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let (account_deployment, signer) = deploy_oz_account(&devnet).await.unwrap();
assert_tx_succeeded_accepted(&account_deployment.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let account_address = account_deployment.contract_address;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
#[tokio::test]
async fn can_deploy_new_cairo1_oz_account_when_cairo0_selected() {
let cli_args = ["--account-class", "cairo0"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let (account_deployment, signer) = deploy_oz_account(&devnet).await.unwrap();
assert_tx_succeeded_accepted(&account_deployment.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let account_address = account_deployment.contract_address;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
#[tokio::test]
async fn can_deploy_new_custom_oz_account() {
let cli_args = ["--account-class-custom", CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH];
let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let (account_deployment, signer) = deploy_oz_account(&devnet).await.unwrap();
assert_tx_succeeded_accepted(&account_deployment.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let account_address = account_deployment.contract_address;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
#[tokio::test]
async fn argent_account_undeployable_by_default() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let account_hash = Felt::from_hex_unchecked(ARGENT_ACCOUNT_CLASS_HASH);
let error = deploy_argent_account(&devnet, account_hash).await.unwrap_err();
assert_contains(
&error.to_string(),
&format!("Class with hash {ARGENT_ACCOUNT_CLASS_HASH} is not declared"),
)
.unwrap();
}
#[tokio::test]
/// Relying on forking: the origin network is expected to have the account class declared.
async fn can_deploy_instance_of_argent_account_via_fork() {
let cli_args = ["--fork-network", INTEGRATION_SEPOLIA_HTTP_URL];
let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let account_hash = Felt::from_hex_unchecked(ARGENT_ACCOUNT_CLASS_HASH);
let (account_deployment, signer) = deploy_argent_account(&devnet, account_hash).await.unwrap();
assert_tx_succeeded_accepted(&account_deployment.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let account_address = account_deployment.contract_address;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
#[tokio::test]
async fn can_deploy_new_argent_account_from_predeclared_class() {
let devnet_args = ["--predeclare-argent"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let account_hash = Felt::from_hex_unchecked(ARGENT_ACCOUNT_CLASS_HASH);
let (account_deployment, signer) = deploy_argent_account(&devnet, account_hash).await.unwrap();
assert_tx_succeeded_accepted(&account_deployment.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
let account_address = account_deployment.contract_address;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
async fn can_declare_deploy_invoke_cairo1_using_account(
devnet: &BackgroundDevnet,
signer: &LocalWallet,
account_address: Felt,
) {
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::New,
));
let (contract_class, casm_hash) = get_simple_contract_artifacts();
// declare the contract
let declaration_result = account
.declare_v3(Arc::new(contract_class), casm_hash)
.gas_estimate_multiplier(1.0)
.gas_price_estimate_multiplier(1.0)
.send()
.await
.unwrap();
// deploy the contract
let contract_factory = new_contract_factory(declaration_result.class_hash, account.clone());
let initial_value = Felt::from(10_u32);
let ctor_args = vec![initial_value];
contract_factory.deploy_v3(ctor_args.clone(), Felt::ZERO, false).send().await.unwrap();
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
Felt::ZERO,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&ctor_args,
);
// invoke on forked devnet
let increment = Felt::from(5_u32);
let contract_invoke = vec![Call {
to: contract_address,
selector: get_selector_from_name("increase_balance").unwrap(),
calldata: vec![increment, Felt::ZERO],
}];
let invoke_result = account.execute_v3(contract_invoke.clone()).send().await.unwrap();
assert_tx_succeeded_accepted(&invoke_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn can_declare_deploy_invoke_using_predeployed_cairo1() {
let cli_args = ["--account-class", "cairo1"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
#[tokio::test]
async fn can_declare_deploy_invoke_using_predeployed_custom() {
let cli_args = ["--account-class-custom", CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH];
let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
}
async fn assert_supports_isrc6(
devnet: &BackgroundDevnet,
account_address: Felt,
) -> Result<(), anyhow::Error> {
// https://github.com/OpenZeppelin/cairo-contracts/blob/89a450a88628ec3b86273f261b2d8d1ca9b1522b/src/account/interface.cairo#L7
let interface_id_hex = "0x2ceccef7f994940b3962a6c67e0ba4fcd37df7d131417c604f91e03caecc1cd";
let interface_id = Felt::from_hex_unchecked(interface_id_hex);
let call = FunctionCall {
contract_address: account_address,
entry_point_selector: get_selector_from_name("supports_interface").unwrap(),
calldata: vec![interface_id],
};
let supports = devnet.json_rpc_client.call(call, BlockId::Tag(BlockTag::Latest)).await.unwrap();
assert_eq_prop!(supports, vec![Felt::ONE])
}
#[tokio::test]
async fn test_interface_support_of_predeployed_account() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (_, account_address) = devnet.get_first_predeployed_account().await;
assert_supports_isrc6(&devnet, account_address).await.unwrap();
}
#[tokio::test]
async fn test_interface_support_of_newly_deployed_account() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (account_deployment, _) = deploy_oz_account(&devnet).await.unwrap();
assert_supports_isrc6(&devnet, account_deployment.contract_address).await.unwrap();
}
#[tokio::test]
async fn test_get_predeployed_accounts_balances() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--accounts",
"10",
"--initial-balance",
"1",
])
.await
.unwrap();
let accounts = get_predeployed_accounts(&devnet, json!({})).await;
for account in accounts.as_array().unwrap() {
assert!(account["balance"].is_null());
}
let accounts_without_balance =
get_predeployed_accounts(&devnet, json!({"with_balance": false})).await;
for account in accounts_without_balance.as_array().unwrap() {
assert!(account["balance"].is_null());
}
let accounts_with_balance =
get_predeployed_accounts(&devnet, json!({"with_balance": true})).await;
assert_eq!(accounts_with_balance.as_array().unwrap().len(), 10);
for account in accounts_with_balance.as_array().unwrap() {
assert_eq!(
account["balance"],
json!(
{
"eth": { "amount": "1", "unit": "WEI" },
"strk": { "amount": "1", "unit": "FRI" },
}
)
);
}
// increase balances and check again
for account in accounts_with_balance.as_array().unwrap() {
let address = &Felt::from_hex_unchecked(account["address"].as_str().unwrap());
devnet.mint_unit(address, 1, FeeUnit::Wei).await;
devnet.mint_unit(address, 1, FeeUnit::Fri).await;
}
let accounts_with_balance =
get_predeployed_accounts(&devnet, json!({"with_balance": true})).await;
assert_eq!(accounts_with_balance.as_array().unwrap().len(), 10);
for account in accounts_with_balance.as_array().unwrap() {
assert_eq!(
account["balance"],
json!(
{
"eth": { "amount": "2", "unit": "WEI" },
"strk": { "amount": "2", "unit": "FRI" },
}
)
);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_restrictive_mode.rs | tests/integration/test_restrictive_mode.rs | use serde_json::json;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::errors::RpcError;
#[tokio::test]
async fn restrictive_mode_with_default_methods_doesnt_affect_other_functionality() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--restrictive-mode"])
.await
.expect("Could not start Devnet");
devnet.send_custom_rpc("devnet_getConfig", json!({})).await.unwrap();
}
#[tokio::test]
async fn restrictive_mode_with_default_methods() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--restrictive-mode"])
.await
.expect("Could not start Devnet");
let json_rpc_error = devnet
.send_custom_rpc("devnet_mint", json!({ "address": "0x1", "amount": 1 }))
.await
.unwrap_err();
assert_eq!(
json_rpc_error,
RpcError { code: -32604, message: "Method forbidden".into(), data: None }
);
}
#[tokio::test]
async fn restrictive_mode_with_custom_methods() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--restrictive-mode",
"devnet_load",
"devnet_mint",
])
.await
.expect("Could not start Devnet");
let json_rpc_error = devnet
.send_custom_rpc("devnet_mint", json!({ "address": "0x1", "amount": 1 }))
.await
.unwrap_err();
assert_eq!(
json_rpc_error,
RpcError { code: -32604, message: "Method forbidden".into(), data: None }
);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_old_state.rs | tests/integration/test_old_state.rs | use std::sync::Arc;
use starknet_core::constants::{
DEVNET_DEFAULT_L1_DATA_GAS_PRICE, DEVNET_DEFAULT_L1_GAS_PRICE, DEVNET_DEFAULT_L2_GAS_PRICE,
UDC_CONTRACT_CLASS_HASH,
};
use starknet_rs_accounts::{Account, ExecutionEncoder, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::chain_id::SEPOLIA;
use starknet_rs_core::types::{
BlockHashAndNumber, BlockId, BlockTag, BroadcastedInvokeTransactionV3, BroadcastedTransaction,
Call, ContractClass, DataAvailabilityMode, ExecuteInvocation, Felt, InvokeTransactionTrace,
ResourceBounds, ResourceBoundsMapping, SimulatedTransaction, SimulationFlag,
SimulationFlagForEstimateFee, StarknetError, TransactionExecutionErrorData, TransactionTrace,
};
use starknet_rs_core::utils::{get_selector_from_name, get_storage_var_address};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_1_VERSION_ASSERTER_SIERRA_PATH, CHAIN_ID, ETH_ERC20_CONTRACT_ADDRESS,
UDC_CONTRACT_ADDRESS,
};
use crate::common::utils::{
FeeUnit, assert_cairo1_classes_equal, extract_message_error, extract_nested_error,
get_events_contract_artifacts, get_flattened_sierra_contract_and_casm_hash,
};
#[tokio::test]
async fn get_storage_from_an_old_state() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
devnet.create_block().await.unwrap();
let BlockHashAndNumber { block_hash, .. } =
devnet.json_rpc_client.block_hash_and_number().await.unwrap();
let amount = Felt::from(1_000_000_000);
account
.execute_v3(vec![Call {
to: ETH_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
amount, // low part of uint256
Felt::ZERO, // high part of uint256
],
}])
.send()
.await
.unwrap();
let storage_address = get_storage_var_address("ERC20_balances", &[account_address]).unwrap();
let latest_balance = devnet
.json_rpc_client
.get_storage_at(
ETH_ERC20_CONTRACT_ADDRESS,
storage_address,
BlockId::Tag(starknet_rs_core::types::BlockTag::Latest),
)
.await
.unwrap();
let previous_balance = devnet
.json_rpc_client
.get_storage_at(ETH_ERC20_CONTRACT_ADDRESS, storage_address, BlockId::Hash(block_hash))
.await
.unwrap();
assert!(latest_balance + amount <= previous_balance); // due to fee
}
#[tokio::test]
async fn minting_in_multiple_steps_and_getting_balance_at_each_block() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.unwrap();
// create a block if there are no blocks before starting minting
devnet.create_block().await.unwrap();
let address = Felt::ONE;
let mint_amount = 1e18 as u128;
let unit = FeeUnit::Fri;
for _ in 0..3 {
let BlockHashAndNumber { block_hash, .. } =
devnet.json_rpc_client.block_hash_and_number().await.unwrap();
devnet.mint(address, mint_amount).await;
let block_id = BlockId::Hash(block_hash);
let balance_at_block = devnet.get_balance_at_block(&address, block_id).await.unwrap();
let latest_balance = devnet.get_balance_latest(&address, unit).await.unwrap();
assert_eq!(balance_at_block + Felt::from(mint_amount), latest_balance);
}
}
/// Fee estimation of invoke tx that reverts must fail; simulating the same tx must produce trace.
#[tokio::test]
async fn fee_estimation_and_simulation_of_deployment_at_old_block_should_not_yield_same_error() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.unwrap();
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
devnet.create_block().await.unwrap();
let BlockHashAndNumber { block_hash, .. } =
devnet.json_rpc_client.block_hash_and_number().await.unwrap();
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_VERSION_ASSERTER_SIERRA_PATH);
let class_hash = flattened_contract_artifact.class_hash();
// declare class
let declaration_result =
account.declare_v3(Arc::new(flattened_contract_artifact), casm_hash).send().await.unwrap();
assert_eq!(declaration_result.class_hash, class_hash);
let udc_selector = get_selector_from_name("deployContract").unwrap();
let salt = Felt::from(0x123);
let calls = vec![Call {
to: UDC_CONTRACT_ADDRESS,
selector: udc_selector,
calldata: vec![class_hash, salt, Felt::ZERO, Felt::ZERO],
}];
let create_query_call = |resource_bounds: ResourceBoundsMapping| -> BroadcastedTransaction {
BroadcastedTransaction::Invoke(BroadcastedInvokeTransactionV3 {
signature: vec![],
nonce: Felt::ZERO,
sender_address: account_address,
calldata: account.encode_calls(&calls),
is_query: true,
resource_bounds,
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
})
};
let block_id = BlockId::Hash(block_hash);
let estimate_fee_error = devnet
.json_rpc_client
.estimate_fee(
[create_query_call(ResourceBoundsMapping {
l1_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l1_data_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: 0 },
})],
[SimulationFlagForEstimateFee::SkipValidate],
block_id,
)
.await
.unwrap_err();
let SimulatedTransaction { transaction_trace, .. } = devnet
.json_rpc_client
.simulate_transaction(
block_id,
create_query_call(ResourceBoundsMapping {
l1_gas: ResourceBounds {
max_amount: 0,
max_price_per_unit: DEVNET_DEFAULT_L1_GAS_PRICE.into(),
},
l1_data_gas: ResourceBounds {
max_amount: 1000,
max_price_per_unit: DEVNET_DEFAULT_L1_DATA_GAS_PRICE.into(),
},
l2_gas: ResourceBounds {
max_amount: 1e7 as u64,
max_price_per_unit: DEVNET_DEFAULT_L2_GAS_PRICE.into(),
},
}),
[SimulationFlag::SkipValidate],
)
.await
.unwrap();
let expected_error_msg =
format!("Class with hash {} is not declared.", class_hash.to_fixed_hex_string());
// Expected error structure:
// __execute__ of account contract -> deployContract of UDC -> constructor at computed address
match estimate_fee_error {
ProviderError::StarknetError(StarknetError::TransactionExecutionError(
TransactionExecutionErrorData { execution_error, .. },
)) => {
let account_error = extract_nested_error(&execution_error).unwrap();
assert_eq!(account_error.selector, get_selector_from_name("__execute__").unwrap());
assert_eq!(account_error.contract_address, account.address());
let account_class_hash = devnet
.json_rpc_client
.get_class_hash_at(BlockId::Tag(BlockTag::Latest), account_error.contract_address)
.await
.unwrap();
assert_eq!(account_error.class_hash, account_class_hash);
let udc_error = extract_nested_error(&account_error.error).unwrap();
assert_eq!(udc_error.contract_address, UDC_CONTRACT_ADDRESS);
assert_eq!(udc_error.selector, udc_selector);
assert_eq!(udc_error.class_hash, UDC_CONTRACT_CLASS_HASH);
let error_at_to_be_deployed_address = extract_nested_error(&udc_error.error).unwrap();
assert_eq!(error_at_to_be_deployed_address.class_hash, class_hash);
assert_eq!(error_at_to_be_deployed_address.selector, Felt::ZERO);
let error_msg = extract_message_error(&error_at_to_be_deployed_address.error).unwrap();
assert_eq!(error_msg.trim(), &expected_error_msg)
}
other => panic!("Unexpected error: {other:?}"),
};
match transaction_trace {
TransactionTrace::Invoke(InvokeTransactionTrace {
execute_invocation: ExecuteInvocation::Reverted(reverted),
..
}) => assert!(reverted.revert_reason.trim().ends_with(&expected_error_msg)),
other => panic!("Unexpected trace {other:?}"),
}
}
#[tokio::test]
async fn test_getting_class_at_various_blocks() {
let devnet_args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
SEPOLIA,
ExecutionEncoding::New,
));
let (contract_class, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(contract_class.clone()), casm_class_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await
.unwrap();
let declaration_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
// create an extra block so the declaration block is no longer the latest
devnet.create_block().await.unwrap();
// getting class at the following block IDs should be successful
let expected_class = ContractClass::Sierra(contract_class);
for block_id in [
BlockId::Tag(BlockTag::Latest),
BlockId::Tag(BlockTag::PreConfirmed),
BlockId::Number(declaration_block.block_number),
BlockId::Number(declaration_block.block_number + 1),
BlockId::Hash(declaration_block.block_hash),
] {
let retrieved_class = devnet
.json_rpc_client
.get_class(block_id, declaration_result.class_hash)
.await
.unwrap();
assert_cairo1_classes_equal(&retrieved_class, &expected_class).unwrap();
}
// getting class at the following block IDs should NOT be successful
for block_id in [BlockId::Number(declaration_block.block_number - 1)] {
let retrieved =
devnet.json_rpc_client.get_class(block_id, declaration_result.class_hash).await;
match retrieved {
Err(ProviderError::StarknetError(StarknetError::ClassHashNotFound)) => (),
other => panic!("Unexpected response: {other:?}"),
}
}
}
#[tokio::test]
async fn test_nonce_retrieval_for_an_old_state() {
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
.await
.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
SEPOLIA,
ExecutionEncoding::New,
));
let BlockHashAndNumber { block_number, .. } =
devnet.json_rpc_client.block_hash_and_number().await.unwrap();
let initial_nonce = devnet
.json_rpc_client
.get_nonce(BlockId::Tag(BlockTag::Latest), account_address)
.await
.unwrap();
account
.execute_v3(vec![Call {
to: ETH_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
Felt::from(1000), // low part of uint256
Felt::ZERO, // high part of uint256
],
}])
.send()
.await
.unwrap();
let latest_nonce = devnet
.json_rpc_client
.get_nonce(BlockId::Tag(BlockTag::Latest), account_address)
.await
.unwrap();
assert!(latest_nonce > initial_nonce);
let nonce_at_old_state = devnet
.json_rpc_client
.get_nonce(BlockId::Number(block_number), account_address)
.await
.unwrap();
assert_eq!(initial_nonce, nonce_at_old_state);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/general_rpc_tests.rs | tests/integration/general_rpc_tests.rs | use serde_json::json;
use starknet_rs_core::types::{ConfirmedBlockId, SyncStatusType};
use starknet_rs_providers::Provider;
use starknet_rs_providers::jsonrpc::JsonRpcError;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::RPC_PATH;
use crate::common::errors::RpcError;
use crate::common::reqwest_client::PostReqwestSender;
use crate::common::utils::{assert_json_rpc_errors_equal, extract_json_rpc_error};
#[tokio::test]
async fn rpc_at_root() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let resp_root: serde_json::Value =
devnet.reqwest_client().post_json_async("/", ()).await.unwrap();
let resp_rpc: serde_json::Value =
devnet.reqwest_client().post_json_async(RPC_PATH, ()).await.unwrap();
assert_eq!(resp_root, resp_rpc);
}
#[tokio::test]
async fn rpc_returns_correct_spec_version() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let resp_body = devnet.send_custom_rpc("starknet_specVersion", json!([])).await.unwrap();
match resp_body.as_str() {
Some(received_ver) => assert_eq!(received_ver, "0.10.0"),
_ => panic!("Invalid resp: {resp_body}"),
}
}
#[tokio::test]
async fn rpc_returns_method_not_found() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
for invalid_method in ["invalid_method", "starknet_specVersion_butWrong", "devnet_invalid"] {
let rpc_error = devnet.send_custom_rpc(invalid_method, json!({})).await.unwrap_err();
assert_eq!(
rpc_error,
RpcError { code: -32601, message: "Method not found".into(), data: None }
);
}
}
#[tokio::test]
async fn rpc_returns_invalid_params() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let rpc_error = devnet
.send_custom_rpc("starknet_specVersion", json!({ "invalid_param": "unneeded_value" }))
.await
.unwrap_err();
assert_eq!(rpc_error.code, -32602);
}
#[tokio::test]
async fn syncing_status_always_false() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
assert_eq!(devnet.json_rpc_client.syncing().await.unwrap(), SyncStatusType::NotSyncing);
}
#[tokio::test]
async fn storage_proof_request_should_always_return_error() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let devnet_storage_proof_msg = "Devnet doesn't support storage proofs";
for (req_params, expected_code, expected_msg) in [
(json!({}), -32602, "missing field `block_id`"),
(json!({ "block_id": ConfirmedBlockId::Number(0) }), 42, devnet_storage_proof_msg),
(json!({ "block_id": "latest" }), 42, devnet_storage_proof_msg),
(json!({ "block_id": ConfirmedBlockId::Number(5) }), 24, "Block not found"),
] {
let error =
devnet.send_custom_rpc("starknet_getStorageProof", req_params).await.unwrap_err();
assert_eq!(
error,
RpcError { code: expected_code.into(), message: expected_msg.into(), data: None }
);
}
// Test with starknet-rs
match devnet.json_rpc_client.get_storage_proof(ConfirmedBlockId::Latest, [], [], []).await {
// Replace when this is accepted: https://github.com/xJonathanLEI/starknet-rs/pull/714
// Err(ProviderError::StarknetError(StarknetError::StorageProofNotSupported)) => (),
Err(e) => assert_json_rpc_errors_equal(
extract_json_rpc_error(e).unwrap(),
JsonRpcError { code: 42, message: devnet_storage_proof_msg.into(), data: None },
)
.unwrap(),
other => panic!("Unexpected result: {other:?}"),
}
}
#[tokio::test]
async fn test_json_syntax_error_handling() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// Send a malformed JSON request
let resp = reqwest::Client::new()
.post(format!("{}/rpc", devnet.url))
.header("Content-Type", "application/json")
.body("{ this is not valid JSON }")
.send()
.await
.unwrap();
assert_eq!(resp.status(), reqwest::StatusCode::OK);
let error_resp: serde_json::Value = resp.json().await.unwrap();
assert_eq!(
error_resp,
json!({
"jsonrpc": "2.0",
"error": {
"code": -32700,
"message": "Parse error",
"data": {
"reason": "Failed to parse the request body as JSON: key must be a string at line 1 column 3"
}
},
"id": null
})
);
}
#[tokio::test]
async fn test_invalid_request_error_handling() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let resp = reqwest::Client::new()
.post(format!("{}/rpc", devnet.url))
.header("Content-Type", "application/json")
.json(&json!({
"jsonrpc": "2.0",
"params": [],
"id": 1
}))
.send()
.await
.unwrap();
assert_eq!(resp.status(), reqwest::StatusCode::OK);
let error_resp: serde_json::Value = resp.json().await.unwrap();
assert_eq!(
error_resp,
json!({
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -32600,
"message": "Invalid request"
}
})
);
}
#[tokio::test]
async fn test_missing_json_content_type() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// Send request without content-type header
let resp = reqwest::Client::new()
.post(format!("{}/rpc", devnet.url))
.body(r#"{"jsonrpc": "2.0", "method": "starknet_chainId", "params": [], "id": 1}"#)
.send()
.await
.unwrap();
assert_eq!(resp.status(), reqwest::StatusCode::OK);
let error_resp: serde_json::Value = resp.json().await.unwrap();
assert_eq!(
error_resp,
json!({
"jsonrpc": "2.0",
"error": {
"code": -32600,
"message": "Invalid request",
"data": {
"reason": "Missing content type"
}
},
"id": null
})
);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_account_impersonation.rs | tests/integration/test_account_impersonation.rs | use std::sync::Arc;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{BlockId, BlockTag, Call, ExecutionResult, Felt};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider};
use starknet_rs_signers::{LocalWallet, SigningKey};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::STRK_ERC20_CONTRACT_ADDRESS;
use crate::common::utils::{
FeeUnit, ImpersonationAction, assert_contains, get_simple_contract_artifacts,
};
use crate::{assert_eq_prop, assert_gte_prop};
const IMPERSONATED_ACCOUNT_PRIVATE_KEY: Felt = Felt::ONE;
// Felt::from(100000000000)
const AMOUNT_TO_TRANSFER: Felt = Felt::from_raw([
576406352303423504,
18446744073709551615,
18446744073709551615,
18446740873709551617,
]);
async fn get_account_for_impersonation_and_private_key(
devnet: &BackgroundDevnet,
) -> (Felt, LocalWallet) {
let (_, account_address) = devnet.get_first_predeployed_account().await;
(
account_address,
LocalWallet::from_signing_key(SigningKey::from_secret_scalar(
IMPERSONATED_ACCOUNT_PRIVATE_KEY,
)),
)
}
fn get_invoke_transaction_request(amount_to_transfer: Felt) -> Call {
Call {
to: STRK_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
amount_to_transfer, // low part of uint256
Felt::ZERO, // high part of uint256
],
}
}
async fn get_account_interacting_with_forked_devnet<'a>(
origin_devnet: &'a BackgroundDevnet,
forked_devnet: &'a BackgroundDevnet,
) -> SingleOwnerAccount<&'a JsonRpcClient<HttpTransport>, LocalWallet> {
let (account_address, private_key) =
get_account_for_impersonation_and_private_key(origin_devnet).await;
SingleOwnerAccount::new(
&forked_devnet.json_rpc_client,
private_key,
account_address,
origin_devnet.json_rpc_client.chain_id().await.unwrap(),
ExecutionEncoding::New,
)
}
#[tokio::test]
async fn test_account_impersonation_have_to_return_an_error_when_in_restrictive_mode() {
let origin_devnet =
BackgroundDevnet::spawn_forkable_devnet().await.expect("Could not start Devnet");
let args =
["--fork-network", origin_devnet.url.as_str(), "--accounts", "0", "--restrictive-mode"];
let forked_devnet = BackgroundDevnet::spawn_with_additional_args(&args).await.unwrap();
let impersonation_err = forked_devnet
.execute_impersonation_action(&ImpersonationAction::ImpersonateAccount(Felt::ONE))
.await
.unwrap_err();
assert_anyhow_error_contains_message(impersonation_err, "method forbidden");
let impersonation_err = forked_devnet
.execute_impersonation_action(&ImpersonationAction::AutoImpersonate)
.await
.unwrap_err();
assert_anyhow_error_contains_message(impersonation_err, "method forbidden");
}
#[tokio::test]
async fn test_impersonated_of_a_predeployed_account_account_can_send_transaction() {
let devnet = BackgroundDevnet::spawn_forkable_devnet().await.expect("Could not start Devnet");
let (_, account_address) = devnet.get_first_predeployed_account().await;
test_invoke_transaction(&devnet, &[ImpersonationAction::ImpersonateAccount(account_address)])
.await
.unwrap();
test_declare_transaction(&devnet, &[ImpersonationAction::ImpersonateAccount(account_address)])
.await
.unwrap();
}
#[tokio::test]
async fn non_impersonated_account_fails_to_make_a_transaction_and_receives_an_error_of_invalid_signature()
{
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let invoke_txn_err = test_invoke_transaction(&origin_devnet, &[]).await.unwrap_err();
assert_anyhow_error_contains_message(invoke_txn_err, "invalid signature");
let declare_txn_err = test_declare_transaction(&origin_devnet, &[]).await.unwrap_err();
assert_anyhow_error_contains_message(declare_txn_err, "invalid signature");
}
#[tokio::test]
async fn test_auto_impersonate_allows_user_to_send_transactions() {
let devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
test_invoke_transaction(&devnet, &[ImpersonationAction::AutoImpersonate]).await.unwrap();
test_declare_transaction(&devnet, &[ImpersonationAction::AutoImpersonate]).await.unwrap();
}
#[tokio::test]
async fn test_impersonate_account_and_then_stop_impersonate_have_to_return_an_error_of_invalid_signature()
{
let origin_devnet = &BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let (_, account_address) = origin_devnet.get_first_predeployed_account().await;
let invoke_txn_err = test_invoke_transaction(
origin_devnet,
&[
ImpersonationAction::ImpersonateAccount(account_address),
ImpersonationAction::StopImpersonateAccount(account_address),
],
)
.await
.unwrap_err();
assert_anyhow_error_contains_message(invoke_txn_err, "invalid signature");
let declare_txn_err = test_declare_transaction(
origin_devnet,
&[
ImpersonationAction::ImpersonateAccount(account_address),
ImpersonationAction::StopImpersonateAccount(account_address),
],
)
.await
.unwrap_err();
assert_anyhow_error_contains_message(declare_txn_err, "invalid signature");
}
#[tokio::test]
async fn test_auto_impersonate_then_stop_and_send_transaction_fails_with_invalid_signature_error() {
let origin_devnet = &BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let invoke_txn_err = test_invoke_transaction(
origin_devnet,
&[ImpersonationAction::AutoImpersonate, ImpersonationAction::StopAutoImpersonate],
)
.await
.unwrap_err();
assert_anyhow_error_contains_message(invoke_txn_err, "invalid signature");
let declare_txn_err = test_declare_transaction(
origin_devnet,
&[ImpersonationAction::AutoImpersonate, ImpersonationAction::StopAutoImpersonate],
)
.await
.unwrap_err();
assert_anyhow_error_contains_message(declare_txn_err, "invalid signature");
}
#[tokio::test]
async fn test_simulate_transaction() {
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
let forked_devnet = origin_devnet.fork().await.unwrap();
let account = get_account_interacting_with_forked_devnet(&origin_devnet, &forked_devnet).await;
let invoke_calls = vec![get_invoke_transaction_request(AMOUNT_TO_TRANSFER)];
// vector of tuples of steps (impersonation action, do validation, expected some error
// message - none if its successful)
let steps = vec![
(Some(ImpersonationAction::ImpersonateAccount(account.address())), true, None),
(Some(ImpersonationAction::ImpersonateAccount(account.address())), false, None),
(None, false, None),
(None, true, Some("invalid signature")),
(Some(ImpersonationAction::AutoImpersonate), true, None),
(Some(ImpersonationAction::AutoImpersonate), false, None),
];
for (impersonation_action_option, do_validate, expected_error_message) in steps {
if let Some(impersonation_action) = impersonation_action_option {
forked_devnet.execute_impersonation_action(&impersonation_action).await.unwrap();
}
let simulation_result =
account.execute_v3(invoke_calls.clone()).simulate(!do_validate, true).await;
if let Some(error_msg) = expected_error_message {
let simulation_err = simulation_result.expect_err("Expected simulation to fail");
assert_contains(&format!("{:?}", simulation_err).to_lowercase(), error_msg).unwrap();
} else {
simulation_result.expect("Expected simulation to succeed");
}
forked_devnet.restart().await;
}
}
async fn test_declare_transaction(
origin_devnet: &BackgroundDevnet,
impersonation_actions: &[ImpersonationAction],
) -> Result<(), anyhow::Error> {
let forked_devnet = origin_devnet.fork().await.unwrap();
let mut account =
get_account_interacting_with_forked_devnet(origin_devnet, &forked_devnet).await;
for action in impersonation_actions.iter() {
forked_devnet.execute_impersonation_action(action).await?;
}
let (flattened_class, compiled_class_hash) = get_simple_contract_artifacts();
account.set_block_id(BlockId::Tag(BlockTag::Latest));
account.declare_v3(Arc::new(flattened_class), compiled_class_hash).send().await?;
Ok(())
}
async fn test_invoke_transaction(
origin_devnet: &BackgroundDevnet,
impersonation_actions: &[ImpersonationAction],
) -> Result<(), anyhow::Error> {
let forked_devnet = origin_devnet.fork().await?;
let account = get_account_interacting_with_forked_devnet(origin_devnet, &forked_devnet).await;
for action in impersonation_actions.iter() {
forked_devnet.execute_impersonation_action(action).await?;
}
let forked_account_initial_balance = forked_devnet
.get_balance_by_tag(&account.address(), FeeUnit::Fri, BlockTag::Latest)
.await?;
let invoke_call = get_invoke_transaction_request(AMOUNT_TO_TRANSFER);
let result = account.execute_v3(vec![invoke_call]).send().await?;
let receipt = forked_devnet
.json_rpc_client
.get_transaction_receipt(result.transaction_hash)
.await?
.receipt;
assert_eq_prop!(receipt.execution_result(), &ExecutionResult::Succeeded)?;
let forked_account_balance = forked_devnet
.get_balance_by_tag(&account.address(), FeeUnit::Fri, BlockTag::Latest)
.await?;
assert_gte_prop!(forked_account_initial_balance, AMOUNT_TO_TRANSFER + forked_account_balance)
}
fn assert_anyhow_error_contains_message(error: anyhow::Error, message: &str) {
let error_string = format!("{:?}", error.root_cause()).to_lowercase();
assert_contains(&error_string, message).unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_to_new_tx_receipts.rs | tests/integration/test_subscription_to_new_tx_receipts.rs | use std::collections::HashMap;
use serde_json::json;
use starknet_core::constants::CHARGEABLE_ACCOUNT_ADDRESS;
use starknet_rs_accounts::{ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
DeclareTransactionReceipt, Felt, InvokeTransactionReceipt, Transaction,
TransactionFinalityStatus, TransactionReceipt, TransactionReceiptWithBlockInfo,
};
use tokio::net::TcpStream;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, connect_async};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
FeeUnit, SubscriptionId, assert_no_notifications, declare_deploy_simple_contract,
deploy_oz_account, receive_new_tx, receive_notification, receive_rpc_via_ws,
send_dummy_mint_tx, subscribe, subscribe_new_txs, unsubscribe,
};
async fn subscribe_new_tx_receipts(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
params: serde_json::Value,
) -> Result<SubscriptionId, anyhow::Error> {
subscribe(ws, "starknet_subscribeNewTransactionReceipts", params).await
}
async fn receive_new_tx_receipt(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
expected_subscription_id: SubscriptionId,
) -> Result<serde_json::Value, anyhow::Error> {
receive_notification(
ws,
"starknet_subscriptionNewTransactionReceipts",
expected_subscription_id,
)
.await
}
#[tokio::test]
async fn should_not_notify_in_block_on_demand_mode_if_default_subscription_params() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// No notifications because default finality_status is ACCEPTED_ON_L2
subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
send_dummy_mint_tx(&devnet).await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_pre_confirmed_txs_with_block_generation_on_demand() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let finality_status = TransactionFinalityStatus::PreConfirmed;
let subscription_params = json!({ "finality_status": [finality_status] });
let subscription_id = subscribe_new_tx_receipts(&mut ws, subscription_params).await.unwrap();
let tx_hash = send_dummy_mint_tx(&devnet).await;
let receipt_notification = receive_new_tx_receipt(&mut ws, subscription_id).await.unwrap();
let extracted_receipt: InvokeTransactionReceipt =
serde_json::from_value(receipt_notification).unwrap();
assert_eq!(extracted_receipt.transaction_hash, tx_hash);
assert_eq!(extracted_receipt.finality_status, finality_status);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_accepted_on_l2_with_block_generation_on_tx() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut explicit_ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut implicit_ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// One subscription is with explicit finality_status, the other with implicit/default
let finality_status = TransactionFinalityStatus::AcceptedOnL2;
let explicit_subscription_id = subscribe_new_tx_receipts(
&mut explicit_ws,
json!({ "finality_status": [finality_status] }),
)
.await
.unwrap();
let implicit_subscription_id =
subscribe_new_tx_receipts(&mut implicit_ws, json!({})).await.unwrap();
let tx_hash = send_dummy_mint_tx(&devnet).await;
for (mut ws, subscription_id) in
[(explicit_ws, explicit_subscription_id), (implicit_ws, implicit_subscription_id)]
{
let receipt_notification = receive_new_tx_receipt(&mut ws, subscription_id).await.unwrap();
let extracted_receipt: InvokeTransactionReceipt =
serde_json::from_value(receipt_notification).unwrap();
assert_eq!(extracted_receipt.transaction_hash, tx_hash);
assert_eq!(extracted_receipt.finality_status, finality_status);
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_notify_for_multiple_subscribers_with_default_params() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mut subscribers = HashMap::new();
for _ in 0..2 {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
subscribers.insert(subscription_id, ws);
}
let tx_hash = send_dummy_mint_tx(&devnet).await;
let finality_status = TransactionFinalityStatus::AcceptedOnL2;
for (subscription_id, mut ws) in subscribers {
let receipt_notification = receive_new_tx_receipt(&mut ws, subscription_id).await.unwrap();
let extracted_receipt: InvokeTransactionReceipt =
serde_json::from_value(receipt_notification).unwrap();
assert_eq!(extracted_receipt.transaction_hash, tx_hash);
assert_eq!(extracted_receipt.finality_status, finality_status);
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_stop_notifying_after_unsubscription() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mut subscribers = vec![];
for _ in 0..3 {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
subscribers.push((ws, subscription_id));
}
send_dummy_mint_tx(&devnet).await;
for (ws, subscription_id) in subscribers.iter_mut() {
receive_rpc_via_ws(ws).await.unwrap();
let unsubscription = unsubscribe(ws, subscription_id.clone()).await.unwrap();
assert_eq!(unsubscription, json!({ "jsonrpc": "2.0", "id": 0, "result": true }));
}
send_dummy_mint_tx(&devnet).await;
for (mut ws, _) in subscribers {
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_work_with_subscription_to_receipts_and_txs() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let receipt_subscription_id = subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
let tx_subscription_id = subscribe_new_txs(&mut ws, json!({})).await.unwrap();
for _ in 0..2 {
let tx_hash = send_dummy_mint_tx(&devnet).await;
let tx_raw = receive_new_tx(&mut ws, tx_subscription_id.clone()).await.unwrap();
let tx: Transaction = serde_json::from_value(tx_raw).unwrap();
assert_eq!(tx.transaction_hash(), &tx_hash);
let receipt_raw =
receive_new_tx_receipt(&mut ws, receipt_subscription_id.clone()).await.unwrap();
let receipt: TransactionReceipt = serde_json::from_value(receipt_raw).unwrap();
assert_eq!(receipt.transaction_hash(), &tx_hash);
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_for_filtered_address() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let subscription_id =
subscribe_new_tx_receipts(&mut ws, json!({ "sender_address": [account_address] }))
.await
.unwrap();
// Send the actual txs
declare_deploy_simple_contract(&predeployed_account).await.unwrap();
// Assert received declaration notification
let declaration_notification =
receive_new_tx_receipt(&mut ws, subscription_id.clone()).await.unwrap();
let declaration_receipt: DeclareTransactionReceipt =
serde_json::from_value(declaration_notification).unwrap();
assert_eq!(declaration_receipt.finality_status, TransactionFinalityStatus::AcceptedOnL2);
// Assert received deployment notification
let deployment_notification = receive_new_tx_receipt(&mut ws, subscription_id).await.unwrap();
let deployment_receipt: InvokeTransactionReceipt =
serde_json::from_value(deployment_notification).unwrap();
assert_eq!(deployment_receipt.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_filtered_address_not_matched() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// dummy address
subscribe_new_tx_receipts(&mut ws, json!({ "sender_address": ["0x1"] })).await.unwrap();
send_dummy_mint_tx(&devnet).await;
// nothing matched since minting is done via the Chargeable account
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_by_filtered_address_already_in_pre_confirmed_block() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
send_dummy_mint_tx(&devnet).await;
let finality_status = TransactionFinalityStatus::PreConfirmed;
for subscription_params in [
json!({ "finality_status": [finality_status] }),
// Minting is done by the Chargeable account
json!({ "finality_status": [finality_status], "sender_address": [CHARGEABLE_ACCOUNT_ADDRESS] }),
json!({ "finality_status": [finality_status], "sender_address": [] }),
] {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
subscribe_new_tx_receipts(&mut ws, subscription_params).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_not_notify_if_tx_by_filtered_address_in_latest_block_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
send_dummy_mint_tx(&devnet).await;
devnet.create_block().await.unwrap();
// Minting is done by the Chargeable account
let acceptable_address = CHARGEABLE_ACCOUNT_ADDRESS;
subscribe_new_tx_receipts(
&mut ws,
json!({ "finality_status": [TransactionFinalityStatus::PreConfirmed], "sender_address": [acceptable_address] }),
)
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_by_filtered_address_in_latest_block_in_on_tx_mode() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// Create tx and new block
send_dummy_mint_tx(&devnet).await;
// Minting is done by the Chargeable account
let acceptable_address = CHARGEABLE_ACCOUNT_ADDRESS;
subscribe_new_tx_receipts(
&mut ws,
json!({ "finality_status": [TransactionFinalityStatus::PreConfirmed], "sender_address": [acceptable_address] }),
)
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_already_in_latest_block_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
send_dummy_mint_tx(&devnet).await;
devnet.create_block().await.unwrap();
// Subscribe AFTER the tx and block creation.
let finality_status = TransactionFinalityStatus::PreConfirmed;
subscribe_new_tx_receipts(&mut ws, json!({ "finality_status": [finality_status] }))
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_already_in_latest_block_in_on_tx_mode() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
send_dummy_mint_tx(&devnet).await;
// Subscribe AFTER the tx and block creation.
for finality_status in
[TransactionFinalityStatus::PreConfirmed, TransactionFinalityStatus::AcceptedOnL2]
{
subscribe_new_tx_receipts(&mut ws, json!({ "finality_status": [finality_status] }))
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_not_notify_on_read_request_if_txs_in_pre_confirmed_block() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let finality_status = TransactionFinalityStatus::PreConfirmed;
subscribe_new_tx_receipts(&mut ws, json!({ "finality_status": [finality_status] }))
.await
.unwrap();
send_dummy_mint_tx(&devnet).await;
receive_rpc_via_ws(&mut ws).await.unwrap();
// Read request should have no impact
let dummy_address = Felt::ONE;
devnet.get_balance_latest(&dummy_address, FeeUnit::Wei).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_twice_if_subscribed_to_both_finality_statuses() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let finality_statuses =
[TransactionFinalityStatus::PreConfirmed, TransactionFinalityStatus::AcceptedOnL2];
let subscription_id =
subscribe_new_tx_receipts(&mut ws, json!({ "finality_status": finality_statuses }))
.await
.unwrap();
let tx_hash = send_dummy_mint_tx(&devnet).await;
for finality_status in finality_statuses {
let receipt_notification =
receive_new_tx_receipt(&mut ws, subscription_id.clone()).await.unwrap();
let extracted_receipt: InvokeTransactionReceipt =
serde_json::from_value(receipt_notification).unwrap();
assert_eq!(extracted_receipt.transaction_hash, tx_hash);
assert_eq!(extracted_receipt.finality_status, finality_status);
assert_no_notifications(&mut ws).await.unwrap();
devnet.create_block().await.unwrap(); // On first loop iteration, this changes tx status
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_deploy_account_receipt_notification() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
let (deployment_result, _) = deploy_oz_account(&devnet).await.unwrap();
let _minting_notification =
receive_new_tx_receipt(&mut ws, subscription_id.clone()).await.unwrap();
let deployment_notification = receive_new_tx_receipt(&mut ws, subscription_id).await.unwrap();
let deployment_receipt_with_block: TransactionReceiptWithBlockInfo =
serde_json::from_value(deployment_notification).unwrap();
assert_eq!(
deployment_receipt_with_block.receipt.transaction_hash(),
&deployment_result.transaction_hash
);
// Verify block info is present and valid
let block = &deployment_receipt_with_block.block;
assert!(block.block_number() > 0, "Block number should be positive");
let block_hash = block.block_hash().expect("Block hash should be present");
assert_ne!(block_hash, Felt::ZERO, "Block hash should not be zero");
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_declare_transaction_receipt_deserialization() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
// Get a predeployed account to use for declaration
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// Declare and deploy a contract (this will generate multiple transactions)
let (_declare_tx_hash, _) = declare_deploy_simple_contract(&predeployed_account).await.unwrap();
// Collect all receipt notifications (there should be at least one declare and one deploy)
let mut found_declare_receipt = false;
// Process all notifications that arrive (we expect multiple notifications)
for _ in 0..5 {
// Limit iterations to avoid infinite loop
match receive_new_tx_receipt(&mut ws, subscription_id.clone()).await {
Ok(notification) => {
let receipt_with_block: TransactionReceiptWithBlockInfo =
serde_json::from_value(notification).unwrap();
// If we find a declare transaction receipt, test it
if let TransactionReceipt::Declare(declare_receipt) = &receipt_with_block.receipt {
found_declare_receipt = true;
// Verify finality status
assert_eq!(
declare_receipt.finality_status,
TransactionFinalityStatus::AcceptedOnL2
);
// Verify fee structure
assert!(
declare_receipt.actual_fee.amount > Felt::ZERO,
"Fee amount should be positive"
);
// Check execution status and resources
assert_eq!(
declare_receipt.execution_result.status(),
starknet_rs_core::types::TransactionExecutionStatus::Succeeded
);
assert!(
declare_receipt.execution_resources.l2_gas > 0,
"L2 gas should be positive"
);
// Verify block info is present and valid
let block = &receipt_with_block.block;
assert!(block.block_number() > 0, "Block number should be positive");
let block_hash = block.block_hash().expect("Block hash should be present");
assert_ne!(block_hash, Felt::ZERO, "Block hash should not be zero");
}
}
Err(_) => break, // No more notifications
}
}
// Make sure we found and tested at least one declare receipt
assert!(found_declare_receipt, "Did not find any declare transaction receipt");
// Ensure we've consumed all notifications
while receive_new_tx_receipt(&mut ws, subscription_id.clone()).await.is_ok() {}
}
#[tokio::test]
async fn test_transaction_receipt_with_block_info_deserialization() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_tx_receipts(&mut ws, json!({})).await.unwrap();
// Send a transaction to get a receipt
let tx_hash = send_dummy_mint_tx(&devnet).await;
// Get the receipt notification
let receipt_notification = receive_new_tx_receipt(&mut ws, subscription_id).await.unwrap();
// Deserialize and verify the TransactionReceiptWithBlockInfo structure
let receipt_with_block: TransactionReceiptWithBlockInfo =
serde_json::from_value(receipt_notification).unwrap();
// Verify TransactionReceiptWithBlockInfo structure
// 1. Check receipt part
assert_eq!(receipt_with_block.receipt.transaction_hash(), &tx_hash);
assert_eq!(
receipt_with_block.receipt.finality_status(),
&TransactionFinalityStatus::AcceptedOnL2
);
// 2. Check block part
let block = &receipt_with_block.block;
assert!(block.block_number() > 0, "Block number should be positive");
let block_hash = block.block_hash().expect("Block hash should be present");
assert_ne!(block_hash, Felt::ZERO, "Block hash should not be zero");
// 3. Verify detailed receipt structure
match &receipt_with_block.receipt {
TransactionReceipt::Invoke(invoke_receipt) => {
// Verify transaction hash and finality status
assert_eq!(invoke_receipt.transaction_hash, tx_hash);
assert_eq!(invoke_receipt.finality_status, TransactionFinalityStatus::AcceptedOnL2);
// Verify fee structure
assert!(invoke_receipt.actual_fee.amount > Felt::ZERO, "Fee amount should be positive");
// Verify events
assert!(!invoke_receipt.events.is_empty(), "There should be at least one event");
// Check execution status and resources
assert_eq!(
invoke_receipt.execution_result.status(),
starknet_rs_core::types::TransactionExecutionStatus::Succeeded
);
assert!(invoke_receipt.execution_resources.l2_gas > 0, "L2 gas should be positive");
}
_ => panic!("Expected an invoke transaction receipt"),
}
// 4. Verify that block hash in receipt matches a real block in the chain
use starknet_rs_core::types::BlockId;
use starknet_rs_providers::Provider;
if let Some(block_hash) = block.block_hash() {
let block_status =
devnet.json_rpc_client.get_block_with_txs(BlockId::Hash(block_hash)).await;
assert!(block_status.is_ok(), "Block with hash {:?} should exist", block_hash);
}
// 5. Clean up test
assert_no_notifications(&mut ws).await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_to_events.rs | tests/integration/test_subscription_to_events.rs | use std::collections::HashSet;
use serde_json::json;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
BlockId, BlockTag, Call, Felt, InvokeTransactionResult, TransactionFinalityStatus,
};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::JsonRpcClient;
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_signers::LocalWallet;
use tokio::net::TcpStream;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, connect_async};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{self, STRK_ERC20_CONTRACT_ADDRESS, UDC_CONTRACT_ADDRESS};
use crate::common::utils::{
SubscriptionId, assert_no_notifications, declare_deploy_events_contract, receive_notification,
receive_rpc_via_ws, subscribe, unsubscribe,
};
fn get_tx_index_in_block(block_transactions: &[Felt], transaction_hash: Felt) -> usize {
block_transactions.iter().position(|tx_hash| *tx_hash == transaction_hash).unwrap_or_else(
|| panic!("Transaction {:?} not found in block transactions", transaction_hash),
)
}
async fn subscribe_events(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
params: serde_json::Value,
) -> Result<SubscriptionId, anyhow::Error> {
subscribe(ws, "starknet_subscribeEvents", params).await
}
async fn receive_event(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
subscription_id: SubscriptionId,
) -> Result<serde_json::Value, anyhow::Error> {
receive_notification(ws, "starknet_subscriptionEvents", subscription_id).await
}
async fn get_single_owner_account(
devnet: &BackgroundDevnet,
) -> SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet> {
let (signer, account_address) = devnet.get_first_predeployed_account().await;
SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
)
}
async fn emit_static_event(
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
contract_address: Felt,
) -> Result<InvokeTransactionResult, anyhow::Error> {
account
.execute_v3(vec![Call {
to: contract_address,
selector: get_selector_from_name("emit_event").unwrap(),
calldata: vec![Felt::ZERO], // what kind of event to emit
}])
.l1_gas(0)
.l1_data_gas(10000)
.l2_gas(5e7 as u64)
.send()
.await
.map_err(|e| anyhow::Error::msg(e.to_string()))
}
fn static_event_key() -> Felt {
get_selector_from_name("StaticEvent").unwrap()
}
#[tokio::test]
async fn event_subscription_with_no_params_until_unsubscription() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_events(&mut ws, json!({})).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
assert_ne!(contract_address, account.address());
// discard notifications emitted by system contracts - asserted in a separate test
receive_rpc_via_ws(&mut ws).await.unwrap(); // erc20 - fee charge
receive_rpc_via_ws(&mut ws).await.unwrap(); // udc - deployment
receive_rpc_via_ws(&mut ws).await.unwrap(); // erc20 - fee charge
let invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(&latest_block.transactions, invocation.transaction_hash);
let event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(
event,
json!({
"transaction_hash": invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0, // only event in the transaction
"block_hash": latest_block.block_hash,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
receive_rpc_via_ws(&mut ws).await.unwrap(); // erc20 - fee charge
assert_no_notifications(&mut ws).await.unwrap();
unsubscribe(&mut ws, subscription_id).await.unwrap();
emit_static_event(&account, contract_address).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_only_from_filtered_address() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let subscription_params = json!({ "from_address": contract_address });
let subscription_id = subscribe_events(&mut ws, subscription_params).await.unwrap();
let invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(&latest_block.transactions, invocation.transaction_hash);
let event = receive_event(&mut ws, subscription_id).await.unwrap();
assert_eq!(
event,
json!({
"transaction_hash": invocation.transaction_hash,
"block_hash": latest_block.block_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_new_events_only_from_filtered_key() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let subscription_params = json!({ "keys": [[static_event_key()]] });
let subscription_id = subscribe_events(&mut ws, subscription_params).await.unwrap();
let invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(&latest_block.transactions, invocation.transaction_hash);
let event = receive_event(&mut ws, subscription_id).await.unwrap();
assert_eq!(
event,
json!({
"transaction_hash": invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_hash": latest_block.block_hash,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_if_already_in_latest_block_in_on_tx_mode() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(&latest_block.transactions, invocation.transaction_hash);
let subscription_id =
subscribe_events(&mut ws, json!({ "from_address": contract_address })).await.unwrap();
let event = receive_event(&mut ws, subscription_id).await.unwrap();
assert_eq!(
event,
json!({
"transaction_hash": invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_hash": latest_block.block_hash,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_only_once_for_pre_confirmed_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws_before, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut ws_after, _) = connect_async(devnet.ws_url()).await.unwrap();
let mut account = get_single_owner_account(&devnet).await;
account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed)); // for correct nonce in deployment
// Define what's needed for requests and responses
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let finality_status = TransactionFinalityStatus::PreConfirmed;
let subscription_request =
json!({ "from_address": contract_address, "finality_status": finality_status });
let subscription_id_before =
subscribe_events(&mut ws_before, subscription_request.clone()).await.unwrap();
let invocation = emit_static_event(&account, contract_address).await.unwrap();
let subscription_id_after =
subscribe_events(&mut ws_after, subscription_request).await.unwrap();
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
let tx_index =
get_tx_index_in_block(&pre_confirmed_block.transactions, invocation.transaction_hash);
for (ws, subscription_id) in
[(&mut ws_before, subscription_id_before), (&mut ws_after, subscription_id_after)]
{
let event = receive_event(ws, subscription_id).await.unwrap();
assert_eq!(
event,
json!({
"transaction_hash": invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": finality_status,
})
);
}
// Should not re-notify on pre_confirmed->latest
devnet.create_block().await.unwrap();
assert_no_notifications(&mut ws_before).await.unwrap();
assert_no_notifications(&mut ws_after).await.unwrap();
}
#[tokio::test]
async fn should_notify_only_once_for_accepted_on_l2_in_on_demand_mode_with_explicit_tx_status() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let mut account = get_single_owner_account(&devnet).await;
account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed)); // for correct nonce in deployment
// Define what's needed for requests and responses
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
should_notify_only_once_for_accepted_on_l2_in_on_demand_mode(
&devnet,
&account,
contract_address,
json!({ "from_address": contract_address, "finality_status": TransactionFinalityStatus::AcceptedOnL2 }),
)
.await;
}
#[tokio::test]
async fn should_notify_only_once_for_accepted_on_l2_in_on_demand_mode_with_implicit_tx_status() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let mut account = get_single_owner_account(&devnet).await;
account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed)); // for correct nonce in deployment
// Define what's needed for requests and responses
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
should_notify_only_once_for_accepted_on_l2_in_on_demand_mode(
&devnet,
&account,
contract_address,
json!({ "from_address": contract_address }),
)
.await;
}
async fn should_notify_only_once_for_accepted_on_l2_in_on_demand_mode(
devnet: &BackgroundDevnet,
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
contract_address: Felt,
subscription_request: serde_json::Value,
) {
// Should work for subscriptions before and after the tx occurs.
// Should work for explicitly and implicitly defined finality status.
let (mut ws_before, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut ws_after, _) = connect_async(devnet.ws_url()).await.unwrap();
// Subscribe before tx
let subscription_id_before =
subscribe_events(&mut ws_before, subscription_request.clone()).await.unwrap();
let invocation = emit_static_event(account, contract_address).await.unwrap();
// Subscribe after tx
let subscription_id_after =
subscribe_events(&mut ws_after, subscription_request).await.unwrap();
// No notifications before block creation and conversion from pre-confirmed to accepted_on_l2
assert_no_notifications(&mut ws_before).await.unwrap();
assert_no_notifications(&mut ws_after).await.unwrap();
let created_block_hash = devnet.create_block().await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(&latest_block.transactions, invocation.transaction_hash);
for (ws, subscription_id) in
[(&mut ws_before, subscription_id_before), (&mut ws_after, subscription_id_after)]
{
let event = receive_event(ws, subscription_id).await.unwrap();
assert_eq!(
event,
json!({
"block_hash": created_block_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_number": 1, // the only created block
"transaction_hash": invocation.transaction_hash,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
}
// Should not re-notify on next block
devnet.create_block().await.unwrap();
assert_no_notifications(&mut ws_before).await.unwrap();
assert_no_notifications(&mut ws_after).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_events_in_old_blocks_with_no_filters() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = latest_block
.transactions
.iter()
.position(|tx_hash| *tx_hash == invocation.transaction_hash)
.unwrap();
// The declaration happens at block_number=1 so we query from there to latest
let subscription_params = json!({ "block_id": BlockId::Number(1) });
let subscription_id = subscribe_events(&mut ws, subscription_params).await.unwrap();
// declaration of events contract fee charge
let declaration_fee_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(declaration_fee_event["block_number"], 1);
assert_eq!(declaration_fee_event["from_address"], json!(STRK_ERC20_CONTRACT_ADDRESS));
// deployment of events contract: udc invocation
let deployment_udc_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(deployment_udc_event["block_number"], 2);
assert_eq!(deployment_udc_event["from_address"], json!(UDC_CONTRACT_ADDRESS));
// deployment of events contract: fee charge
let deployment_fee_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(deployment_fee_event["block_number"], 2);
assert_eq!(deployment_fee_event["from_address"], json!(STRK_ERC20_CONTRACT_ADDRESS),);
// invocation of events contract
let invocation_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(
invocation_event,
json!({
"transaction_hash": invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_hash": latest_block.block_hash,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
// invocation of events contract fee charge
let invocation_fee_event = receive_event(&mut ws, subscription_id).await.unwrap();
assert_eq!(invocation_fee_event["block_number"], latest_block.block_number);
assert_eq!(invocation_fee_event["from_address"], json!(STRK_ERC20_CONTRACT_ADDRESS));
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_old_and_new_events_with_address_filter() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let old_invocation = emit_static_event(&account, contract_address).await.unwrap();
let block_before_subscription = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(
&block_before_subscription.transactions,
old_invocation.transaction_hash,
);
// The declaration happens at block_number=1, but only invocation should be notified of
let subscription_params =
json!({ "block_id": BlockId::Number(1), "from_address": contract_address });
let subscription_id = subscribe_events(&mut ws, subscription_params).await.unwrap();
// assert presence of old event (event that was triggered before the subscription)
let old_invocation_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(
old_invocation_event,
json!({
"transaction_hash": old_invocation.transaction_hash,
"block_hash": block_before_subscription.block_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_number": block_before_subscription.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
// new event (after subscription)
let new_invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index =
get_tx_index_in_block(&latest_block.transactions, new_invocation.transaction_hash);
let new_invocation_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(
new_invocation_event,
json!({
"transaction_hash": new_invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_hash": latest_block.block_hash,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_old_and_new_events_with_key_filter() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let old_invocation = emit_static_event(&account, contract_address).await.unwrap();
let block_before_subscription = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index = get_tx_index_in_block(
&block_before_subscription.transactions,
old_invocation.transaction_hash,
);
// The declaration happens at block_number=1, but only invocation should be notified of
let subscription_params =
json!({ "block_id": BlockId::Number(1), "keys": [[static_event_key()]] });
let subscription_id = subscribe_events(&mut ws, subscription_params).await.unwrap();
// assert presence of old event (event that was triggered before the subscription)
let invocation_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(
invocation_event,
json!({
"transaction_hash": old_invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_hash": block_before_subscription.block_hash,
"block_number": block_before_subscription.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
// new event (after subscription)
let new_invocation = emit_static_event(&account, contract_address).await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let tx_index =
get_tx_index_in_block(&latest_block.transactions, new_invocation.transaction_hash);
let invocation_event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(
invocation_event,
json!({
"transaction_hash": new_invocation.transaction_hash,
"transaction_index": tx_index,
"event_index": 0,
"block_hash": latest_block.block_hash,
"block_number": latest_block.block_number,
"from_address": contract_address,
"keys": [static_event_key()],
"data": [],
"finality_status": TransactionFinalityStatus::AcceptedOnL2,
})
);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_of_events_in_too_old_blocks() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
emit_static_event(&account, contract_address).await.unwrap();
let last_block_hash = devnet.create_block().await.unwrap();
subscribe_events(&mut ws, json!({ "block_id": BlockId::Hash(last_block_hash) })).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_events_in_old_blocks() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let account = get_single_owner_account(&devnet).await;
let contract_address = declare_deploy_events_contract(&account).await.unwrap();
let block_number_before_emission =
devnet.get_latest_block_with_tx_hashes().await.unwrap().block_number;
let mut txs_with_invocation_events = HashSet::new();
let expected_events = 3;
for _ in 0..expected_events {
let invocation_event = emit_static_event(&account, contract_address).await.unwrap();
txs_with_invocation_events.insert(invocation_event.transaction_hash);
}
let subscription_id = subscribe_events(
&mut ws,
json!({ "block_id": BlockId::Number(0), "from_address": contract_address }),
)
.await
.unwrap();
let mut received_tx_hashes_from_events = HashSet::new();
for i in 0..expected_events {
let event_notification = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
let tx_hash =
Felt::from_hex_unchecked(event_notification["transaction_hash"].as_str().unwrap());
received_tx_hashes_from_events.insert(tx_hash);
assert_eq!(event_notification["block_number"], json!(block_number_before_emission + i + 1));
assert_eq!(event_notification["from_address"], json!(contract_address));
assert_eq!(event_notification["keys"], json!([static_event_key()]));
assert_eq!(event_notification["data"], json!([]));
}
assert_eq!(received_tx_hashes_from_events, txs_with_invocation_events);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_fork_subscription_to_events() {
// Setup original devnet
let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
// Deploy event contract on origin
let account = get_single_owner_account(&origin_devnet).await;
let event_contract_address = declare_deploy_events_contract(&account).await.unwrap();
// Emit static events on origin
let n_origin_events = 3;
let mut origin_tx_hashes = Vec::new();
for _ in 0..n_origin_events {
let invocation = emit_static_event(&account, event_contract_address).await.unwrap();
origin_tx_hashes.push(invocation.transaction_hash);
origin_devnet.create_block().await.unwrap();
}
// Fork the devnet
let fork_devnet = origin_devnet.fork().await.unwrap();
// Create some blocks on fork devnet before subscribing (to test empty block handling)
fork_devnet.create_block().await.unwrap();
// Subscribe to events on the forked devnet
let (mut ws, _) = connect_async(fork_devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_events(
&mut ws,
json!({
"block_id": BlockId::Number(0),
"from_address": event_contract_address.to_hex_string()
}),
)
.await
.unwrap();
// We should receive notifications for all events from origin
for hash in origin_tx_hashes.iter() {
let event = receive_event(&mut ws, subscription_id.clone()).await.unwrap();
// Verify event data
assert_eq!(event["from_address"], json!(event_contract_address));
assert_eq!(event["keys"][0], json!(static_event_key()));
assert_eq!(event["data"], json!([]));
assert_eq!(event["transaction_hash"], json!(hash));
}
// Emit additional events on the forked devnet
let (wallet, address) = origin_devnet.get_first_predeployed_account().await; // to avoid nonce clash
let original_account_on_fork = SingleOwnerAccount::new(
&fork_devnet.json_rpc_client,
wallet,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let n_fork_events = 2;
for _ in 0..n_fork_events {
let invocation =
emit_static_event(&original_account_on_fork, event_contract_address).await.unwrap();
// Verify we get notification for the new event
let event = receive_event(&mut ws, subscription_id.clone()).await;
let event = event.unwrap();
assert_eq!(event["from_address"], json!(event_contract_address));
assert_eq!(event["keys"][0], json!(static_event_key()));
assert_eq!(event["data"], json!([]));
assert_eq!(event["transaction_hash"], json!(invocation.transaction_hash));
}
assert_no_notifications(&mut ws).await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_call.rs | tests/integration/test_call.rs | use starknet_rs_accounts::SingleOwnerAccount;
use starknet_rs_core::types::{
BlockId, BlockTag, ContractErrorData, Felt, FunctionCall, StarknetError,
};
use starknet_rs_core::utils::{cairo_short_string_to_felt, get_selector_from_name};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH, ETH_ERC20_CONTRACT_ADDRESS, PREDEPLOYED_ACCOUNT_ADDRESS,
};
use crate::common::utils::{
assert_contains, declare_v3_deploy_v3, deploy_v3, extract_message_error, extract_nested_error,
get_flattened_sierra_contract_and_casm_hash,
};
#[tokio::test]
/// This test doesn't rely on devnet.get_balance because it's not supposed to call ERC20
async fn calling_method_of_undeployed_contract() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let entry_point_selector = get_selector_from_name("balanceOf").unwrap();
let undeployed_address = Felt::from_hex_unchecked("0x1234");
let err = devnet
.json_rpc_client
.call(
FunctionCall {
contract_address: undeployed_address,
entry_point_selector,
calldata: vec![contract_address],
},
BlockId::Tag(BlockTag::Latest),
)
.await
.expect_err("Should have failed");
match err {
ProviderError::StarknetError(StarknetError::ContractNotFound) => (),
_ => panic!("Invalid error: {err:?}"),
}
}
#[tokio::test]
async fn calling_nonexistent_cairo0_contract_method() {
let devnet_args = ["--account-class", "cairo0"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let entry_point_selector =
starknet_rs_core::utils::get_selector_from_name("nonExistentMethod").unwrap();
let err = devnet
.json_rpc_client
.call(
FunctionCall {
contract_address,
entry_point_selector,
calldata: vec![contract_address],
},
BlockId::Tag(BlockTag::Latest),
)
.await
.expect_err("Should have failed");
match err {
ProviderError::StarknetError(StarknetError::EntrypointNotFound) => {}
_ => {
panic!("Invalid error received {:?}", err);
}
}
}
#[tokio::test]
async fn calling_nonexistent_cairo1_contract_method() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
let entry_point_selector = get_selector_from_name("nonExistentMethod").unwrap();
let called_contract_address = ETH_ERC20_CONTRACT_ADDRESS;
let err = devnet
.json_rpc_client
.call(
FunctionCall {
contract_address: called_contract_address,
entry_point_selector,
calldata: vec![contract_address],
},
BlockId::Tag(BlockTag::Latest),
)
.await
.expect_err("Should have failed");
match err {
ProviderError::StarknetError(StarknetError::EntrypointNotFound) => {}
_ => {
panic!("Invalid error received {:?}", err);
}
}
}
#[tokio::test]
async fn call_panicking_method() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
devnet.json_rpc_client.chain_id().await.unwrap(),
starknet_rs_accounts::ExecutionEncoding::New,
);
let (contract_class, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let (class_hash, contract_address) =
declare_v3_deploy_v3(&account, contract_class, casm_hash, &[]).await.unwrap();
let other_contract_address = deploy_v3(&account, class_hash, &[]).await.unwrap();
let top_selector = get_selector_from_name("create_panic_in_another_contract").unwrap();
let panic_message = cairo_short_string_to_felt("funny_text").unwrap();
let err = devnet
.json_rpc_client
.call(
FunctionCall {
contract_address,
entry_point_selector: top_selector,
calldata: vec![other_contract_address, panic_message],
},
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap_err();
match err {
ProviderError::StarknetError(StarknetError::ContractError(ContractErrorData {
revert_error,
})) => {
let root = extract_nested_error(&revert_error).unwrap();
assert_eq!(root.contract_address, contract_address);
assert_eq!(root.class_hash, class_hash);
assert_eq!(root.selector, top_selector);
let inner = extract_nested_error(&root.error).unwrap();
assert_eq!(inner.contract_address, other_contract_address);
assert_eq!(inner.selector, get_selector_from_name("create_panic").unwrap());
assert_eq!(inner.class_hash, class_hash);
let error_msg = extract_message_error(&inner.error).unwrap();
assert_contains(error_msg, &panic_message.to_hex_string()).unwrap();
}
_ => panic!("Invalid error received {err:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/general_integration_tests.rs | tests/integration/general_integration_tests.rs | use serde_json::json;
use starknet_rs_core::types::{BlockId, BlockTag, Felt, FunctionCall};
use starknet_rs_core::utils::{
get_selector_from_name, get_storage_var_address, parse_cairo_short_string,
};
use starknet_rs_providers::Provider;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, ETH_ERC20_CONTRACT_ADDRESS,
ETH_ERC20_CONTRACT_CLASS_HASH, STRK_ERC20_CONTRACT_ADDRESS, STRK_ERC20_CONTRACT_CLASS_HASH,
};
use crate::common::utils::{UniqueAutoDeletableFile, to_hex_felt};
#[tokio::test]
/// Asserts that a background instance can be spawned
async fn background_devnet_can_be_spawned() {
BackgroundDevnet::spawn().await.expect("Could not start Devnet");
}
#[tokio::test]
async fn background_devnets_at_different_ports_with_random_acquisition() {
let devnet_args = ["--port", "0"];
let devnet1 = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let devnet2 = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
assert_ne!(devnet1.url, devnet2.url);
}
#[tokio::test]
async fn test_config() {
// random values
let dump_file = UniqueAutoDeletableFile::new("dummy");
let expected_config = json!({
"seed": 1,
"total_accounts": 2,
"account_contract_class_hash": Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH),
"predeployed_accounts_initial_balance": "3",
"start_time": 4,
"gas_price_wei": 5,
"gas_price_fri": 7,
"data_gas_price_wei": 6,
"data_gas_price_fri": 8,
"l2_gas_price_wei": 9,
"l2_gas_price_fri": 10,
"chain_id": "SN_MAIN",
"dump_on": "exit",
"dump_path": dump_file.path,
"state_archive": "full",
"fork_config": {
"url": null,
"block_number": null,
},
"server_config": {
"host": "0.0.0.0",
"port": 0, // default value in tests, config not modified upon finding a free port
"timeout": 121,
"restricted_methods": null,
},
"block_generation_on": "demand",
"lite_mode": false,
"eth_erc20_class_hash": to_hex_felt(Ð_ERC20_CONTRACT_CLASS_HASH),
"strk_erc20_class_hash": to_hex_felt(&STRK_ERC20_CONTRACT_CLASS_HASH),
"class_size_config": {
"maximum_contract_class_size": 1_000_000,
"maximum_contract_bytecode_size": 200_000,
"maximum_sierra_length": 300_000,
}
});
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--seed",
&expected_config["seed"].to_string(),
"--accounts",
&expected_config["total_accounts"].to_string(),
"--initial-balance",
expected_config["predeployed_accounts_initial_balance"].as_str().unwrap(),
"--start-time",
&expected_config["start_time"].to_string(),
"--gas-price",
&expected_config["gas_price_wei"].to_string(),
"--gas-price-fri",
&expected_config["gas_price_fri"].to_string(),
"--data-gas-price",
&expected_config["data_gas_price_wei"].to_string(),
"--data-gas-price-fri",
&expected_config["data_gas_price_fri"].to_string(),
"--l2-gas-price",
&expected_config["l2_gas_price_wei"].to_string(),
"--l2-gas-price-fri",
&expected_config["l2_gas_price_fri"].to_string(),
"--chain-id",
"MAINNET",
"--dump-on",
expected_config["dump_on"].as_str().unwrap(),
"--dump-path",
expected_config["dump_path"].as_str().unwrap(),
"--block-generation-on",
"demand",
"--state-archive-capacity",
expected_config["state_archive"].as_str().unwrap(),
"--host",
expected_config["server_config"]["host"].as_str().unwrap(),
"--timeout",
&expected_config["server_config"]["timeout"].to_string(),
"--maximum-contract-class-size",
&expected_config["class_size_config"]["maximum_contract_class_size"].to_string(),
"--maximum-contract-bytecode-size",
&expected_config["class_size_config"]["maximum_contract_bytecode_size"].to_string(),
"--maximum-sierra-length",
&expected_config["class_size_config"]["maximum_sierra_length"].to_string(),
])
.await
.unwrap();
let fetched_config = devnet.get_config().await;
assert_eq!(fetched_config, expected_config);
}
#[tokio::test]
async fn predeployed_erc20_tokens_have_expected_storage() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
for (token_address, var_name, expected_value) in [
(ETH_ERC20_CONTRACT_ADDRESS, "ERC20_name", "Ether"),
(ETH_ERC20_CONTRACT_ADDRESS, "ERC20_symbol", "ETH"),
(STRK_ERC20_CONTRACT_ADDRESS, "ERC20_name", "StarkNet Token"),
(STRK_ERC20_CONTRACT_ADDRESS, "ERC20_symbol", "STRK"),
] {
let actual_value = devnet
.json_rpc_client
.get_storage_at(
token_address,
get_storage_var_address(var_name, &[]).unwrap(),
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap();
assert_eq!(parse_cairo_short_string(&actual_value).unwrap().as_str(), expected_value);
}
}
#[tokio::test]
async fn predeployed_erc20_tokens_return_expected_values_from_property_getters() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
for (token_address, getter_name, expected_value) in [
(ETH_ERC20_CONTRACT_ADDRESS, "name", "Ether"),
(ETH_ERC20_CONTRACT_ADDRESS, "symbol", "ETH"),
(STRK_ERC20_CONTRACT_ADDRESS, "name", "StarkNet Token"),
(STRK_ERC20_CONTRACT_ADDRESS, "symbol", "STRK"),
] {
let actual_felts = devnet
.json_rpc_client
.call(
FunctionCall {
contract_address: token_address,
entry_point_selector: get_selector_from_name(getter_name).unwrap(),
calldata: vec![],
},
BlockId::Tag(BlockTag::Latest),
)
.await
.unwrap();
assert_eq!(actual_felts.len(), 1);
assert_eq!(parse_cairo_short_string(&actual_felts[0]).unwrap(), expected_value);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_transaction_handling.rs | tests/integration/test_transaction_handling.rs | use std::sync::Arc;
use starknet_rs_accounts::{Account, AccountError, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
Call, Felt, InvokeTransactionResult, StarknetError, TransactionExecutionErrorData,
};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::ProviderError;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH, CHAIN_ID, INVALID_ACCOUNT_SIERRA_PATH,
};
use crate::common::utils::{
assert_contains, declare_v3_deploy_v3, get_flattened_sierra_contract_and_casm_hash,
get_simple_contract_artifacts,
};
#[tokio::test]
async fn test_failed_validation_with_expected_message() {
let args = ["--account-class-custom", INVALID_ACCOUNT_SIERRA_PATH];
let devnet = BackgroundDevnet::spawn_with_additional_args(&args).await.unwrap();
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::Legacy,
));
// get class
let (contract_artifact, casm_hash) = get_simple_contract_artifacts();
let contract_artifact = Arc::new(contract_artifact);
// declare class
let declaration_result = account
.declare_v3(contract_artifact, casm_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await;
match declaration_result {
Err(AccountError::Provider(ProviderError::StarknetError(
StarknetError::ValidationFailure(message),
))) => assert_contains(&message, "FAILED VALIDATE DECLARE").unwrap(),
other => panic!("Unexpected result: {other:?}"),
}
}
#[tokio::test]
async fn test_declaration_rejected_if_casm_hash_not_matching() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
));
let (contract_class, _) = get_simple_contract_artifacts();
let dummy_casm_hash = Felt::ONE;
let declaration_result = account
.declare_v3(Arc::new(contract_class), dummy_casm_hash)
.nonce(Felt::ZERO)
.send()
.await;
match declaration_result {
Err(AccountError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(TransactionExecutionErrorData {
transaction_index: 0,
execution_error,
}),
))) => {
assert!(
format!("{execution_error:?}").contains("Mismatch compiled class hash"),
"Unexpected error: {execution_error:?}"
);
}
other => panic!("Unexpected response: {other:?}"),
}
}
#[tokio::test]
async fn test_tx_status_content_of_failed_invoke() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
CHAIN_ID,
ExecutionEncoding::New,
);
let (sierra, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH);
let (_, contract_address) =
declare_v3_deploy_v3(&account, sierra, casm_hash, &[]).await.unwrap();
let InvokeTransactionResult { transaction_hash } = account
.execute_v3(vec![Call {
to: contract_address,
selector: get_selector_from_name("create_panic").unwrap(),
calldata: vec![],
}])
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(5e7 as u64)
.send()
.await
.unwrap();
// Sending a custom request because starknet-rs was not adapted at the time of writing.
let tx_status = devnet
.send_custom_rpc(
"starknet_getTransactionStatus",
serde_json::json!({ "transaction_hash": transaction_hash }),
)
.await
.unwrap();
assert_eq!(tx_status["finality_status"], "ACCEPTED_ON_L2");
assert_contains(tx_status["failure_reason"].as_str().unwrap(), "Error in the called contract")
.unwrap();
assert_eq!(tx_status["execution_status"], "REVERTED");
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_advancing_time.rs | tests/integration/test_advancing_time.rs | use std::sync::Arc;
use std::time;
use serde_json::json;
use starknet_rs_accounts::{Account, AccountError, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
BlockId, BlockTag, Call, Felt, FunctionCall, StarknetError, TransactionExecutionStatus,
TransactionStatus,
};
use starknet_rs_core::utils::{get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
UniqueAutoDeletableFile, assert_contains, declare_v3_deploy_v3, extract_message_error,
extract_nested_error, get_block_reader_contract_artifacts,
get_timestamp_asserter_contract_artifacts, get_unix_timestamp_as_seconds, increase_time,
new_contract_factory, send_ctrl_c_signal_and_wait, set_time,
};
use crate::{assert_gte_prop, assert_lte_prop};
const DUMMY_ADDRESS: u128 = 1;
const DUMMY_AMOUNT: u128 = 1;
// buffer should be always lower than the time change that we are testing
const BUFFER_TIME_SECONDS: u64 = 30;
async fn sleep_until_new_timestamp() {
// Sometimes sleeping for 1 second isn't enough.
tokio::time::sleep(time::Duration::from_millis(1500)).await
}
pub fn assert_ge_with_buffer(val1: u64, val2: u64) -> Result<(), anyhow::Error> {
assert_gte_prop!(val1, val2)?;
let upper_limit = val2 + BUFFER_TIME_SECONDS;
assert_lte_prop!(val1, upper_limit)
}
pub fn assert_gt_with_buffer(val1: u64, val2: u64) -> Result<(), anyhow::Error> {
assert_gte_prop!(val1, val2)?;
let upper_limit = val2 + BUFFER_TIME_SECONDS;
assert_lte_prop!(val1, upper_limit)
}
fn assert_eq_with_buffer(val1: u64, val2: u64) {
assert!(
val1.abs_diff(val2) < BUFFER_TIME_SECONDS,
"Failed equality assertion with buffer: {val1} != {val2}"
);
}
pub async fn setup_timestamp_contract(devnet: &BackgroundDevnet) -> Felt {
let (signer, address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// declare
let (cairo_1_contract, casm_class_hash) = get_block_reader_contract_artifacts();
let declaration_result = predeployed_account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.send()
.await
.unwrap();
let predeployed_account = Arc::new(predeployed_account);
// deploy
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
contract_factory.deploy_v3(vec![], Felt::ZERO, false).send().await.unwrap();
get_udc_deployed_address(
Felt::ZERO,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&[],
)
}
pub async fn get_current_timestamp(
devnet: &BackgroundDevnet,
timestamp_contract_address: Felt,
) -> u64 {
let call_current_timestamp = FunctionCall {
contract_address: timestamp_contract_address,
entry_point_selector: get_selector_from_name("get_timestamp").unwrap(),
calldata: vec![],
};
let call_result = devnet
.json_rpc_client
.call(call_current_timestamp, BlockId::Tag(BlockTag::Latest))
.await
.unwrap();
assert_eq!(call_result.len(), 1);
call_result[0].to_string().parse::<u64>().unwrap()
}
#[tokio::test]
async fn timestamp_syscall_set_in_past() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let timestamp_contract_address = setup_timestamp_contract(&devnet).await;
// set time in past
let past_time = 1;
let block_timestamp = set_time(&devnet, past_time).await;
assert_eq!(block_timestamp, past_time);
devnet.create_block().await.unwrap();
// check if timestamp is greater/equal
let current_timestamp = get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_ge_with_buffer(current_timestamp, past_time).unwrap();
}
#[tokio::test]
async fn timestamp_syscall_set_in_future() {
let now = get_unix_timestamp_as_seconds();
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let timestamp_contract_address = setup_timestamp_contract(&devnet).await;
// set time in future
let future_time = now + 1000;
let block_timestamp = set_time(&devnet, future_time).await;
assert_eq!(block_timestamp, future_time);
devnet.create_block().await.unwrap();
// check if timestamp is greater/equal
let current_timestamp = get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_ge_with_buffer(current_timestamp, future_time).unwrap();
}
#[tokio::test]
async fn timestamp_syscall_increase_time() {
let now = get_unix_timestamp_as_seconds();
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let timestamp_contract_address = setup_timestamp_contract(&devnet).await;
// increase time
let time_increment: u64 = 1000;
increase_time(&devnet, time_increment).await;
// check if timestamp is greater/equal
let current_timestamp = get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_ge_with_buffer(current_timestamp, now + time_increment).unwrap();
sleep_until_new_timestamp().await;
devnet.create_block().await.unwrap();
// check if timestamp is greater
let timestamp_after_new_block =
get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_gt_with_buffer(timestamp_after_new_block, now + time_increment).unwrap();
assert_gt_with_buffer(timestamp_after_new_block, current_timestamp).unwrap();
}
#[tokio::test]
async fn timestamp_syscall_contract_constructor() {
let now = get_unix_timestamp_as_seconds();
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let timestamp_contract_address = setup_timestamp_contract(&devnet).await;
sleep_until_new_timestamp().await;
// check constructor set of timestamp
let call_storage_timestamp = FunctionCall {
contract_address: timestamp_contract_address,
entry_point_selector: get_selector_from_name("get_storage_timestamp").unwrap(),
calldata: vec![],
};
let storage_timestamp = devnet
.json_rpc_client
.call(call_storage_timestamp, BlockId::Tag(BlockTag::Latest))
.await
.unwrap()[0]
.to_string()
.parse::<u64>()
.unwrap();
assert_gt_with_buffer(storage_timestamp, now).unwrap();
sleep_until_new_timestamp().await;
devnet.create_block().await.unwrap();
// check if current timestamp > storage timestamp and now
let current_timestamp = get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_gt_with_buffer(current_timestamp, now).unwrap();
assert_gt_with_buffer(current_timestamp, storage_timestamp).unwrap();
}
#[tokio::test]
async fn start_time_in_past_syscall() {
let past_time = 1;
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--start-time",
past_time.to_string().as_str(),
])
.await
.expect("Could not start Devnet");
let timestamp_contract_address = setup_timestamp_contract(&devnet).await;
devnet.create_block().await.unwrap();
// check if timestamp is greater/equal
let current_timestamp = get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_ge_with_buffer(current_timestamp, past_time).unwrap();
}
#[tokio::test]
async fn start_time_in_future_syscall() {
let now: u64 = get_unix_timestamp_as_seconds();
let future_time = now + 1000;
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--start-time",
future_time.to_string().as_str(),
])
.await
.expect("Could not start Devnet");
let timestamp_contract_address = setup_timestamp_contract(&devnet).await;
devnet.create_block().await.unwrap();
// check if timestamp is greater/equal
let current_timestamp = get_current_timestamp(&devnet, timestamp_contract_address).await;
assert_ge_with_buffer(current_timestamp, future_time).unwrap();
}
async fn set_time_in_past(devnet: &BackgroundDevnet) {
// set time and assert if >= past_time, check if inside buffer limit
let past_time = 1;
let block_timestamp = set_time(devnet, past_time).await;
assert_eq!(block_timestamp, past_time);
let set_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(set_time_block.timestamp, past_time).unwrap();
sleep_until_new_timestamp().await;
// create block and check if block_timestamp > past_time, check if inside buffer limit
devnet.create_block().await.unwrap();
let empty_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(empty_block.timestamp, past_time).unwrap();
sleep_until_new_timestamp().await;
// check if after create block timestamp > last block, check if inside buffer limit
devnet.create_block().await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(latest_block.timestamp, empty_block.timestamp).unwrap();
}
#[tokio::test]
async fn set_time_in_past_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
set_time_in_past(&devnet).await;
}
#[tokio::test]
async fn set_time_in_past_block_generation_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.expect("Could not start Devnet");
set_time_in_past(&devnet).await;
}
async fn set_time_in_future(devnet: &BackgroundDevnet) {
// set time and assert if >= future_time, check if inside buffer limit
let now = get_unix_timestamp_as_seconds();
let future_time = now + 1000;
let block_timestamp = set_time(devnet, future_time).await;
assert_eq!(block_timestamp, future_time);
let set_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(set_time_block.timestamp, future_time).unwrap();
sleep_until_new_timestamp().await;
// create block and check if block_timestamp > future_time, check if inside buffer limit
devnet.create_block().await.unwrap();
let empty_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(empty_block.timestamp, future_time).unwrap();
sleep_until_new_timestamp().await;
// check if after create block timestamp > last empty block, check if inside buffer limit
devnet.create_block().await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(latest_block.timestamp, future_time).unwrap();
}
#[tokio::test]
async fn set_time_in_future_normal_mode() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
set_time_in_future(&devnet).await;
}
#[tokio::test]
async fn set_time_in_future_block_generation_on_demand() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.expect("Could not start Devnet");
set_time_in_future(&devnet).await;
}
#[tokio::test]
async fn set_time_with_pre_confirmed_txs() {
let start_time = get_unix_timestamp_as_seconds();
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--block-generation-on", "demand"])
.await
.unwrap();
let mut sent_mint_txs = vec![];
for _ in 0..2 {
// dummy data
let mint_tx = devnet.mint(Felt::ONE, 1_u128).await;
sent_mint_txs.push(mint_tx);
}
sent_mint_txs.sort(); // sorting to allow equality assertion
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
let mut pre_confirmed_txs = pre_confirmed_block.transactions.clone();
pre_confirmed_txs.sort();
assert_eq!(pre_confirmed_txs, sent_mint_txs);
assert_eq_with_buffer(pre_confirmed_block.timestamp, start_time);
let future_time = set_time(&devnet, start_time + 1000).await;
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
let mut latest_txs = latest_block.transactions.clone();
latest_txs.sort();
assert_eq!(latest_txs, sent_mint_txs);
assert_ge_with_buffer(latest_block.timestamp, future_time).unwrap();
}
#[tokio::test]
async fn set_time_empty_body() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let response_error = devnet.send_custom_rpc("devnet_setTime", json!({})).await.unwrap_err();
assert_eq!(response_error.code, -32602);
}
#[tokio::test]
async fn set_time_wrong_body() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let rpc_error = devnet
.send_custom_rpc(
"devnet_setTime",
json!({
"test": 0
}),
)
.await
.unwrap_err();
assert_eq!(rpc_error.code, -32602);
}
#[tokio::test]
async fn test_increase_time() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let now = get_unix_timestamp_as_seconds();
// increase time and assert if > now, check if inside buffer limit
let first_increase_time: u64 = 10000;
increase_time(&devnet, first_increase_time).await;
let first_increase_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(first_increase_time_block.timestamp, now + first_increase_time).unwrap();
// second increase time, check if inside buffer limit
let second_increase_time: u64 = 1000;
increase_time(&devnet, second_increase_time).await;
let second_increase_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(
second_increase_time_block.timestamp,
now + first_increase_time + second_increase_time,
)
.unwrap();
sleep_until_new_timestamp().await;
// create block and check again if block_timestamp > last block, check if
// inside buffer limit
devnet.create_block().await.unwrap();
let empty_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(empty_block.timestamp, second_increase_time_block.timestamp).unwrap();
sleep_until_new_timestamp().await;
// check if after mint timestamp > last block, check if inside buffer limit
devnet.mint(DUMMY_ADDRESS, DUMMY_AMOUNT).await;
let last_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(last_block.timestamp, empty_block.timestamp).unwrap();
}
#[tokio::test]
async fn increase_time_empty_body() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let rpc_error = devnet.send_custom_rpc("devnet_increaseTime", json!({})).await.unwrap_err();
assert_eq!(rpc_error.code, -32602);
}
#[tokio::test]
async fn increase_time_wrong_body() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let rpc_error =
devnet.send_custom_rpc("devnet_increaseTime", json!({ "test": 0 })).await.unwrap_err();
assert_eq!(rpc_error.code, -32602);
}
#[tokio::test]
async fn wrong_start_time() {
let devnet = BackgroundDevnet::spawn_with_additional_args(&["--start-time", "wrong"]).await;
assert!(devnet.is_err());
}
#[tokio::test]
async fn start_time_in_past() {
let past_time = 1;
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--start-time",
past_time.to_string().as_str(),
])
.await
.expect("Could not start Devnet");
// create block and check if block timestamp >= 1, check if inside buffer limit
devnet.create_block().await.unwrap();
let empty_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(empty_block.timestamp, past_time).unwrap();
}
#[tokio::test]
async fn start_time_in_future() {
let now = get_unix_timestamp_as_seconds();
let future_time = now + 100;
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--start-time",
future_time.to_string().as_str(),
])
.await
.expect("Could not start Devnet");
// create block and check if block timestamp > now, check if inside buffer limit
devnet.create_block().await.unwrap();
let empty_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(empty_block.timestamp, future_time).unwrap();
}
#[tokio::test]
async fn advance_time_combination_test_with_dump_and_load() {
let now = get_unix_timestamp_as_seconds();
let past_time = 1;
let dump_file = UniqueAutoDeletableFile::new("time_combination");
let devnet = BackgroundDevnet::spawn_with_additional_args(&[
"--start-time",
past_time.to_string().as_str(),
"--dump-path",
dump_file.path.as_str(),
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
// increase time and assert if >= start-time argument + first_increase_time, check if inside
// buffer limit
let first_increase_time: u64 = 1000;
increase_time(&devnet, first_increase_time).await;
let first_increase_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(first_increase_time_block.timestamp, past_time + first_increase_time)
.unwrap();
// increase the time a second time and assert if >= past_time + first_increase_time +
// second_increase_time, check if inside buffer limit
let second_increase_time: u64 = 100;
increase_time(&devnet, second_increase_time).await;
let second_increase_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(
second_increase_time_block.timestamp,
past_time + first_increase_time + second_increase_time,
)
.unwrap();
// set time to be now and check if the latest block timestamp >= now, check if
// it's inside buffer limit
let block_timestamp = set_time(&devnet, now).await;
assert_eq!(block_timestamp, now);
let set_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(set_time_block.timestamp, now).unwrap();
sleep_until_new_timestamp().await;
// create a new empty block and check again if block timestamp > set_time_block, check if
// inside buffer limit
devnet.create_block().await.unwrap();
let empty_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_gt_with_buffer(empty_block.timestamp, set_time_block.timestamp).unwrap();
// increase the time a third time and assert >= last empty block timestamp +
// third_increase_time, check if inside buffer limit
let third_increase_time: u64 = 10000;
increase_time(&devnet, third_increase_time).await;
let third_increase_time_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(
third_increase_time_block.timestamp,
empty_block.timestamp + third_increase_time,
)
.unwrap();
sleep_until_new_timestamp().await;
// check if the last block timestamp is > previous block, check if inside buffer limit
devnet.create_block().await.unwrap();
let last_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_ge_with_buffer(last_block.timestamp, third_increase_time_block.timestamp).unwrap();
send_ctrl_c_signal_and_wait(&devnet.process).await;
// load from file and check block number and timestamp
let devnet_load = BackgroundDevnet::spawn_with_additional_args(&[
"--start-time",
past_time.to_string().as_str(),
"--dump-path",
dump_file.path.as_str(),
"--dump-on",
"exit",
])
.await
.expect("Could not start Devnet");
let last_block_load = devnet_load.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(last_block.block_number, last_block_load.block_number);
let timestamp_diff = last_block_load.timestamp.abs_diff(last_block.timestamp);
assert!(timestamp_diff < BUFFER_TIME_SECONDS)
}
#[tokio::test]
async fn set_time_with_later_block_generation() {
let now = get_unix_timestamp_as_seconds();
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--start-time", now.to_string().as_str()])
.await
.expect("Could not start Devnet");
// set time in past without block generation
let past_time = 1;
let resp_body_set_time: serde_json::Value = devnet
.send_custom_rpc("devnet_setTime", json!({ "time": past_time, "generate_block": false }))
.await
.unwrap();
// time is set but the block was not generated
assert_eq!(resp_body_set_time["block_timestamp"], past_time);
assert!(resp_body_set_time["block_hash"].is_null());
sleep_until_new_timestamp().await;
// create block and assert
devnet.create_block().await.unwrap();
let latest_block = devnet.get_latest_block_with_tx_hashes().await.unwrap();
assert_eq!(latest_block.block_number, 1);
assert_eq!(latest_block.timestamp, past_time);
}
#[tokio::test]
async fn correct_pre_confirmed_block_timestamp() {
let initial_time = get_unix_timestamp_as_seconds();
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--start-time", &initial_time.to_string()])
.await
.unwrap();
let block = devnet.get_pre_confirmed_block_with_txs().await.unwrap();
assert_eq!(block.timestamp, initial_time);
}
#[tokio::test]
async fn correct_pre_confirmed_block_timestamp_after_setting() {
let initial_time = get_unix_timestamp_as_seconds();
let devnet =
BackgroundDevnet::spawn_with_additional_args(&["--start-time", &initial_time.to_string()])
.await
.unwrap();
let block = devnet.get_pre_confirmed_block_with_txs().await.unwrap();
assert_eq!(block.timestamp, initial_time);
sleep_until_new_timestamp().await;
devnet.create_block().await.unwrap();
let block = devnet.get_pre_confirmed_block_with_txs().await.unwrap();
assert_gt_with_buffer(block.timestamp, initial_time).unwrap();
}
#[tokio::test]
async fn tx_resource_estimation_fails_unless_time_incremented() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_timestamp_asserter_contract_artifacts();
let lock_interval = 86_400;
let ctor_args = &[Felt::from(lock_interval)];
let (_, contract_address) =
declare_v3_deploy_v3(&account, contract_class, casm_hash, ctor_args).await.unwrap();
let time_check_selector = get_selector_from_name("check_time").unwrap();
let time_check_call =
Call { to: contract_address, selector: time_check_selector, calldata: vec![] };
// A failure is expected without time change.
let error = account.execute_v3(vec![time_check_call.clone()]).estimate_fee().await.unwrap_err();
match error {
AccountError::Provider(ProviderError::StarknetError(
StarknetError::TransactionExecutionError(error_data),
)) => {
assert_eq!(error_data.transaction_index, 0);
let root_error = extract_nested_error(&error_data.execution_error).unwrap();
assert_eq!(root_error.contract_address, account.address());
assert_eq!(root_error.selector, get_selector_from_name("__execute__").unwrap());
// Currently the root error is twice mentioned, so we extract twice
let inner_error = extract_nested_error(&root_error.error).unwrap();
let inner_error = extract_nested_error(&inner_error.error).unwrap();
assert_eq!(inner_error.contract_address, contract_address);
assert_eq!(inner_error.selector, time_check_selector);
let message = extract_message_error(&inner_error.error).unwrap();
assert_contains(message, "Wait a bit more").unwrap();
}
other => panic!("Invalid error: {other:?}"),
}
// Increasing the system timestamp should make the estimation succeed
increase_time(&devnet, lock_interval).await;
account.execute_v3(vec![time_check_call]).estimate_fee().await.unwrap();
}
#[tokio::test]
async fn tx_execution_fails_unless_time_incremented() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (signer, address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let (contract_class, casm_hash) = get_timestamp_asserter_contract_artifacts();
let lock_interval = 86_400;
let ctor_args = &[Felt::from(lock_interval)];
let (_, contract_address) =
declare_v3_deploy_v3(&account, contract_class, casm_hash, ctor_args).await.unwrap();
let time_check_selector = get_selector_from_name("check_time").unwrap();
let time_check_call =
Call { to: contract_address, selector: time_check_selector, calldata: vec![] };
// A failure is expected without time change.
let reverted_tx = account
.execute_v3(vec![time_check_call.clone()])
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e7 as u64)
.send()
.await
.unwrap();
match devnet.json_rpc_client.get_transaction_status(reverted_tx.transaction_hash).await {
Ok(TransactionStatus::AcceptedOnL2(tx_details)) => {
assert_eq!(tx_details.status(), TransactionExecutionStatus::Reverted);
assert_contains(tx_details.revert_reason().unwrap(), "Wait a bit more").unwrap();
}
other => panic!("Unexpected tx: {other:?}"),
}
// Increasing the system timestamp should make the tx succeed (and the implicit fee estimation)
increase_time(&devnet, lock_interval).await;
account.execute_v3(vec![time_check_call]).send().await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/get_transaction_receipt_by_hash.rs | tests/integration/get_transaction_receipt_by_hash.rs | use std::sync::Arc;
use starknet_rs_accounts::{
Account, AccountFactory, ExecutionEncoding, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{
Call, ExecutionResult, Felt, StarknetError, TransactionFinalityStatus, TransactionReceipt,
};
use starknet_rs_core::utils::{get_selector_from_name, get_udc_deployed_address};
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_0_ACCOUNT_CONTRACT_HASH, CHAIN_ID, ETH_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_CONTRACT_ADDRESS, UDC_CONTRACT_ADDRESS,
};
use crate::common::utils::{
assert_contains, get_deployable_account_signer, get_events_contract_artifacts,
new_contract_factory,
};
#[tokio::test]
async fn deploy_account_transaction_receipt() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let signer = get_deployable_account_signer();
let account_factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
CHAIN_ID,
signer.clone(),
devnet.clone_provider(),
)
.await
.unwrap();
let new_account_nonce = Felt::ZERO;
let salt = Felt::THREE;
let deployment = account_factory.deploy_v3(salt).nonce(new_account_nonce);
let new_account_address = deployment.address();
devnet.mint(new_account_address, 1e18 as u128).await;
// Converting Felt to u64 for the gas parameter
let deploy_account_result = deployment.send().await.unwrap();
let deploy_account_receipt = devnet
.json_rpc_client
.get_transaction_receipt(deploy_account_result.transaction_hash)
.await
.unwrap()
.receipt;
match deploy_account_receipt {
TransactionReceipt::DeployAccount(receipt) => {
assert_eq!(receipt.contract_address, new_account_address);
}
_ => panic!("Invalid receipt {:?}", deploy_account_receipt),
}
}
#[tokio::test]
async fn deploy_transaction_receipt() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
));
let (cairo_1_contract, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.send()
.await
.unwrap();
// deploy the contract
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
let salt = Felt::ZERO;
let constructor_args = Vec::<Felt>::new();
let deployment_result =
contract_factory.deploy_v3(constructor_args.clone(), salt, false).send().await.unwrap();
let deployment_receipt = devnet
.json_rpc_client
.get_transaction_receipt(deployment_result.transaction_hash)
.await
.unwrap()
.receipt;
match deployment_receipt {
TransactionReceipt::Invoke(receipt) => {
assert_eq!(receipt.finality_status, TransactionFinalityStatus::AcceptedOnL2);
let expected_contract_address = get_udc_deployed_address(
salt,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&constructor_args,
);
assert_eq!(receipt.events.len(), 2); // UDC and STRK events
// Assert UDC event
let deployment_event =
receipt.events.iter().find(|e| e.from_address == UDC_CONTRACT_ADDRESS).unwrap();
assert_eq!(
deployment_event.keys,
vec![get_selector_from_name("ContractDeployed").unwrap()]
);
assert_eq!(deployment_event.data[0], expected_contract_address);
assert_eq!(deployment_event.data[1], account_address);
// Assert STRK fee charge event
let fee_charge_event = receipt
.events
.iter()
.find(|e| e.from_address == STRK_ERC20_CONTRACT_ADDRESS)
.unwrap();
assert_eq!(fee_charge_event.keys, vec![get_selector_from_name("Transfer").unwrap()]);
assert_eq!(fee_charge_event.data[0], account_address);
}
_ => panic!("Invalid receipt {:?}", deployment_receipt),
};
}
#[tokio::test]
async fn invalid_deploy_transaction_receipt() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::New,
));
let (cairo_1_contract, casm_class_hash) = get_events_contract_artifacts();
// declare the contract
let declaration_result = predeployed_account
.declare_v3(Arc::new(cairo_1_contract), casm_class_hash)
.send()
.await
.unwrap();
// try deploying with invalid constructor args - none are expected, we are providing [1]
let contract_factory =
new_contract_factory(declaration_result.class_hash, predeployed_account.clone());
let salt = Felt::ZERO;
let invalid_constructor_args = vec![Felt::ONE];
let l1_gas = 0;
let l1_data_gas = 1000;
let l2_gas = 1e6 as u64;
let invalid_deployment_result = contract_factory
.deploy_v3(invalid_constructor_args, salt, false)
.l1_gas(l1_gas)
.l1_data_gas(l1_data_gas)
.l2_gas(l2_gas)
.send()
.await
.unwrap();
let invalid_deployment_receipt = devnet
.json_rpc_client
.get_transaction_receipt(invalid_deployment_result.transaction_hash)
.await
.unwrap()
.receipt;
match invalid_deployment_receipt {
TransactionReceipt::Invoke(receipt) => {
match receipt.execution_result {
ExecutionResult::Reverted { reason } => {
assert!(reason.contains("Input too long for arguments"));
}
other => panic!("Invalid execution result {other:?}"),
}
assert_eq!(receipt.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert!(receipt.execution_resources.l1_gas <= l1_gas);
assert!(receipt.execution_resources.l1_data_gas <= l1_data_gas);
assert!(receipt.execution_resources.l2_gas <= l2_gas);
}
_ => panic!("Invalid receipt {:?}", invalid_deployment_receipt),
};
}
#[tokio::test]
async fn reverted_invoke_transaction_receipt() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let transfer_execution = predeployed_account.execute_v3(vec![Call {
to: ETH_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
Felt::from(1_000_000_000), // low part of uint256
Felt::ZERO, // high part of uint256
],
}]);
let fee = transfer_execution.estimate_fee().await.unwrap();
// send transaction with lower than estimated overall fee; should revert
let transfer_result = transfer_execution
.l1_gas(fee.l1_gas_consumed) // Using as is, ok to be 0
// .l2_gas(u64::try_from(fee.l2_gas_consumed).unwrap() - 1) // subtract to induce failure
.l2_gas(1156800 - 1) // TODO: determined experimentally as the actual value used minus 1
.l1_data_gas(fee.l1_data_gas_consumed) // using as is
.send()
.await
.unwrap();
let transfer_receipt = devnet
.json_rpc_client
.get_transaction_receipt(transfer_result.transaction_hash)
.await
.unwrap()
.receipt;
match transfer_receipt {
TransactionReceipt::Invoke(receipt) => {
match receipt.execution_result {
starknet_rs_core::types::ExecutionResult::Reverted { reason } => {
assert_contains(&reason, "Insufficient max L2Gas").unwrap();
}
_ => panic!("Invalid receipt {:?}", receipt),
}
// due to earlier l2_gas - 1
assert!(receipt.actual_fee.amount <= Felt::from(fee.overall_fee - fee.l2_gas_price));
}
_ => panic!("Invalid receipt {:?}", transfer_receipt),
};
}
#[tokio::test]
async fn get_non_existing_transaction() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let result = devnet.json_rpc_client.get_transaction_receipt(Felt::ZERO).await.unwrap_err();
match result {
ProviderError::StarknetError(StarknetError::TransactionHashNotFound) => (),
_ => panic!("Invalid error: {result:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_to_new_txs.rs | tests/integration/test_subscription_to_new_txs.rs | use std::collections::HashMap;
use serde_json::json;
use starknet_core::constants::CHARGEABLE_ACCOUNT_ADDRESS;
use starknet_rs_accounts::{ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
DeclareTransactionV3, DeployAccountTransaction, Felt, InvokeTransactionV3, Transaction,
TransactionFinalityStatus,
};
use tokio_tungstenite::connect_async;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
FeeUnit, assert_no_notifications, declare_deploy_simple_contract, deploy_oz_account,
receive_new_tx, receive_rpc_via_ws, send_dummy_mint_tx, subscribe_new_txs, unsubscribe,
};
#[tokio::test]
async fn should_not_notify_in_block_on_demand_mode_if_default_subscription_params() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// No notifications because default finality_status is ACCEPTED_ON_L2
subscribe_new_txs(&mut ws, json!({})).await.unwrap();
send_dummy_mint_tx(&devnet).await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_pre_confirmed_txs_with_block_generation_on_demand() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let finality_status = TransactionFinalityStatus::PreConfirmed;
let subscription_params = json!({ "finality_status": [finality_status] });
let subscription_id = subscribe_new_txs(&mut ws, subscription_params).await.unwrap();
let tx_hash = send_dummy_mint_tx(&devnet).await;
let mut notification_tx = receive_new_tx(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_tx["finality_status"].take(), json!(finality_status));
let extracted_tx: Transaction = serde_json::from_value(notification_tx).unwrap();
assert_eq!(extracted_tx.transaction_hash(), &tx_hash);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_of_accepted_on_l2_with_block_generation_on_tx() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut explicit_ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut implicit_ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// One subscription is with explicit finality_status, the other with implicit/default
let finality_status = TransactionFinalityStatus::AcceptedOnL2;
let explicit_subscription_id =
subscribe_new_txs(&mut explicit_ws, json!({ "finality_status": [finality_status] }))
.await
.unwrap();
let implicit_subscription_id = subscribe_new_txs(&mut implicit_ws, json!({})).await.unwrap();
let tx_hash = send_dummy_mint_tx(&devnet).await;
for (mut ws, subscription_id) in
[(explicit_ws, explicit_subscription_id), (implicit_ws, implicit_subscription_id)]
{
let mut notification_tx = receive_new_tx(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_tx["finality_status"].take(), json!(finality_status));
let extracted_tx: Transaction = serde_json::from_value(notification_tx).unwrap();
assert_eq!(extracted_tx.transaction_hash(), &tx_hash);
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_notify_for_multiple_subscribers_with_default_params() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mut subscribers = HashMap::new();
for _ in 0..2 {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_txs(&mut ws, json!({})).await.unwrap();
subscribers.insert(subscription_id, ws);
}
let tx_hash = send_dummy_mint_tx(&devnet).await;
let finality_status = TransactionFinalityStatus::AcceptedOnL2;
for (subscription_id, mut ws) in subscribers {
let mut notification_tx = receive_new_tx(&mut ws, subscription_id).await.unwrap();
assert_eq!(notification_tx["finality_status"].take(), json!(finality_status));
let extracted_tx: Transaction = serde_json::from_value(notification_tx).unwrap();
assert_eq!(extracted_tx.transaction_hash(), &tx_hash);
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_stop_notifying_after_unsubscription() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let mut subscribers = vec![];
for _ in 0..3 {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_txs(&mut ws, json!({})).await.unwrap();
subscribers.push((ws, subscription_id));
}
send_dummy_mint_tx(&devnet).await;
for (ws, subscription_id) in subscribers.iter_mut() {
receive_rpc_via_ws(ws).await.unwrap();
let unsubscription = unsubscribe(ws, subscription_id.clone()).await.unwrap();
assert_eq!(unsubscription, json!({ "jsonrpc": "2.0", "id": 0, "result": true }));
}
send_dummy_mint_tx(&devnet).await;
for (mut ws, _) in subscribers {
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_notify_for_filtered_address() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let subscription_id =
subscribe_new_txs(&mut ws, json!({ "sender_address": [account_address] })).await.unwrap();
// Send the actual txs
let (class_hash, _) = declare_deploy_simple_contract(&predeployed_account).await.unwrap();
// Assert received declaration notification
let declaration_notification = receive_new_tx(&mut ws, subscription_id.clone()).await.unwrap();
let declaration_tx: DeclareTransactionV3 =
serde_json::from_value(declaration_notification).unwrap();
assert_eq!(declaration_tx.class_hash, class_hash);
assert_eq!(declaration_tx.nonce, Felt::ZERO);
// Assert received deployment notification
let deployment_notification = receive_new_tx(&mut ws, subscription_id).await.unwrap();
let deployment_tx: InvokeTransactionV3 =
serde_json::from_value(deployment_notification).unwrap();
assert_eq!(deployment_tx.nonce, Felt::ONE);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_filtered_address_not_matched() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// dummy address
subscribe_new_txs(&mut ws, json!({ "sender_address": ["0x1"] })).await.unwrap();
send_dummy_mint_tx(&devnet).await;
// nothing matched since minting is done via the Chargeable account
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_by_filtered_address_already_in_pre_confirmed_block() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
send_dummy_mint_tx(&devnet).await;
let finality_status = TransactionFinalityStatus::PreConfirmed;
for subscription_params in [
json!({ "finality_status": [finality_status] }),
// Minting is done by the Chargeable account
json!({ "finality_status": [finality_status], "sender_address": [CHARGEABLE_ACCOUNT_ADDRESS] }),
json!({ "finality_status": [finality_status], "sender_address": [] }),
] {
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
subscribe_new_txs(&mut ws, subscription_params).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_not_notify_if_tx_by_filtered_address_in_latest_block_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
send_dummy_mint_tx(&devnet).await;
devnet.create_block().await.unwrap();
// Minting is done by the Chargeable account
let acceptable_address = CHARGEABLE_ACCOUNT_ADDRESS;
subscribe_new_txs(
&mut ws,
json!({ "finality_status": [TransactionFinalityStatus::PreConfirmed], "sender_address": [acceptable_address] }),
)
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_by_filtered_address_in_latest_block_in_on_tx_mode() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// Create tx and new block
send_dummy_mint_tx(&devnet).await;
// Minting is done by the Chargeable account
let acceptable_address = CHARGEABLE_ACCOUNT_ADDRESS;
subscribe_new_txs(
&mut ws,
json!({ "finality_status": [TransactionFinalityStatus::PreConfirmed], "sender_address": [acceptable_address] }),
)
.await
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_already_in_latest_block_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
send_dummy_mint_tx(&devnet).await;
devnet.create_block().await.unwrap();
// Subscribe AFTER the tx and block creation.
let finality_status = TransactionFinalityStatus::PreConfirmed;
subscribe_new_txs(&mut ws, json!({ "finality_status": [finality_status] })).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_if_tx_already_in_latest_block_in_on_tx_mode() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
send_dummy_mint_tx(&devnet).await;
// Subscribe AFTER the tx and block creation.
for finality_status in
[TransactionFinalityStatus::PreConfirmed, TransactionFinalityStatus::AcceptedOnL2]
{
subscribe_new_txs(&mut ws, json!({ "finality_status": [finality_status] })).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_not_notify_on_read_request_if_txs_in_pre_confirmed_block() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let finality_status = TransactionFinalityStatus::PreConfirmed;
subscribe_new_txs(&mut ws, json!({ "finality_status": [finality_status] })).await.unwrap();
send_dummy_mint_tx(&devnet).await;
receive_rpc_via_ws(&mut ws).await.unwrap();
// Read request should have no impact
let dummy_address = Felt::ONE;
devnet.get_balance_latest(&dummy_address, FeeUnit::Wei).await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_twice_if_subscribed_to_both_finality_statuses() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let finality_statuses =
[TransactionFinalityStatus::PreConfirmed, TransactionFinalityStatus::AcceptedOnL2];
let subscription_id =
subscribe_new_txs(&mut ws, json!({ "finality_status": finality_statuses })).await.unwrap();
let tx_hash = send_dummy_mint_tx(&devnet).await;
for finality_status in finality_statuses {
let mut notification_tx = receive_new_tx(&mut ws, subscription_id.clone()).await.unwrap();
assert_eq!(notification_tx["finality_status"].take(), json!(finality_status));
let extracted_tx: Transaction = serde_json::from_value(notification_tx).unwrap();
assert_eq!(extracted_tx.transaction_hash(), &tx_hash);
assert_no_notifications(&mut ws).await.unwrap();
devnet.create_block().await.unwrap(); // On first loop iteration, this changes tx status
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_deploy_account_tx_notification() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_new_txs(&mut ws, json!({})).await.unwrap();
let (deployment_result, _) = deploy_oz_account(&devnet).await.unwrap();
let _minting_notification = receive_new_tx(&mut ws, subscription_id.clone()).await.unwrap();
let notification = receive_new_tx(&mut ws, subscription_id).await.unwrap();
let tx: DeployAccountTransaction = serde_json::from_value(notification.clone()).unwrap();
assert_eq!(*tx.transaction_hash(), deployment_result.transaction_hash);
assert_eq!(notification["transaction_hash"], json!(deployment_result.transaction_hash));
assert_no_notifications(&mut ws).await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_with_invalid_block_id.rs | tests/integration/test_subscription_with_invalid_block_id.rs | use serde_json::json;
use starknet_rs_core::types::{BlockId, Felt};
use tokio_tungstenite::connect_async;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::utils::{assert_no_notifications, send_text_rpc_via_ws};
fn block_not_found_error() -> serde_json::Value {
json!({ "jsonrpc": "2.0", "id": 0, "error": { "code": 24, "message": "Block not found" } })
}
fn call_on_pre_confirmed_error() -> serde_json::Value {
json!({ "jsonrpc": "2.0", "id": 0, "error": { "code": -32602, "message": "Subscription block cannot be 'pre_confirmed'" }})
}
fn call_on_l1_accepted_error() -> serde_json::Value {
json!({ "jsonrpc": "2.0", "id": 0, "error": { "code": -32602, "message": "Subscription block cannot be 'l1_accepted'" }})
}
#[tokio::test]
async fn test_subscribing_to_non_existent_block() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// Cartesian product: subscription_method x invalid_block_id
for subscription_method in ["starknet_subscribeNewHeads", "starknet_subscribeEvents"] {
for block_id in [BlockId::Number(1), BlockId::Hash(Felt::ONE)] {
let subscription_resp =
send_text_rpc_via_ws(&mut ws, subscription_method, json!({ "block_id": block_id }))
.await
.unwrap();
assert_eq!(subscription_resp, block_not_found_error())
}
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_aborted_blocks_not_subscribable() {
let devnet_args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let created_block_hash = devnet.create_block().await.unwrap();
devnet.abort_blocks(&BlockId::Hash(created_block_hash)).await.unwrap();
// Cartesian product: subscription_method x invalid_block_id
for subscription_method in ["starknet_subscribeNewHeads", "starknet_subscribeEvents"] {
for block_id in [BlockId::Number(1), BlockId::Hash(created_block_hash)] {
let subscription_resp =
send_text_rpc_via_ws(&mut ws, subscription_method, json!({ "block_id": block_id }))
.await
.unwrap();
assert_eq!(subscription_resp, block_not_found_error())
}
}
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_pre_confirmed_block_not_allowed_in_block_and_event_subscription() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
for subscription_method in ["starknet_subscribeNewHeads", "starknet_subscribeEvents"] {
let subscription_resp = send_text_rpc_via_ws(
&mut ws,
subscription_method,
json!({ "block_id": "pre_confirmed" }),
)
.await
.unwrap();
assert_eq!(
subscription_resp,
call_on_pre_confirmed_error(),
"Method: {subscription_method}"
);
}
}
#[tokio::test]
async fn test_l1_accepted_block_not_allowed_in_block_and_event_subscription() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
for subscription_method in ["starknet_subscribeNewHeads", "starknet_subscribeEvents"] {
let subscription_resp = send_text_rpc_via_ws(
&mut ws,
subscription_method,
json!({ "block_id": "l1_accepted" }),
)
.await
.unwrap();
assert_eq!(subscription_resp, call_on_l1_accepted_error(), "Method: {subscription_method}");
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_websocket.rs | tests/integration/test_websocket.rs | use std::sync::Arc;
use futures::{SinkExt, StreamExt};
use serde_json::json;
use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::types::{
BroadcastedDeclareTransactionV3, DataAvailabilityMode, Felt, Transaction,
};
use starknet_rs_signers::Signer;
use tokio_tungstenite::connect_async;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants;
use crate::common::utils::{
FeeUnit, LocalFee, UniqueAutoDeletableFile, assert_no_notifications,
get_simple_contract_artifacts, send_binary_rpc_via_ws, send_ctrl_c_signal_and_wait,
send_text_rpc_via_ws, subscribe,
};
#[tokio::test]
async fn mint_and_check_tx_via_websocket() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let mint_resp = send_text_rpc_via_ws(
&mut ws,
"devnet_mint",
json!({ "address": "0x1", "amount": 100, "unit": "FRI" }),
)
.await
.unwrap();
let tx_hash = Felt::from_hex_unchecked(mint_resp["result"]["tx_hash"].as_str().unwrap());
let tx_raw = send_text_rpc_via_ws(
&mut ws,
"starknet_getTransactionByHash",
json!({ "transaction_hash": tx_hash }),
)
.await
.unwrap();
let tx: Transaction = serde_json::from_value(tx_raw["result"].clone()).unwrap();
assert_eq!(tx.transaction_hash(), &tx_hash);
}
#[tokio::test]
async fn create_block_via_binary_ws_message() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let block_specifier = json!({ "block_id": "latest" });
let block_resp_before =
send_binary_rpc_via_ws(&mut ws, "starknet_getBlockWithTxs", block_specifier.clone())
.await
.unwrap();
assert_eq!(block_resp_before["result"]["block_number"], 0);
let creation_resp =
send_binary_rpc_via_ws(&mut ws, "devnet_createBlock", json!({})).await.unwrap();
assert!(creation_resp["result"].is_object());
let block_resp_after =
send_binary_rpc_via_ws(&mut ws, "starknet_getBlockWithTxs", block_specifier).await.unwrap();
assert_eq!(block_resp_after["result"]["block_number"], 1);
}
#[tokio::test]
async fn multiple_ws_connections() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let iterations = 10;
let mut ws_streams = vec![];
for _ in 0..iterations {
let (ws, _) = connect_async(devnet.ws_url()).await.unwrap();
ws_streams.push(ws);
}
let dummy_address = Felt::ONE;
let single_mint_amount = 11;
let mint_params = json!({ "address": dummy_address, "amount": single_mint_amount });
for ws in &mut ws_streams {
send_text_rpc_via_ws(ws, "devnet_mint", mint_params.clone()).await.unwrap();
}
let balance = devnet.get_balance_latest(&dummy_address, FeeUnit::Fri).await.unwrap();
assert_eq!(balance, Felt::from(single_mint_amount * iterations));
}
#[tokio::test]
async fn invalid_general_rpc_request() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let resp = send_text_rpc_via_ws(&mut ws, "devnet_mint", json!({})).await.unwrap();
assert_eq!(resp["error"]["message"], "missing field `address`");
}
#[tokio::test]
async fn restarting_should_forget_all_websocket_subscriptions() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
devnet.create_block().await.unwrap();
subscribe(&mut ws, "starknet_subscribeNewHeads", json!({})).await.unwrap();
devnet.restart().await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn test_deserialization_error_via_ws() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
ws.send(tokio_tungstenite::tungstenite::Message::Text("garbage_string".into())).await.unwrap();
let resp_raw = ws.next().await.unwrap().unwrap();
let resp: serde_json::Value = serde_json::from_slice(&resp_raw.into_data()).unwrap();
assert_eq!(
resp,
json!({
"jsonrpc": "2.0",
"id": serde_json::Value::Null,
"error": { "code": -32700, "message": "Parse error", "data": {"reason" : "expected value at line 1 column 1"} }
})
);
}
#[tokio::test]
async fn test_invalid_rpc_methods_via_ws() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
for method in [
"starknet_invalid",
"definitely_invalid",
"devnet_invalid",
"starknet_subscribeInvalid",
"starknet_unsubscribeInvalid",
] {
let resp = send_text_rpc_via_ws(&mut ws, method, json!({})).await.unwrap();
assert_eq!(
resp,
json!({
"jsonrpc": "2.0",
"id": 0,
"error": { "code": -32601, "message": "Method not found" }
})
);
}
}
#[tokio::test]
async fn method_restriction_applies_via_ws() {
let devnet_args = ["--restrictive-mode", "devnet_mint"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let mint_resp = send_text_rpc_via_ws(
&mut ws,
"devnet_mint",
json!({ "address": "0x1", "amount": 100, "unit": "FRI" }),
)
.await
.unwrap();
assert_eq!(
mint_resp,
json!({"jsonrpc":"2.0","id":0,"error":{"code":-32604,"message":"Method forbidden"}})
)
}
#[tokio::test]
// Dumping section isolated to prevent variable mixing
async fn should_load_correct_devnet_with_state_modified_via_ws() {
// Common to dumpable and loaded Devnet
let dump_file = UniqueAutoDeletableFile::new("tmp");
let mint_address = "0x1";
let mint_amount = 100;
{
let devnet_args = ["--dump-on", "request"];
let devnet_dumpable =
BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws_on_dumped, _) = connect_async(devnet_dumpable.ws_url()).await.unwrap();
send_text_rpc_via_ws(
&mut ws_on_dumped,
"devnet_mint",
json!({ "address": mint_address, "amount": mint_amount, "unit": "FRI" }),
)
.await
.unwrap();
let dump_resp = send_text_rpc_via_ws(
&mut ws_on_dumped,
"devnet_dump",
json!({ "path": dump_file.path }),
)
.await
.unwrap();
assert_eq!(dump_resp, json!({ "jsonrpc": "2.0", "id": 0, "result": null }));
send_ctrl_c_signal_and_wait(&devnet_dumpable.process).await;
}
let devnet_loaded = BackgroundDevnet::spawn().await.unwrap();
let (mut ws_on_loaded, _) = connect_async(devnet_loaded.ws_url()).await.unwrap();
let load_resp =
send_text_rpc_via_ws(&mut ws_on_loaded, "devnet_load", json!({ "path": dump_file.path }))
.await
.unwrap();
assert_eq!(load_resp, json!({ "jsonrpc": "2.0", "id": 0, "result": {} }));
let balance_resp = send_text_rpc_via_ws(
&mut ws_on_loaded,
"devnet_getAccountBalance",
json!({ "address": mint_address, "unit": "FRI" }),
)
.await
.unwrap();
assert_eq!(
balance_resp,
json!({ "jsonrpc": "2.0", "id": 0, "result": {"amount": mint_amount.to_string(), "unit": "FRI"} })
);
}
#[tokio::test]
async fn should_support_restarting_via_ws() {
let devnet_args = ["--dump-on", "request"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let mint_address = "0x1";
send_text_rpc_via_ws(
&mut ws,
"devnet_mint",
json!({ "address": mint_address, "amount": 100, "unit": "FRI" }),
)
.await
.unwrap();
let restart_resp = send_text_rpc_via_ws(&mut ws, "devnet_restart", json!({})).await.unwrap();
assert_eq!(restart_resp, json!({ "jsonrpc": "2.0", "id": 0, "result": {} }));
let balance_resp = send_text_rpc_via_ws(
&mut ws,
"devnet_getAccountBalance",
json!({ "address": mint_address, "unit": "FRI" }),
)
.await
.unwrap();
assert_eq!(
balance_resp,
json!({ "jsonrpc": "2.0", "id": 0, "result": {"amount": "0", "unit": "FRI"} })
);
}
#[tokio::test]
async fn should_declare_via_ws() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
// Prepare account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
// Prepare class
let (simple_class, casm_hash) = get_simple_contract_artifacts();
let simple_class = Arc::new(simple_class);
// Prepare declaration - create a signable tx
let declaration = account.declare_v3(simple_class.clone(), casm_hash);
let nonce = Felt::ZERO;
let fee = LocalFee::from(declaration.estimate_fee().await.unwrap());
let signable_declaration = declaration
.l1_gas(fee.l1_gas)
.l1_gas_price(fee.l1_gas_price)
.l2_gas(fee.l2_gas)
.l2_gas_price(fee.l2_gas_price)
.l1_data_gas(fee.l1_data_gas)
.l1_data_gas_price(fee.l1_data_gas_price)
.nonce(nonce)
.tip(0)
.prepared()
.unwrap();
// Prepare declaration - sign it
let declaration_hash = signable_declaration.transaction_hash(false);
let signature = signer.sign_hash(&declaration_hash).await.unwrap();
// Send the declaration tx via ws
let sendable_declaration = BroadcastedDeclareTransactionV3 {
sender_address: account_address,
compiled_class_hash: casm_hash,
signature: vec![signature.r, signature.s],
nonce,
contract_class: simple_class,
resource_bounds: fee.into(),
tip: 0,
paymaster_data: vec![],
account_deployment_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
is_query: false,
};
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let declaration_resp = send_text_rpc_via_ws(
&mut ws,
"starknet_addDeclareTransaction",
json!({ "declare_transaction": sendable_declaration }),
)
.await
.unwrap();
let received_declaration_hash =
Felt::from_hex_unchecked(declaration_resp["result"]["transaction_hash"].as_str().unwrap());
assert_eq!(declaration_hash, received_declaration_hash);
// Assert sending the tx was successful
let tx_status = send_text_rpc_via_ws(
&mut ws,
"starknet_getTransactionStatus",
json!({ "transaction_hash": declaration_hash }),
)
.await
.unwrap();
assert_eq!(
tx_status["result"],
json!({
"finality_status": "ACCEPTED_ON_L2",
"failure_reason": null,
"execution_status": "SUCCEEDED",
})
);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_gas_modification.rs | tests/integration/test_gas_modification.rs | use std::sync::Arc;
use serde_json::json;
use starknet_core::constants::{
DEVNET_DEFAULT_L1_DATA_GAS_PRICE, DEVNET_DEFAULT_L1_GAS_PRICE, DEVNET_DEFAULT_L2_GAS_PRICE,
};
use starknet_rs_accounts::{Account, AccountError, ExecutionEncoding, SingleOwnerAccount};
use starknet_rs_core::chain_id::SEPOLIA;
use starknet_rs_core::types::{Felt, ResourcePrice, StarknetError};
use starknet_rs_core::utils::cairo_short_string_to_felt;
use starknet_rs_providers::{Provider, ProviderError};
use starknet_rs_signers::Signer;
use crate::assert_eq_prop;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_1_CONTRACT_PATH, INTEGRATION_SAFE_BLOCK, INTEGRATION_SEPOLIA_HTTP_URL,
};
use crate::common::errors::RpcError;
use crate::common::fees::assert_difference_if_validation;
use crate::common::utils::{
assert_tx_succeeded_accepted, felt_to_u128, get_flattened_sierra_contract_and_casm_hash,
get_simple_contract_artifacts, iter_to_hex_felt, to_hex_felt, to_num_as_hex,
};
trait SetGasPrice {
async fn set_gas_price(
&self,
gas_price: &serde_json::Value,
generate_block: bool,
) -> Result<serde_json::Value, RpcError>;
}
impl SetGasPrice for BackgroundDevnet {
async fn set_gas_price(
&self,
gas_price: &serde_json::Value,
generate_block: bool,
) -> Result<serde_json::Value, RpcError> {
let mut req_obj = gas_price.clone();
if generate_block {
req_obj["generate_block"] = json!(true);
}
self.send_custom_rpc("devnet_setGasPrice", req_obj).await
}
}
/// Test scenario for gas modification involving simulateTransactions:
/// 1. Execute simulateTransactions with a declare transaction and check gas fees.
/// 2. Set the gas values.
/// 3. Execute simulateTransactions again and check gas fees.
///
/// Chain ID assertion justified in: https://github.com/0xSpaceShard/starknet-devnet/pull/551#discussion_r1682755696
///
/// Note to test maintainer: the usual way of adapting this test to a new Starknet version is to
/// repeatedly run it and hardcode new hex fee values.
async fn set_gas_scenario(
devnet: BackgroundDevnet,
expected_chain_id: Felt,
) -> Result<(), anyhow::Error> {
// get account
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
expected_chain_id,
ExecutionEncoding::New,
);
// get class
let (flattened_contract_artifact, casm_hash) =
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_CONTRACT_PATH);
let nonce = Felt::ZERO;
let declaration = account
.declare_v3(Arc::new(flattened_contract_artifact.clone()), casm_hash)
.l1_gas(0)
.l1_gas_price(0)
.l1_data_gas(0)
.l1_data_gas_price(0)
.l2_gas(0)
.l2_gas_price(0)
.nonce(nonce)
.tip(0)
.prepared()?;
let signature = signer.sign_hash(&declaration.transaction_hash(false)).await?;
let zero_bounds = json!({ "max_amount": "0x0", "max_price_per_unit": "0x0" });
let sender_address_hex = to_hex_felt(&account_address);
let get_params = |simulation_flags: &[&str]| -> serde_json::Value {
json!({
"block_id": "latest",
"simulation_flags": simulation_flags,
"transactions": [
{
"type": "DECLARE",
"sender_address": sender_address_hex,
"compiled_class_hash": to_hex_felt(&casm_hash),
"version": "0x3",
"resource_bounds": {
"l1_gas": zero_bounds,
"l1_data_gas": zero_bounds,
"l2_gas": zero_bounds,
},
"signature": iter_to_hex_felt(&[signature.r, signature.s]),
"nonce": to_num_as_hex(&nonce),
"contract_class": flattened_contract_artifact,
"tip": "0x0",
"paymaster_data": [],
"account_deployment_data": [],
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1",
}
]
})
};
let chain_id = devnet.json_rpc_client.chain_id().await?;
assert_eq_prop!(chain_id, expected_chain_id)?;
let params_skip_fee_charge = get_params(&["SKIP_FEE_CHARGE"]);
let resp_no_flags = &devnet
.send_custom_rpc("starknet_simulateTransactions", params_skip_fee_charge.clone())
.await
.map_err(|err| anyhow::anyhow!("failed to simulate transactions {:?}", err))?[0];
assert_eq_prop!(
resp_no_flags["fee_estimation"]["l1_gas_price"],
to_hex_felt(&DEVNET_DEFAULT_L1_GAS_PRICE)
)?;
assert_eq_prop!(
resp_no_flags["fee_estimation"]["l1_data_gas_price"],
to_hex_felt(&DEVNET_DEFAULT_L1_DATA_GAS_PRICE)
)?;
assert_eq_prop!(
resp_no_flags["fee_estimation"]["l2_gas_price"],
to_hex_felt(&DEVNET_DEFAULT_L2_GAS_PRICE)
)?;
assert_eq_prop!(resp_no_flags["transaction_trace"]["execution_resources"]["l1_gas"], 0)?;
assert_eq_prop!(resp_no_flags["fee_estimation"]["overall_fee"], "0x99cb411f968000")?;
let params_skip_validation_and_fee_charge = get_params(&["SKIP_VALIDATE", "SKIP_FEE_CHARGE"]);
let resp_skip_validation = &devnet
.send_custom_rpc(
"starknet_simulateTransactions",
params_skip_validation_and_fee_charge.clone(),
)
.await
.map_err(|err| anyhow::anyhow!("failed to simulate transactions {:?}", err))?[0];
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["l1_gas_price"],
to_hex_felt(&DEVNET_DEFAULT_L1_GAS_PRICE)
)?;
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["l1_data_gas_price"],
to_hex_felt(&DEVNET_DEFAULT_L1_DATA_GAS_PRICE)
)?;
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["l2_gas_price"],
to_hex_felt(&DEVNET_DEFAULT_L2_GAS_PRICE)
)?;
assert_eq_prop!(resp_no_flags["transaction_trace"]["execution_resources"]["l1_gas"], 0)?;
assert_eq_prop!(resp_skip_validation["fee_estimation"]["overall_fee"], "0x995e1d72370000")?;
let should_skip_fee_invocation = true;
assert_difference_if_validation(
resp_no_flags,
resp_skip_validation,
&sender_address_hex,
should_skip_fee_invocation,
);
let l1_fri_price = 8.5e18 as u128;
let l1_data_fri_price = 7.5e18 as u128;
let l2_fri_price = 6.5e18 as u128;
let gas_request = json!({
"gas_price_wei": 9e18 as u128,
"gas_price_fri": l1_fri_price,
"data_gas_price_wei": 8e18 as u128,
"data_gas_price_fri": l1_data_fri_price,
"l2_gas_price_wei": 7e18 as u128,
"l2_gas_price_fri": l2_fri_price,
});
let gas_response = &devnet.set_gas_price(&gas_request, true).await?;
assert_eq_prop!(gas_response, &gas_request)?;
let chain_id = devnet.json_rpc_client.chain_id().await?;
assert_eq_prop!(chain_id, expected_chain_id)?;
let resp_no_flags =
&devnet.send_custom_rpc("starknet_simulateTransactions", params_skip_fee_charge).await?[0];
assert_eq_prop!(resp_no_flags["fee_estimation"]["l1_gas_price"], to_hex_felt(&l1_fri_price))?;
assert_eq_prop!(
resp_no_flags["fee_estimation"]["l1_data_gas_price"],
to_hex_felt(&l1_data_fri_price)
)?;
assert_eq_prop!(resp_no_flags["fee_estimation"]["l2_gas_price"], to_hex_felt(&l2_fri_price))?;
assert_eq_prop!(resp_no_flags["fee_estimation"]["overall_fee"], "0xe8c077047881faf1800000")?;
let resp_skip_validation = &devnet
.send_custom_rpc("starknet_simulateTransactions", params_skip_validation_and_fee_charge)
.await?[0];
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["l1_gas_price"],
to_hex_felt(&l1_fri_price)
)?;
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["l1_data_gas_price"],
to_hex_felt(&l1_data_fri_price)
)?;
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["l2_gas_price"],
to_hex_felt(&l2_fri_price)
)?;
assert_eq_prop!(
resp_skip_validation["fee_estimation"]["overall_fee"],
"0xe81b4b21fb0b18a2000000"
)?;
assert_difference_if_validation(
resp_no_flags,
resp_skip_validation,
&sender_address_hex,
should_skip_fee_invocation,
);
Ok(())
}
#[tokio::test]
async fn set_gas() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
// Testnet gas modification test scenario
set_gas_scenario(devnet, SEPOLIA).await.unwrap();
}
#[tokio::test]
async fn set_gas_fork() {
let fork_block = &INTEGRATION_SAFE_BLOCK.to_string();
let cli_args = ["--fork-network", INTEGRATION_SEPOLIA_HTTP_URL, "--fork-block", fork_block];
let fork_devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
// Sepolia fork gas modification test scenario
set_gas_scenario(fork_devnet, cairo_short_string_to_felt("SN_INTEGRATION_SEPOLIA").unwrap())
.await
.unwrap();
}
#[tokio::test]
async fn set_gas_check_blocks() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let default_gas_price = ResourcePrice {
price_in_wei: u128::from(DEVNET_DEFAULT_L1_GAS_PRICE).into(),
price_in_fri: u128::from(DEVNET_DEFAULT_L1_GAS_PRICE).into(),
};
let default_data_gas_price = ResourcePrice {
price_in_wei: u128::from(DEVNET_DEFAULT_L1_DATA_GAS_PRICE).into(),
price_in_fri: u128::from(DEVNET_DEFAULT_L1_DATA_GAS_PRICE).into(),
};
let default_l2_gas_price = ResourcePrice {
price_in_wei: u128::from(DEVNET_DEFAULT_L2_GAS_PRICE).into(),
price_in_fri: u128::from(DEVNET_DEFAULT_L2_GAS_PRICE).into(),
};
// First update - don't generate new block
let latest_block = devnet.get_latest_block_with_txs().await.unwrap();
assert_eq!(latest_block.block_number, 0);
assert_eq!(latest_block.l1_gas_price, default_gas_price);
assert_eq!(latest_block.l1_data_gas_price, default_data_gas_price);
assert_eq!(latest_block.l2_gas_price, default_l2_gas_price);
let first_update_gas_price =
ResourcePrice { price_in_wei: (9e18 as u128).into(), price_in_fri: (7e18 as u128).into() };
let first_update_data_gas_price =
ResourcePrice { price_in_wei: (8e18 as u128).into(), price_in_fri: (6e18 as u128).into() };
let first_update_l2_gas_price = ResourcePrice {
price_in_wei: (8.5e18 as u128).into(),
price_in_fri: (7.5e18 as u128).into(),
};
let gas_request = json!({
"gas_price_wei": felt_to_u128(first_update_gas_price.price_in_wei),
"data_gas_price_wei": felt_to_u128(first_update_data_gas_price.price_in_wei),
"l2_gas_price_wei": felt_to_u128(first_update_l2_gas_price.price_in_wei),
"gas_price_fri": felt_to_u128(first_update_gas_price.price_in_fri),
"data_gas_price_fri": felt_to_u128(first_update_data_gas_price.price_in_fri),
"l2_gas_price_fri": felt_to_u128(first_update_l2_gas_price.price_in_fri),
});
let gas_response = devnet.set_gas_price(&gas_request, false).await.unwrap();
assert_eq!(gas_response, gas_request);
let latest_block = devnet.get_latest_block_with_txs().await.unwrap();
assert_eq!(latest_block.block_number, 0);
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
assert_eq!(pre_confirmed_block.l1_gas_price, default_gas_price);
assert_eq!(pre_confirmed_block.l1_data_gas_price, default_gas_price);
devnet.create_block().await.unwrap();
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
assert_eq!(pre_confirmed_block.l1_gas_price, first_update_gas_price);
assert_eq!(pre_confirmed_block.l1_data_gas_price, first_update_data_gas_price);
let latest_block = devnet.get_latest_block_with_txs().await.unwrap();
assert_eq!(latest_block.block_number, 1);
assert_eq!(latest_block.l1_gas_price, first_update_gas_price);
assert_eq!(latest_block.l1_data_gas_price, first_update_data_gas_price);
// Second update - generate new block
let second_update_gas_price =
ResourcePrice { price_in_wei: (8e18 as u128).into(), price_in_fri: (6e18 as u128).into() };
let second_update_data_gas_price =
ResourcePrice { price_in_wei: (7e18 as u128).into(), price_in_fri: (5e18 as u128).into() };
let second_update_l2_gas_price = ResourcePrice {
price_in_wei: (7.5e18 as u128).into(),
price_in_fri: (6.5e18 as u128).into(),
};
let gas_price = json!({
"gas_price_wei": felt_to_u128(second_update_gas_price.price_in_wei),
"data_gas_price_wei": felt_to_u128(second_update_data_gas_price.price_in_wei),
"l2_gas_price_wei": felt_to_u128(second_update_l2_gas_price.price_in_wei),
"gas_price_fri": felt_to_u128(second_update_gas_price.price_in_fri),
"data_gas_price_fri": felt_to_u128(second_update_data_gas_price.price_in_fri),
"l2_gas_price_fri": felt_to_u128(second_update_l2_gas_price.price_in_fri),
});
let gas_response = devnet.set_gas_price(&gas_price, true).await.unwrap();
assert_eq!(gas_response, gas_price);
let latest_block = devnet.get_latest_block_with_txs().await.unwrap();
assert_eq!(latest_block.block_number, 2);
assert_eq!(latest_block.l1_gas_price, second_update_gas_price);
assert_eq!(latest_block.l1_data_gas_price, second_update_data_gas_price);
assert_eq!(latest_block.l2_gas_price, second_update_l2_gas_price);
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
assert_eq!(pre_confirmed_block.l1_gas_price, second_update_gas_price);
assert_eq!(pre_confirmed_block.l1_data_gas_price, second_update_data_gas_price);
assert_eq!(pre_confirmed_block.l2_gas_price, second_update_l2_gas_price);
}
#[tokio::test]
async fn unsuccessful_declare_set_gas_successful_declare() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let predeployed_account = Arc::new(SingleOwnerAccount::new(
devnet.clone_provider(),
signer.clone(),
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
));
let (contract_class, casm_class_hash) = get_simple_contract_artifacts();
let shared_class = Arc::new(contract_class);
let l1_gas = 0;
let l1_data_gas = 1000;
// used l2 gas (pre-calculated, must be at least this, otherwise insufficient resources): 4.3e7
let l2_gas = 1.1e12 as u64; // l2_balance (1e21) / l2_price (1e9) + a bit to exceed balance
let unsuccessful_declare_tx = predeployed_account
.declare_v3(shared_class.clone(), casm_class_hash)
.l1_gas(l1_gas)
.l1_data_gas(l1_data_gas)
.l2_gas(l2_gas)
.send()
.await;
match unsuccessful_declare_tx {
Err(AccountError::Provider(ProviderError::StarknetError(
StarknetError::InsufficientAccountBalance,
))) => (),
other => panic!("Unexpected result: {other:?}"),
};
let new_l2_fri_price = 9e7 as u128; // approximate upper limit that will pass
let gas_price = json!({ "l2_gas_price_fri": new_l2_fri_price });
let gas_response = devnet.set_gas_price(&gas_price, true).await.unwrap();
assert_eq!(gas_response["l2_gas_price_fri"], json!(new_l2_fri_price));
let latest_block = devnet.get_latest_block_with_txs().await.unwrap();
assert_eq!(latest_block.block_number, 1);
let pre_confirmed_block = devnet.get_pre_confirmed_block_with_tx_hashes().await.unwrap();
assert_eq!(
pre_confirmed_block.l1_gas_price,
ResourcePrice {
price_in_wei: u128::from(DEVNET_DEFAULT_L1_GAS_PRICE).into(),
price_in_fri: u128::from(DEVNET_DEFAULT_L1_GAS_PRICE).into()
}
);
assert_eq!(
pre_confirmed_block.l1_data_gas_price,
ResourcePrice {
price_in_wei: u128::from(DEVNET_DEFAULT_L1_DATA_GAS_PRICE).into(),
price_in_fri: u128::from(DEVNET_DEFAULT_L1_DATA_GAS_PRICE).into()
}
);
assert_eq!(
pre_confirmed_block.l2_gas_price,
ResourcePrice {
price_in_wei: u128::from(DEVNET_DEFAULT_L2_GAS_PRICE).into(),
price_in_fri: new_l2_fri_price.into()
}
);
let successful_declare_tx = predeployed_account
.declare_v3(shared_class, casm_class_hash)
.l1_gas(l1_gas)
.l1_data_gas(l1_data_gas)
.l2_gas(l2_gas)
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&successful_declare_tx.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn set_gas_optional_parameters() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let latest_block = devnet.get_latest_block_with_txs().await.unwrap();
assert_eq!(
latest_block.l1_gas_price,
ResourcePrice {
price_in_wei: (u128::from(DEVNET_DEFAULT_L1_GAS_PRICE)).into(),
price_in_fri: (u128::from(DEVNET_DEFAULT_L1_GAS_PRICE)).into(),
}
);
// set nothing, get initial gas information and assert
let gas_response = devnet.set_gas_price(&json!({}), false).await.unwrap();
assert_eq!(
gas_response,
json!({
"gas_price_wei": DEVNET_DEFAULT_L1_GAS_PRICE,
"data_gas_price_wei": DEVNET_DEFAULT_L1_GAS_PRICE,
"l2_gas_price_wei": DEVNET_DEFAULT_L2_GAS_PRICE,
"gas_price_fri": DEVNET_DEFAULT_L1_GAS_PRICE,
"data_gas_price_fri": DEVNET_DEFAULT_L1_GAS_PRICE,
"l2_gas_price_fri": DEVNET_DEFAULT_L2_GAS_PRICE,
})
);
let expected_final_gas_price = json!({
"gas_price_wei": 9e18 as u128,
"data_gas_price_wei": 8e18 as u128,
"l2_gas_price_wei": 7.5e18 as u128,
"gas_price_fri": 7e18 as u128,
"data_gas_price_fri": 6e18 as u128,
"l2_gas_price_fri": 5.5e18 as u128,
});
for (gas_prop, gas_price) in expected_final_gas_price.as_object().unwrap() {
// Construct the JSON request dynamically based on the parameter
let optional_gas_request = json!({ gas_prop: gas_price });
let gas_response = devnet.set_gas_price(&optional_gas_request, true).await.unwrap();
assert_eq!(&gas_response[gas_prop], gas_price);
}
// set nothing, get final gas information and assert
let gas_response = devnet.set_gas_price(&json!({}), false).await.unwrap();
assert_eq!(gas_response, expected_final_gas_price);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/test_subscription_to_tx_status.rs | tests/integration/test_subscription_to_tx_status.rs | use serde_json::json;
use starknet_rs_core::types::{BlockId, Felt};
use tokio::net::TcpStream;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, connect_async};
use crate::assert_eq_prop;
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::utils::{
SubscriptionId, assert_no_notifications, receive_rpc_via_ws, subscribe, subscribe_new_heads,
unsubscribe,
};
async fn subscribe_tx_status(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
tx_hash: &Felt,
) -> Result<SubscriptionId, anyhow::Error> {
subscribe(ws, "starknet_subscribeTransactionStatus", json!({ "transaction_hash": tx_hash }))
.await
}
/// Returns (address, amount, tx_hash), with tx_hash being the hash of the minting tx if it's
/// the first thing done on a fresh Devnet using the returned `address` and `amount`.
fn first_mint_data() -> (Felt, u128, Felt) {
let expected_tx_hash = Felt::from_hex_unchecked(
"0x40c9808b4812c58bcd71323527ead6a3f74c802fd3ded08b9653f2e19a67f11",
);
(Felt::ONE, 10, expected_tx_hash)
}
fn assert_mint_notification_succeeded(
notification: serde_json::Value,
tx_hash: Felt,
subscription_id: SubscriptionId,
expected_finality_status: &str,
) -> Result<(), anyhow::Error> {
let expected_resp = json!({
"jsonrpc": "2.0",
"method": "starknet_subscriptionTransactionStatus",
"params": {
"result": {
"transaction_hash": tx_hash,
"status": {
"finality_status": expected_finality_status,
"failure_reason": null,
"execution_status": "SUCCEEDED",
},
},
"subscription_id": subscription_id,
}
});
assert_eq_prop!(notification, expected_resp)
}
#[tokio::test]
async fn subscribe_to_new_tx_status_happy_path() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (address, mint_amount, expected_tx_hash) = first_mint_data();
let subscription_id = subscribe_tx_status(&mut ws, &expected_tx_hash).await.unwrap();
let tx_hash = devnet.mint(address, mint_amount).await;
assert_eq!(tx_hash, expected_tx_hash);
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_mint_notification_succeeded(notification, tx_hash, subscription_id, "ACCEPTED_ON_L2")
.unwrap();
}
#[tokio::test]
async fn should_stop_notifying_after_unsubscription() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (address, mint_amount, expected_tx_hash) = first_mint_data();
// subscribe and immediately unsubscribe
let subscription_id = subscribe_tx_status(&mut ws, &expected_tx_hash).await.unwrap();
let unsubscription = unsubscribe(&mut ws, subscription_id).await.unwrap();
assert_eq!(unsubscription, json!({ "jsonrpc": "2.0", "id": 0, "result": true }));
devnet.mint(address, mint_amount).await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_receive_notification_if_not_subscribed() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
devnet.mint(0x1, 1).await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_receive_notification_if_subscribed_to_another_tx() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let dummy_tx_hash = Felt::ONE;
subscribe_tx_status(&mut ws, &dummy_tx_hash).await.unwrap();
let (address, mint_amount, expected_tx_hash) = first_mint_data();
let tx_hash = devnet.mint(address, mint_amount).await;
assert_eq!(tx_hash, expected_tx_hash);
assert_ne!(tx_hash, dummy_tx_hash);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_receive_tx_notification_if_subscribed_to_blocks() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
subscribe_new_heads(&mut ws, json!({})).await.unwrap();
devnet.mint(0x1, 1).await;
// there should only be a single new block notification since minting is a block-adding tx
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_eq!(notification["method"], "starknet_subscriptionNewHeads");
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_receive_block_notification_if_subscribed_to_tx() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
subscribe_tx_status(&mut ws, &Felt::ONE).await.unwrap();
devnet.create_block().await.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
async fn should_notify_if_subscribed_before_and_after_tx(
devnet: &BackgroundDevnet,
ws_before_tx: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
ws_after_tx: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
expected_finality_status: &str,
) -> Result<(Felt, String, String), anyhow::Error> {
let (address, mint_amount, expected_tx_hash) = first_mint_data();
// should work if subscribing before sending the tx
let subscription_id_before = subscribe_tx_status(ws_before_tx, &expected_tx_hash).await?;
let tx_hash = devnet.mint(address, mint_amount).await;
assert_eq_prop!(tx_hash, expected_tx_hash)?;
{
let notification = receive_rpc_via_ws(ws_before_tx).await.unwrap();
assert_mint_notification_succeeded(
notification,
tx_hash,
subscription_id_before.clone(),
expected_finality_status,
)?;
assert_no_notifications(ws_before_tx).await?;
}
// should work even if subscribing after the tx was sent
let subscription_id_after = subscribe_tx_status(ws_after_tx, &expected_tx_hash).await?;
{
let notification = receive_rpc_via_ws(ws_after_tx).await?;
assert_mint_notification_succeeded(
notification,
tx_hash,
subscription_id_after.clone(),
expected_finality_status,
)?;
assert_no_notifications(ws_after_tx).await?;
}
Ok((tx_hash, subscription_id_before, subscription_id_after))
}
#[tokio::test]
async fn should_notify_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws_before_tx, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut ws_after_tx, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mint_tx_hash, subscription_id_before, subscription_id_after) =
should_notify_if_subscribed_before_and_after_tx(
&devnet,
&mut ws_before_tx,
&mut ws_after_tx,
"PRE_CONFIRMED",
)
.await
.unwrap();
// Creating a new block should make txs go: PRE_CONFIRMED->ACCEPTED_ON_L2
devnet.create_block().await.unwrap();
for (mut ws, subscription_id) in
[(ws_before_tx, subscription_id_before), (ws_after_tx, subscription_id_after)]
{
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_mint_notification_succeeded(
notification,
mint_tx_hash,
subscription_id,
"ACCEPTED_ON_L2",
)
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
}
}
#[tokio::test]
async fn should_notify_only_once_in_on_demand_mode() {
let devnet_args = ["--block-generation-on", "demand"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (address, mint_amount, expected_tx_hash) = first_mint_data();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let subscription_id = subscribe_tx_status(&mut ws, &expected_tx_hash).await.unwrap();
let tx_hash = devnet.mint(address, mint_amount).await;
assert_eq!(tx_hash, expected_tx_hash);
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_mint_notification_succeeded(notification, tx_hash, subscription_id, "PRE_CONFIRMED")
.unwrap();
assert_no_notifications(&mut ws).await.unwrap();
let another_tx_hash = devnet.mint(address, mint_amount).await;
assert_ne!(another_tx_hash, tx_hash);
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_in_on_transaction_mode() {
let devnet_args = ["--block-generation-on", "transaction"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws_before_tx, _) = connect_async(devnet.ws_url()).await.unwrap();
let (mut ws_after_tx, _) = connect_async(devnet.ws_url()).await.unwrap();
should_notify_if_subscribed_before_and_after_tx(
&devnet,
&mut ws_before_tx,
&mut ws_after_tx,
"ACCEPTED_ON_L2",
)
.await
.unwrap();
// Expect no new notifications on creating a new empty block
devnet.create_block().await.unwrap();
assert_no_notifications(&mut ws_before_tx).await.unwrap();
assert_no_notifications(&mut ws_after_tx).await.unwrap();
}
#[tokio::test]
async fn should_notify_if_already_in_latest() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// created tx
let (address, mint_amount, _) = first_mint_data();
let tx_hash = devnet.mint(address, mint_amount).await;
let subscription_id = subscribe_tx_status(&mut ws, &tx_hash).await.unwrap();
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_mint_notification_succeeded(notification, tx_hash, subscription_id, "ACCEPTED_ON_L2")
.unwrap();
devnet.mint(address, mint_amount).await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_notify_if_already_in_an_old_block() {
let devnet = BackgroundDevnet::spawn().await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
// created tx
let (address, mint_amount, _) = first_mint_data();
let tx_hash = devnet.mint(address, mint_amount).await;
// push back the block with the tx
devnet.create_block().await.unwrap();
devnet.create_block().await.unwrap();
let subscription_id = subscribe_tx_status(&mut ws, &tx_hash).await.unwrap();
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_mint_notification_succeeded(notification, tx_hash, subscription_id, "ACCEPTED_ON_L2")
.unwrap();
devnet.mint(address, mint_amount).await;
assert_no_notifications(&mut ws).await.unwrap();
}
#[tokio::test]
async fn should_not_notify_of_status_change_when_block_aborted() {
let devnet_args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
let (mut ws, _) = connect_async(devnet.ws_url()).await.unwrap();
let (address, amount, _) = first_mint_data();
let tx_hash = devnet.mint(address, amount).await;
let subscription_id = subscribe_tx_status(&mut ws, &tx_hash).await.unwrap();
// as expected, the actual tx accepted notification is first
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_mint_notification_succeeded(notification, tx_hash, subscription_id, "ACCEPTED_ON_L2")
.unwrap();
devnet.abort_blocks(&BlockId::Number(1)).await.unwrap();
// only expect reorg subscription
let notification = receive_rpc_via_ws(&mut ws).await.unwrap();
assert_eq!(notification["method"], "starknet_subscriptionReorg");
assert_no_notifications(&mut ws).await.unwrap();
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/get_transaction_by_hash.rs | tests/integration/get_transaction_by_hash.rs | use std::sync::Arc;
use starknet_rs_accounts::{
Account, AccountFactory, ExecutionEncoding, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_core::types::{BlockId, BlockTag, Call, Felt, StarknetError};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::{Provider, ProviderError};
use crate::common::background_devnet::BackgroundDevnet;
use crate::common::constants::{
self, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, ETH_ERC20_CONTRACT_ADDRESS,
};
use crate::common::utils::{
assert_tx_succeeded_accepted, get_deployable_account_signer, get_simple_contract_artifacts,
};
#[tokio::test]
async fn get_declare_v3_transaction_by_hash_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let (signer, address) = devnet.get_first_predeployed_account().await;
let mut account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
address,
constants::CHAIN_ID,
ExecutionEncoding::Legacy,
);
account.set_block_id(BlockId::Tag(BlockTag::Latest));
let declare_result = account
.declare_v3(Arc::new(contract_class), casm_hash)
.nonce(Felt::ZERO)
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&declare_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn get_deploy_account_transaction_by_hash_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let signer = get_deployable_account_signer();
let factory = OpenZeppelinAccountFactory::new(
Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH),
constants::CHAIN_ID,
signer,
devnet.clone_provider(),
)
.await
.unwrap();
let salt = Felt::from_hex_unchecked("0x123");
let deployment = factory.deploy_v3(salt).gas_estimate_multiplier(1.0);
let deployment_address = deployment.address();
let fee_estimation = deployment.estimate_fee().await.unwrap();
// fund the account before deployment
let mint_amount = fee_estimation.overall_fee * 2;
devnet.mint(deployment_address, mint_amount).await;
let deploy_account_result = deployment.send().await.unwrap();
assert_tx_succeeded_accepted(&deploy_account_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn get_invoke_v3_transaction_by_hash_happy_path() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let (signer, account_address) = devnet.get_first_predeployed_account().await;
let account = SingleOwnerAccount::new(
&devnet.json_rpc_client,
signer,
account_address,
constants::CHAIN_ID,
ExecutionEncoding::New,
);
let invoke_tx_result = account
.execute_v3(vec![Call {
to: ETH_ERC20_CONTRACT_ADDRESS,
selector: get_selector_from_name("transfer").unwrap(),
calldata: vec![
Felt::ONE, // recipient
Felt::from(1_000_000_000), // low part of uint256
Felt::ZERO, // high part of uint256
],
}])
.send()
.await
.unwrap();
assert_tx_succeeded_accepted(&invoke_tx_result.transaction_hash, &devnet.json_rpc_client)
.await
.unwrap();
}
#[tokio::test]
async fn get_non_existing_transaction() {
let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
let result = devnet.json_rpc_client.get_transaction_by_hash(Felt::ZERO).await.unwrap_err();
match result {
ProviderError::StarknetError(StarknetError::TransactionHashNotFound) => (),
_ => panic!("Invalid error: {result:?}"),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/errors.rs | tests/integration/common/errors.rs | use core::fmt;
use std::borrow::Cow;
use serde::{self, Deserialize, Serialize};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum TestError {
#[error("Could not parse URL")]
UrlParseError(#[from] url::ParseError),
#[error("Invalid URI")]
InvalidUri(#[from] axum::http::uri::InvalidUri),
#[error("Could not start Devnet. Make sure you built it with `cargo build --release`: {0}")]
DevnetNotStartable(String),
#[error("Could not start Anvil: {0}")]
AnvilNotStartable(String),
#[error("Alloy error: {0}")]
AlloyError(String),
}
#[derive(Error, Debug)]
pub enum ReqwestError {
#[error(transparent)]
Error(#[from] reqwest::Error),
#[error("Error with message: {message}")]
ErrorWithMessage { error: reqwest::Error, message: String },
}
impl ReqwestError {
pub fn error_message(&self) -> String {
match self {
ReqwestError::Error(_) => "".to_string(),
ReqwestError::ErrorWithMessage { message, .. } => message.clone(),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RpcError {
pub code: i64,
/// error message
pub message: Cow<'static, str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,
}
impl fmt::Display for RpcError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{self:?}")
}
}
impl std::error::Error for RpcError {}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/reqwest_client.rs | tests/integration/common/reqwest_client.rs | use std::any::TypeId;
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::json;
use super::errors::ReqwestError;
#[derive(Clone, Debug)]
pub struct HttpEmptyResponseBody;
#[derive(Clone, Debug)]
pub struct ReqwestClient {
url: String,
reqwest_client: reqwest::Client,
}
impl ReqwestClient {
pub fn new(url: String, reqwest_client: reqwest::Client) -> Self {
Self { url, reqwest_client }
}
async fn get_response<TParam>(
&self,
path: &str,
query: &str,
method: reqwest::Method,
body: TParam,
) -> Result<reqwest::Response, ReqwestError>
where
TParam: Serialize + Send + Sync + 'static,
{
let url = if query.is_empty() {
format!("{}{}", self.url, path)
} else {
format!("{}{}?{}", self.url, path, query)
};
let request_builder = match method {
reqwest::Method::GET => self.reqwest_client.get(&url),
reqwest::Method::POST => self.reqwest_client.post(&url),
_ => panic!("Unsupported method: {:?}", method),
};
if TypeId::of::<TParam>() == TypeId::of::<()>() {
request_builder.json(&json!({})).send().await.map_err(ReqwestError::Error)
} else {
request_builder.json(&body).send().await.map_err(ReqwestError::Error)
}
}
}
#[async_trait::async_trait]
pub trait PostReqwestSender<TParam, TResponse>: Clone + Send + Sync + 'static {
/// Sends a POST request to the devnet with the given path and body (`TParam`) and returns the
/// response
///
/// # Arguments
/// * `path` - The path to send the request to
/// * `body` - The body of the request
///
/// # Returns
/// The response from the devnet in the form of the type `TResponse`
/// If http status is not success it will return a `super::errors::ReqwestError`
async fn post_json_async(&self, path: &str, body: TParam) -> Result<TResponse, ReqwestError>;
}
#[async_trait::async_trait]
impl<TParam, TResponse> PostReqwestSender<TParam, TResponse> for ReqwestClient
where
TParam: Serialize + Send + Sync + 'static,
TResponse: DeserializeOwned + 'static,
{
async fn post_json_async(&self, path: &str, body: TParam) -> Result<TResponse, ReqwestError> {
let response = self.get_response(path, "", reqwest::Method::POST, body).await?;
if response.status().is_success() {
return response.json::<TResponse>().await.map_err(|err| err.into());
} else {
if response.content_length().unwrap_or(0) > 0 {
let error = response.error_for_status_ref().unwrap_err();
let error_message = response.text().await.unwrap();
return Err(ReqwestError::ErrorWithMessage { error, message: error_message });
}
return Err(response.error_for_status().unwrap_err().into());
}
}
}
#[async_trait::async_trait]
impl<TParam> PostReqwestSender<TParam, HttpEmptyResponseBody> for ReqwestClient
where
TParam: Serialize + Send + Sync + 'static,
{
async fn post_json_async(
&self,
path: &str,
body: TParam,
) -> Result<HttpEmptyResponseBody, ReqwestError> {
let response = self.get_response(path, "", reqwest::Method::POST, body).await?;
if response.status().is_success() {
return Ok(HttpEmptyResponseBody {});
} else {
if response.content_length().unwrap_or(0) > 0 {
let error = response.error_for_status_ref().unwrap_err();
let error_message = response.text().await.unwrap();
return Err(ReqwestError::ErrorWithMessage { error, message: error_message });
}
return Err(response.error_for_status().unwrap_err().into());
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/background_anvil.rs | tests/integration/common/background_anvil.rs | use std::process::Command;
use std::str::FromStr;
use std::time;
use alloy::eips::BlockId;
use alloy::primitives::{Address, U256};
use alloy::providers::{Provider, ProviderBuilder};
use alloy::rpc::types::Block;
use alloy::signers::Signer;
use alloy::signers::local::PrivateKeySigner;
use alloy::sol;
use reqwest::StatusCode;
use url::Url;
use super::background_server::get_acquired_port;
use super::constants::{DEFAULT_ANVIL_MNEMONIC_PHRASE, DEFAULT_ETH_ACCOUNT_PRIVATE_KEY, HOST};
use super::errors::TestError;
use super::safe_child::SafeChild;
pub struct BackgroundAnvil {
pub process: SafeChild,
pub url: Url,
pub provider_signer: PrivateKeySigner,
}
sol! {
#[derive(Debug)]
#[sol(rpc)]
L1L2Example,
"../../contracts/l1-l2-artifacts/L1L2Example.json"
}
impl BackgroundAnvil {
pub(crate) async fn spawn() -> Result<Self, TestError> {
Self::spawn_with_additional_args(&[]).await
}
pub(crate) async fn spawn_with_additional_args_and_custom_signer(
args: &[&str],
mnemonic_phrase: &str,
private_key: &str,
) -> Result<Self, TestError> {
let process = Command::new("anvil")
.arg("--port")
.arg("0")
.arg("--mnemonic")
.arg(mnemonic_phrase)
.arg("--silent")
.args(args)
.spawn()
.expect("Could not start background Anvil");
let mut safe_process = SafeChild { process, port: None };
let sleep_time = time::Duration::from_millis(500);
let max_retries = 30;
let port = get_acquired_port(&mut safe_process, sleep_time, max_retries)
.await
.map_err(|e| TestError::AnvilNotStartable(format!("Cannot determine port: {e:?}")))?;
let url: Url = format!("http://{HOST}:{port}").parse()?;
let client = reqwest::Client::new();
for _ in 0..max_retries {
if let Ok(anvil_block_rsp) = send_dummy_request(&client, url.as_str()).await {
assert_eq!(anvil_block_rsp.status(), StatusCode::OK);
println!("Spawned background anvil at {url}");
let chain_id =
ProviderBuilder::new().connect_http(url.clone()).get_chain_id().await.map_err(
|e| TestError::AlloyError(format!("Failed to get chain id: {e}")),
)?;
let provider_signer = PrivateKeySigner::from_str(private_key)
.map_err(|e| TestError::AlloyError(format!("Invalid private key: {e}")))?
.with_chain_id(chain_id.into());
return Ok(Self { process: safe_process, url, provider_signer });
}
tokio::time::sleep(sleep_time).await;
}
Err(TestError::AnvilNotStartable("Not responsive for too long".into()))
}
/// Spawns an instance at random port. Assumes CLI args in `args` don't contain `--port` or
/// mnemonic parameters. Uses the mnemonic phrase defined in constants.
pub(crate) async fn spawn_with_additional_args(args: &[&str]) -> Result<Self, TestError> {
Self::spawn_with_additional_args_and_custom_signer(
args,
DEFAULT_ANVIL_MNEMONIC_PHRASE,
DEFAULT_ETH_ACCOUNT_PRIVATE_KEY,
)
.await
}
pub async fn get_block(self, block: BlockId) -> Result<Block, TestError> {
let provider = ProviderBuilder::new().connect_http(self.url.clone());
provider
.get_block(block)
.await
.map_err(|e| {
TestError::AlloyError(format!(
"Error getting block from anvil at {}: {e}",
self.url
))
})?
.ok_or_else(|| TestError::AlloyError(format!("Block not found at {}", self.url)))
}
pub async fn deploy_l1l2_contract(
&self,
messaging_address: Address,
) -> Result<Address, TestError> {
let provider = ProviderBuilder::new()
.wallet(self.provider_signer.clone())
.connect_http(self.url.clone());
let contract = L1L2Example::deploy(provider, messaging_address).await.map_err(|e| {
TestError::AlloyError(format!("Error deploying l1l2 contract on ethereum: {e}"))
})?;
Ok(*contract.address())
}
pub async fn get_balance_l1l2(&self, address: Address, user: U256) -> Result<U256, TestError> {
let provider = ProviderBuilder::new().connect_http(self.url.clone());
let contract = L1L2Example::new(address, provider);
contract.get_balance(user).call().await.map_err(|e| {
TestError::AlloyError(format!("Error calling l1l2 contract on ethereum: {e}"))
})
}
pub async fn withdraw_l1l2(
&self,
address: Address,
account_address: U256,
user: U256,
amount: U256,
) -> Result<(), TestError> {
let provider = ProviderBuilder::new()
.wallet(self.provider_signer.clone())
.connect_http(self.url.clone());
let contract = L1L2Example::new(address, provider);
let _ = contract
.withdraw(account_address, user, amount)
.send()
.await
.map_err(|e| {
TestError::AlloyError(format!(
"tx for withdrawing from l1-l2 contract on ethereum failed: {e}"
))
})?
.watch()
.await
.map_err(|e| {
TestError::AlloyError(format!(
"Error confirming withdraw transaction from l1-l2 contract on ethereum: {e}"
))
})?;
Ok(())
}
pub async fn deposit_l1l2(
&self,
address: Address,
contract_address: U256,
user: U256,
amount: U256,
) -> Result<(), TestError> {
let provider = ProviderBuilder::new()
.wallet(self.provider_signer.clone())
.connect_http(self.url.clone());
let contract = L1L2Example::new(address, provider);
// The minimum value for messaging is 30k gwei,
// we multiplied by 10 here.
let value = U256::from(300000000000000_u128);
let _ = contract
.deposit(contract_address, user, amount)
.value(value)
.send()
.await
.map_err(|e| {
TestError::AlloyError(format!(
"tx for deposit l1l2 contract on ethereum failed: {e}"
))
})?
.watch()
.await
.map_err(|e| {
TestError::AlloyError(format!(
"Error confirming deposit l1l2 contract on ethereum: {e}"
))
})?;
Ok(())
}
}
/// Even if the RPC method is dummy (doesn't exist),
/// the server is expected to respond properly if alive
async fn send_dummy_request(
client: &reqwest::Client,
rpc_url: &str,
) -> Result<reqwest::Response, reqwest::Error> {
client
.post(rpc_url)
.json(&serde_json::json!({
"jsonrpc": "2.0",
"method": "eth_blockNumberfuiorhgorueh",
"params": [],
"id": "1"
}))
.send()
.await
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/background_server.rs | tests/integration/common/background_server.rs | use std::time;
use super::safe_child::SafeChild;
pub(crate) async fn get_acquired_port(
process: &mut SafeChild,
sleep_time: time::Duration,
max_retries: usize,
) -> Result<u16, anyhow::Error> {
let pid = process.id();
for _ in 0..max_retries {
if let Ok(ports) = listeners::get_ports_by_pid(pid) {
if ports.len() == 1 {
return Ok(ports.into_iter().next().unwrap());
}
}
if let Ok(Some(status)) = process.process.try_wait() {
return Err(anyhow::anyhow!("Background server process exited with status {status}"));
}
tokio::time::sleep(sleep_time).await;
}
Err(anyhow::anyhow!("Could not identify a unique port used by PID {pid}"))
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/utils.rs | tests/integration/common/utils.rs | use std::fmt::{Debug, LowerHex};
use std::fs;
use std::path::Path;
use std::process::{Child, Command};
use std::sync::Arc;
use std::time::Duration;
use alloy::primitives::U256;
use futures::{SinkExt, StreamExt, TryStreamExt};
use rand::{Rng, rng};
use serde_json::json;
use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
use starknet_core::CasmContractClass;
use starknet_rs_accounts::{
Account, AccountFactory, ArgentAccountFactory, OpenZeppelinAccountFactory, SingleOwnerAccount,
};
use starknet_rs_contract::{ContractFactory, UdcSelector};
use starknet_rs_core::types::contract::SierraClass;
use starknet_rs_core::types::{
BlockId, BlockTag, ContractClass, ContractExecutionError, DeployAccountTransactionResult,
ExecutionResult, FeeEstimate, Felt, FlattenedSierraClass, FunctionCall,
InnerContractExecutionError, ResourceBounds, ResourceBoundsMapping, TransactionReceipt,
};
use starknet_rs_core::utils::{
UdcUniqueSettings, get_selector_from_name, get_udc_deployed_address,
};
use starknet_rs_providers::jsonrpc::{
HttpTransport, HttpTransportError, JsonRpcClientError, JsonRpcError,
};
use starknet_rs_providers::{JsonRpcClient, Provider, ProviderError};
use starknet_rs_signers::LocalWallet;
use tokio::net::TcpStream;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
use super::background_devnet::BackgroundDevnet;
use super::constants::{
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, CAIRO_1_CONTRACT_PATH, UDC_CONTRACT_ADDRESS,
};
use super::safe_child::SafeChild;
use crate::common::errors::RpcError;
use crate::{assert_eq_prop, assert_ne_prop};
pub enum ImpersonationAction {
ImpersonateAccount(Felt),
StopImpersonateAccount(Felt),
AutoImpersonate,
StopAutoImpersonate,
}
/// dummy testing value
pub fn get_deployable_account_signer() -> LocalWallet {
let new_account_private_key = "0xc248668388dbe9acdfa3bc734cc2d57a";
starknet_rs_signers::LocalWallet::from(starknet_rs_signers::SigningKey::from_secret_scalar(
Felt::from_hex_unchecked(new_account_private_key),
))
}
pub fn remove_file(path: &str) {
let file_path = Path::new(path);
if file_path.exists() {
fs::remove_file(file_path).expect("Could not remove file");
}
}
pub type SierraWithCasmHash = (FlattenedSierraClass, Felt);
pub fn get_flattened_sierra_contract_and_casm_hash(sierra_path: &str) -> SierraWithCasmHash {
let sierra_string = std::fs::read_to_string(sierra_path).unwrap();
let sierra_class: SierraClass = serde_json::from_str(&sierra_string).unwrap();
let casm_json = usc::compile_contract(serde_json::from_str(&sierra_string).unwrap()).unwrap();
let casm_hash =
serde_json::from_value::<CasmContractClass>(casm_json).unwrap().hash(&HashVersion::V2).0;
(sierra_class.flatten().unwrap(), casm_hash)
}
pub fn get_messaging_contract_artifacts() -> SierraWithCasmHash {
let sierra_path = "../../contracts/l1-l2-artifacts/cairo_l1_l2.contract_class.sierra";
get_flattened_sierra_contract_and_casm_hash(sierra_path)
}
pub fn get_messaging_lib_artifacts() -> SierraWithCasmHash {
let sierra_path = "../../contracts/l1-l2-artifacts/cairo_l1_l2_lib.contract_class.sierra";
get_flattened_sierra_contract_and_casm_hash(sierra_path)
}
pub fn get_events_contract_artifacts() -> SierraWithCasmHash {
let events_sierra_path =
"../../contracts/test_artifacts/cairo1/events/events_2.0.1_compiler.sierra";
get_flattened_sierra_contract_and_casm_hash(events_sierra_path)
}
pub fn get_block_reader_contract_artifacts() -> SierraWithCasmHash {
let timestamp_sierra_path =
"../../contracts/test_artifacts/cairo1/block_reader/block_reader.sierra";
get_flattened_sierra_contract_and_casm_hash(timestamp_sierra_path)
}
pub fn get_simple_contract_artifacts() -> SierraWithCasmHash {
get_flattened_sierra_contract_and_casm_hash(CAIRO_1_CONTRACT_PATH)
}
pub fn get_timestamp_asserter_contract_artifacts() -> SierraWithCasmHash {
get_flattened_sierra_contract_and_casm_hash(
"../../contracts/test_artifacts/cairo1/timestamp_asserter/target/dev/\
cairo_TimestampAsserter.contract_class.json",
)
}
pub async fn assert_tx_succeeded_accepted<T: Provider>(
tx_hash: &Felt,
client: &T,
) -> Result<(), anyhow::Error> {
let receipt = client.get_transaction_receipt(tx_hash).await?.receipt;
match receipt.execution_result() {
ExecutionResult::Succeeded => (),
other => anyhow::bail!("Tx {tx_hash:#x} should have succeeded; got: {other:?}"),
}
match receipt.finality_status() {
starknet_rs_core::types::TransactionFinalityStatus::AcceptedOnL2 => Ok(()),
other => anyhow::bail!("Tx {tx_hash:#x} should have been accepted on L2; got: {other:?}"),
}
}
pub async fn assert_tx_succeeded_pre_confirmed<T: Provider>(
tx_hash: &Felt,
client: &T,
) -> Result<(), anyhow::Error> {
let receipt = client.get_transaction_receipt(tx_hash).await.unwrap().receipt;
match receipt.execution_result() {
ExecutionResult::Succeeded => (),
other => panic!("Should have succeeded; got: {other:?}"),
}
match receipt.finality_status() {
starknet_rs_core::types::TransactionFinalityStatus::PreConfirmed => (),
other => panic!("Should have been pre-confirmed; got: {other:?}"),
}
Ok(())
}
pub async fn get_contract_balance(
devnet: &BackgroundDevnet,
contract_address: Felt,
) -> Result<Felt, anyhow::Error> {
get_contract_balance_by_block_id(devnet, contract_address, BlockId::Tag(BlockTag::Latest)).await
}
pub async fn get_contract_balance_by_block_id(
devnet: &BackgroundDevnet,
contract_address: Felt,
block_id: BlockId,
) -> Result<Felt, anyhow::Error> {
let contract_call = FunctionCall {
contract_address,
entry_point_selector: get_selector_from_name("get_balance").unwrap(),
calldata: vec![],
};
match devnet.json_rpc_client.call(contract_call, block_id).await {
Ok(res) if res.len() == 1 => Ok(res[0]),
other => anyhow::bail!("Expected a single-felt result; got: {other:?}"),
}
}
pub async fn assert_tx_reverted<T: Provider>(
tx_hash: &Felt,
client: &T,
expected_failure_reasons: &[&str],
) -> Result<(), anyhow::Error> {
let receipt: TransactionReceipt = client.get_transaction_receipt(tx_hash).await?.receipt;
match receipt.execution_result() {
ExecutionResult::Reverted { reason } => {
for expected_reason in expected_failure_reasons {
assert_contains(reason, expected_reason)?
}
Ok(())
}
other => anyhow::bail!("Should have reverted; got: {other:?}; receipt: {receipt:?}"),
}
}
pub fn to_hex_felt<T: LowerHex>(value: &T) -> String {
format!("{value:#x}")
}
pub fn to_num_as_hex<T: LowerHex>(value: &T) -> String {
format!("{value:#x}")
}
pub fn iter_to_hex_felt<T: LowerHex>(iterable: &[T]) -> Vec<String> {
iterable.iter().map(to_hex_felt).collect()
}
pub fn get_unix_timestamp_as_seconds() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("should get current UNIX timestamp")
.as_secs()
}
pub async fn send_ctrl_c_signal_and_wait(process: &SafeChild) {
send_ctrl_c_signal(&process.process).await;
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
async fn send_ctrl_c_signal(process: &Child) {
#[cfg(windows)]
{
// To send SIGINT signal on windows, windows-kill is needed
let mut kill = Command::new("windows-kill")
.args(["-SIGINT", process.id().to_string().as_str()])
.spawn()
.unwrap();
kill.wait().unwrap();
}
#[cfg(unix)]
{
let mut kill = Command::new("kill")
.args(["-s", "SIGINT", process.id().to_string().as_str()])
.spawn()
.unwrap();
kill.wait().unwrap();
}
}
fn take_abi_from_json(value: &mut serde_json::Value) -> Result<serde_json::Value, anyhow::Error> {
let abi_jsonified = value["abi"].take();
let json_null = serde_json::json!(null);
assert_ne_prop!(abi_jsonified, json_null)?;
Ok(serde_json::from_str(abi_jsonified.as_str().unwrap())?)
}
/// Handles differences in abi serialization (some might contain spaces between properties, some
/// not) Comparing the ABIs separately as JSON-parsed values.
pub fn assert_cairo1_classes_equal(
class_a: &ContractClass,
class_b: &ContractClass,
) -> Result<(), anyhow::Error> {
let mut class_a_jsonified = serde_json::to_value(class_a)?;
let mut class_b_jsonified = serde_json::to_value(class_b)?;
let abi_a = take_abi_from_json(&mut class_a_jsonified)?;
let abi_b = take_abi_from_json(&mut class_b_jsonified)?;
assert_eq_prop!(class_a_jsonified, class_b_jsonified)?;
assert_eq_prop!(abi_a, abi_b)
}
/// Wrapper of file name which attempts to delete the file when the variable is dropped.
/// Appends a random sequence to the file name base to make it unique.
/// Prevents name collisions - no need to come up with unique names for files (e.g. when dumping).
/// Automatically deletes the underlying file when the variable is dropped - no need to remember
/// deleting.
pub struct UniqueAutoDeletableFile {
pub path: String,
}
impl UniqueAutoDeletableFile {
/// Appends a random sequence to the name_base to make it unique
/// Unlike [NamedTempFile](https://docs.rs/tempfile/latest/tempfile/struct.NamedTempFile.html),
/// it doesn't create the file.
pub fn new(name_base: &str) -> Self {
// generate two random numbers to increase uniqueness
let mut rand_gen = rng();
let rand = format!("{}{}", rand_gen.random::<u32>(), rand_gen.random::<u32>());
Self { path: format!("{name_base}-{}", rand) }
}
}
impl Drop for UniqueAutoDeletableFile {
fn drop(&mut self) {
remove_file(&self.path)
}
}
/// Deploys an instance of the class whose sierra hash is provided as `class_hash`. Uses a v3 invoke
/// transaction. Returns the address of the newly deployed contract.
pub async fn deploy_v3(
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
class_hash: Felt,
ctor_args: &[Felt],
) -> Result<Felt, anyhow::Error> {
let contract_factory = new_contract_factory(class_hash, account);
contract_factory.deploy_v3(ctor_args.to_vec(), Felt::ZERO, true).send().await?;
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
Felt::ZERO,
class_hash,
&starknet_rs_core::utils::UdcUniqueness::Unique(UdcUniqueSettings {
deployer_address: account.address(),
udc_contract_address: UDC_CONTRACT_ADDRESS,
}),
ctor_args,
);
Ok(contract_address)
}
/// Declares and deploys a Cairo 1 contract; returns class hash and contract address
pub async fn declare_v3_deploy_v3(
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
contract_class: FlattenedSierraClass,
casm_hash: Felt,
ctor_args: &[Felt],
) -> Result<(Felt, Felt), anyhow::Error> {
let salt = Felt::ZERO;
let declaration_result = account.declare_v3(Arc::new(contract_class), casm_hash).send().await?;
// deploy the contract
let contract_factory = new_contract_factory(declaration_result.class_hash, account);
contract_factory.deploy_v3(ctor_args.to_vec(), salt, false).send().await?;
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
salt,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
ctor_args,
);
Ok((declaration_result.class_hash, contract_address))
}
pub async fn declare_deploy_simple_contract(
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
) -> Result<(Felt, Felt), anyhow::Error> {
let (contract_class, casm_hash) = get_simple_contract_artifacts();
let declaration_result = account
.declare_v3(Arc::new(contract_class), casm_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await?;
// deploy the contract
let salt = Felt::ZERO;
let ctor_args = [Felt::ONE];
let contract_factory = new_contract_factory(declaration_result.class_hash, account);
contract_factory
.deploy_v3(ctor_args.to_vec(), salt, false)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e7 as u64)
.send()
.await?;
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
salt,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&ctor_args,
);
Ok((declaration_result.class_hash, contract_address))
}
/// Returns deployment address.
pub async fn declare_deploy_events_contract(
account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
) -> Result<Felt, anyhow::Error> {
let (contract_class, casm_hash) = get_events_contract_artifacts();
let declaration_result = account
.declare_v3(Arc::new(contract_class), casm_hash)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await?;
// deploy the contract
let salt = Felt::ZERO;
let ctor_args = [];
let contract_factory = new_contract_factory(declaration_result.class_hash, account);
contract_factory
.deploy_v3(ctor_args.to_vec(), salt, false)
.l1_gas(0)
.l1_data_gas(1000)
.l2_gas(1e8 as u64)
.send()
.await?;
// generate the address of the newly deployed contract
let contract_address = get_udc_deployed_address(
salt,
declaration_result.class_hash,
&starknet_rs_core::utils::UdcUniqueness::NotUnique,
&ctor_args,
);
Ok(contract_address)
}
/// Assumes the Cairo1 OpenZepplin contract is declared in the target network.
pub async fn deploy_oz_account(
devnet: &BackgroundDevnet,
) -> Result<(DeployAccountTransactionResult, LocalWallet), anyhow::Error> {
let signer = get_deployable_account_signer();
let salt = Felt::THREE;
let factory = OpenZeppelinAccountFactory::new(
Felt::from_hex(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH)?,
devnet.json_rpc_client.chain_id().await?,
signer.clone(),
devnet.clone_provider(),
)
.await?;
let deployment = factory.deploy_v3(salt);
let account_address = deployment.address();
devnet.mint(account_address, u128::MAX).await;
let deployment_result = deployment.send().await?;
Ok((deployment_result, signer))
}
/// Assumes the Argent account contract is declared in the target network.
pub async fn deploy_argent_account(
devnet: &BackgroundDevnet,
class_hash: Felt,
) -> Result<(DeployAccountTransactionResult, LocalWallet), anyhow::Error> {
let signer = get_deployable_account_signer();
let salt = Felt::THREE;
let factory = ArgentAccountFactory::new(
class_hash,
devnet.json_rpc_client.chain_id().await?,
None,
signer.clone(),
devnet.clone_provider(),
)
.await?;
let deployment = factory.deploy_v3(salt);
let account_address = deployment.address();
devnet.mint(account_address, u128::MAX).await;
let deployment_result = deployment.send().await?;
Ok((deployment_result, signer))
}
/// Assert that the set of elements of `iterable1` is a subset of the elements of `iterable2` and
/// vice versa.
pub fn assert_equal_elements<T>(iterable1: &[T], iterable2: &[T]) -> Result<(), anyhow::Error>
where
T: PartialEq + Debug,
{
assert_eq_prop!(iterable1.len(), iterable2.len())?;
for el in iterable1 {
if !iterable2.contains(el) {
anyhow::bail!("Element {el:?} from left not found in right");
}
}
Ok(())
}
pub fn felt_to_u256(f: Felt) -> U256 {
U256::from_be_bytes(f.to_bytes_be())
}
/// Unchecked conversion
pub fn felt_to_u128(f: Felt) -> u128 {
let bigint = f.to_bigint();
bigint.try_into().unwrap()
}
/// Helper for extracting JSON RPC error from the provider instance of `ProviderError`.
/// To be used when there are discrepancies between starknet-rs and the target RPC spec.
pub fn extract_json_rpc_error(error: ProviderError) -> Result<JsonRpcError, anyhow::Error> {
match error {
ProviderError::Other(provider_impl_error) => {
let impl_specific_error: &JsonRpcClientError<HttpTransportError> =
provider_impl_error.as_any().downcast_ref().unwrap();
match impl_specific_error {
JsonRpcClientError::JsonRpcError(json_rpc_error) => Ok(json_rpc_error.clone()),
other => {
Err(anyhow::Error::msg(format!("Cannot extract RPC error from: {:?}", other)))
}
}
}
other => Err(anyhow::Error::msg(format!("Cannot extract RPC error from: {:?}", other))),
}
}
pub fn assert_json_rpc_errors_equal(
e1: JsonRpcError,
e2: JsonRpcError,
) -> Result<(), anyhow::Error> {
assert_eq_prop!((e1.code, &e1.message, &e1.data), (e2.code, &e2.message, &e2.data))
}
/// Extract the message that is encapsulated inside the provided error.
pub fn extract_message_error(error: &ContractExecutionError) -> Result<&String, anyhow::Error> {
match error {
ContractExecutionError::Message(msg) => Ok(msg),
other => anyhow::bail!("Unexpected error: {other:?}"),
}
}
/// Extract the error that is nested inside the provided `error`.
pub fn extract_nested_error(
error: &ContractExecutionError,
) -> Result<&InnerContractExecutionError, anyhow::Error> {
match error {
ContractExecutionError::Nested(nested) => Ok(nested),
other => anyhow::bail!("Unexpected error: {other:?}"),
}
}
pub async fn send_text_rpc_via_ws(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
method: &str,
params: serde_json::Value,
) -> Result<serde_json::Value, anyhow::Error> {
let text_body = json!({
"jsonrpc": "2.0",
"id": 0,
"method": method,
"params": params,
})
.to_string();
ws.send(tokio_tungstenite::tungstenite::Message::Text(text_body.into())).await?;
let resp_raw =
ws.next().await.ok_or(anyhow::Error::msg("No response in websocket stream"))??;
let resp_body: serde_json::Value = serde_json::from_slice(&resp_raw.into_data())?;
Ok(resp_body)
}
pub async fn send_binary_rpc_via_ws(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
method: &str,
params: serde_json::Value,
) -> Result<serde_json::Value, anyhow::Error> {
let body = json!({
"jsonrpc": "2.0",
"id": 0,
"method": method,
"params": params,
});
let binary_body = serde_json::to_vec(&body)?;
ws.send(tokio_tungstenite::tungstenite::Message::Binary(binary_body.into())).await?;
let resp_raw =
ws.next().await.ok_or(anyhow::Error::msg("No response in websocket stream"))??;
let resp_body: serde_json::Value = serde_json::from_slice(&resp_raw.into_data())?;
Ok(resp_body)
}
pub type SubscriptionId = String;
pub async fn subscribe(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
subscription_method: &str,
params: serde_json::Value,
) -> Result<SubscriptionId, anyhow::Error> {
let subscription_confirmation = send_text_rpc_via_ws(ws, subscription_method, params).await?;
if let Some(error) = subscription_confirmation.get("error") {
match serde_json::from_value::<RpcError>(error.clone()) {
Ok(rpc_error) => return Err(anyhow::Error::new(rpc_error)),
Err(_) => return Err(anyhow::Error::msg(error.to_string())),
}
}
Ok(subscription_confirmation["result"]
.as_str()
.ok_or(anyhow::Error::msg(format!(
"No ID in subscription response: {subscription_confirmation}"
)))?
.to_string())
}
/// Tries to read from the provided ws stream. To prevent deadlock, waits for a second at most.
pub async fn receive_rpc_via_ws(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
) -> Result<serde_json::Value, anyhow::Error> {
let msg = tokio::time::timeout(Duration::from_secs(1), ws.try_next())
.await??
.ok_or(anyhow::Error::msg("Nothing to read"))?;
Ok(serde_json::from_str(&msg.into_text()?)?)
}
/// Extract `result` from the notification and assert general properties
pub async fn receive_notification(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
method: &str,
expected_subscription_id: SubscriptionId,
) -> Result<serde_json::Value, anyhow::Error> {
let mut notification = receive_rpc_via_ws(ws).await?;
assert_eq_prop!(notification["jsonrpc"], "2.0")?;
assert_eq_prop!(notification["method"], method)?;
let subscription_id = notification["params"]["subscription_id"]
.as_str()
.ok_or(anyhow::Error::msg("No Subscription ID in notification"))?
.to_string();
assert_eq_prop!(subscription_id, expected_subscription_id)?;
Ok(notification["params"]["result"].take())
}
pub async fn assert_no_notifications(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
) -> Result<(), anyhow::Error> {
match receive_rpc_via_ws(ws).await {
Ok(resp) => anyhow::bail!("Expected no notifications; found: {resp}"),
Err(e) if e.to_string().contains("deadline has elapsed") => Ok(()), // expected
Err(e) => anyhow::bail!("Expected to error out due to empty channel; found: {e}"),
}
}
pub async fn subscribe_new_heads(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
block_specifier: serde_json::Value,
) -> Result<SubscriptionId, anyhow::Error> {
subscribe(ws, "starknet_subscribeNewHeads", block_specifier).await
}
pub async fn subscribe_new_txs(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
params: serde_json::Value,
) -> Result<SubscriptionId, anyhow::Error> {
subscribe(ws, "starknet_subscribeNewTransactions", params).await
}
pub async fn receive_new_tx(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
expected_subscription_id: SubscriptionId,
) -> Result<serde_json::Value, anyhow::Error> {
receive_notification(ws, "starknet_subscriptionNewTransaction", expected_subscription_id).await
}
pub async fn unsubscribe(
ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
subscription_id: SubscriptionId,
) -> Result<serde_json::Value, anyhow::Error> {
send_text_rpc_via_ws(ws, "starknet_unsubscribe", json!({ "subscription_id": subscription_id }))
.await
}
pub async fn send_dummy_mint_tx(devnet: &BackgroundDevnet) -> Felt {
devnet.mint(Felt::ONE, 123).await
}
pub fn new_contract_factory<A: Account>(class_hash: Felt, account: A) -> ContractFactory<A> {
ContractFactory::new_with_udc(class_hash, account, UdcSelector::New)
}
#[derive(Debug, Clone, Copy, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum FeeUnit {
Wei,
Fri,
}
#[derive(Clone, Copy)]
pub(crate) struct LocalFee {
pub(crate) l1_gas: u64,
pub(crate) l1_gas_price: u128,
pub(crate) l1_data_gas: u64,
pub(crate) l1_data_gas_price: u128,
pub(crate) l2_gas: u64,
pub(crate) l2_gas_price: u128,
}
impl From<LocalFee> for ResourceBoundsMapping {
fn from(value: LocalFee) -> Self {
ResourceBoundsMapping {
l1_gas: ResourceBounds {
max_amount: value.l1_gas,
max_price_per_unit: value.l1_gas_price,
},
l1_data_gas: ResourceBounds {
max_amount: value.l1_data_gas,
max_price_per_unit: value.l1_data_gas_price,
},
l2_gas: ResourceBounds {
max_amount: value.l2_gas,
max_price_per_unit: value.l2_gas_price,
},
}
}
}
impl From<FeeEstimate> for LocalFee {
fn from(fee: FeeEstimate) -> Self {
LocalFee {
l1_gas: fee.l1_gas_consumed,
l1_gas_price: fee.l1_gas_price,
l1_data_gas: fee.l1_data_gas_consumed,
l1_data_gas_price: fee.l1_data_gas_price,
l2_gas: fee.l2_gas_consumed,
l2_gas_price: fee.l2_gas_price,
}
}
}
/// Panics if `text` does not contain `pattern`
pub fn assert_contains(text: &str, pattern: &str) -> Result<(), anyhow::Error> {
if !text.contains(pattern) {
anyhow::bail!(
"Failed content assertion!
Pattern: '{pattern}'
not present in
Text: '{text}'"
);
}
Ok(())
}
/// Set time and generate a new block
/// Returns the block timestamp of the newly generated block
pub async fn set_time(devnet: &BackgroundDevnet, time: u64) -> u64 {
let resp_body =
devnet.send_custom_rpc("devnet_setTime", json!({ "time": time })).await.unwrap();
resp_body["block_timestamp"].as_u64().unwrap()
}
pub async fn increase_time(devnet: &BackgroundDevnet, time: u64) {
devnet.send_custom_rpc("devnet_increaseTime", json!({ "time": time })).await.unwrap();
}
#[cfg(test)]
mod test_unique_auto_deletable_file {
use std::path::Path;
use crate::common::utils::UniqueAutoDeletableFile;
#[test]
fn test_deleted() {
let file = UniqueAutoDeletableFile::new("foo");
let saved_file_path = file.path.clone();
assert!(!Path::new(&file.path).exists());
std::fs::File::create(&file.path).unwrap();
assert!(Path::new(&file.path).exists());
drop(file);
assert!(!Path::new(&saved_file_path).exists());
}
#[test]
fn test_dropping_successful_if_file_not_created() {
let file = UniqueAutoDeletableFile::new("foo");
drop(file);
// if everything ok, the test should just exit successfully
}
#[test]
fn test_file_names_unique() {
let common_prefix = "foo";
// run it many times to increase the probability of being secure
for _ in 0..1_000_000 {
let file1 = UniqueAutoDeletableFile::new(common_prefix);
let file2 = UniqueAutoDeletableFile::new(common_prefix);
assert_ne!(file1.path, file2.path);
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/mod.rs | tests/integration/common/mod.rs | #![cfg(test)]
#[macro_use]
pub mod assertions;
pub mod background_anvil;
pub mod background_devnet;
mod background_server;
pub mod constants;
pub mod errors;
pub mod fees;
pub mod reqwest_client;
mod safe_child;
pub mod utils;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/safe_child.rs | tests/integration/common/safe_child.rs | use std::process::Child;
#[derive(Debug)]
pub struct SafeChild {
pub process: Child,
pub port: Option<u16>,
}
impl SafeChild {
pub fn id(&self) -> u32 {
self.process.id()
}
}
/// By implementing Drop, we ensure there are no zombie processes in case of early test failure
impl Drop for SafeChild {
fn drop(&mut self) {
self.process.kill().expect("Cannot kill process");
self.process.wait().expect("Should be dead");
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/constants.rs | tests/integration/common/constants.rs | use starknet_rs_core::types::Felt;
pub const HOST: &str = "127.0.0.1";
pub const SEED: usize = 42;
pub const ACCOUNTS: usize = 3;
pub const CHAIN_ID: Felt = starknet_rs_core::chain_id::SEPOLIA;
// Devnet executable info
pub const DEVNET_EXECUTABLE_BINARY_PATH: &str =
concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/release/starknet-devnet");
pub const DEVNET_MANIFEST_PATH: &str =
concat!(env!("CARGO_MANIFEST_DIR"), "/../../crates/starknet-devnet/Cargo.toml");
// URL paths
pub const RPC_PATH: &str = "/rpc";
pub const HEALTHCHECK_PATH: &str = "/is_alive";
pub const WS_PATH: &str = "/ws";
// predeployed account info with seed=42
pub const PREDEPLOYED_ACCOUNT_ADDRESS: &str =
"0x34ba56f92265f0868c57d3fe72ecab144fc96f97954bbbc4252cef8e8a979ba";
// half the default value - sanity check
pub const PREDEPLOYED_ACCOUNT_INITIAL_BALANCE: u128 = 1_000_000_000_000_000_000_000 / 2;
// account classes
pub const CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH: &str =
"0x05b4b537eaa2399e3aa99c4e2e0208ebd6c71bc1467938cd52c798c601e43564";
pub const CAIRO_0_ACCOUNT_CONTRACT_HASH: &str =
"0x4d07e40e93398ed3c76981e72dd1fd22557a78ce36c0515f679e27f0bb5bc5f";
pub const CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH: &str = concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../crates/starknet-devnet-core/contracts/accounts_artifacts/OpenZeppelin/1.0.0/Account.\
cairo/Account.sierra"
);
pub const CAIRO_1_ACCOUNT_CONTRACT_0_8_0_SIERRA_PATH: &str = concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../crates/starknet-devnet-core/contracts/accounts_artifacts/OpenZeppelin/0.8.0/Account.\
cairo/Account.sierra"
);
// system contracts
pub const ETH_ERC20_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7");
pub const ETH_ERC20_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x9524a94b41c4440a16fd96d7c1ef6ad6f44c1c013e96662734502cd4ee9b1f");
pub const STRK_ERC20_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x76791ef97c042f81fbf352ad95f39a22554ee8d7927b2ce3c681f3418b5206a");
pub const STRK_ERC20_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d");
pub const UDC_LEGACY_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x41A78E741E5AF2FEC34B695679BC6891742439F7AFB8484ECD7766661AD02BF");
pub const UDC_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x02ceed65a4bd731034c01113685c831b01c15d7d432f71afb1cf1634b53a2125");
// Example contract with basic storage read and write - Cairo 1
pub const CAIRO_1_CONTRACT_PATH: &str =
"../../contracts/test_artifacts/cairo1/simple_contract/output.sierra";
// Simple contract with a failable (panicking) function
pub const CAIRO_1_PANICKING_CONTRACT_SIERRA_PATH: &str =
"../../contracts/test_artifacts/cairo1/panicking_contract/panicking_contract.sierra";
pub const TOO_BIG_CONTRACT_SIERRA_PATH: &str =
"../../contracts/test_artifacts/cairo1/too_big/too_big.sierra";
// Contract which asserts the tx version
pub const CAIRO_1_VERSION_ASSERTER_SIERRA_PATH: &str =
"../../contracts/test_artifacts/cairo1/version_asserter/version_asserter.sierra";
// L1 L2 pre-registered addresses.
/// Hardcoded in the cairo0 l1l2 contract
pub const MESSAGING_WHITELISTED_L1_CONTRACT: &str = "0x8359e4b0152ed5a731162d3c7b0d8d56edb165a0";
pub const L1_HANDLER_SELECTOR: &str =
"0xc73f681176fc7b3f9693986fd7b14581e8d540519e27400e88b8713932be01";
pub const MESSAGING_L2_CONTRACT_ADDRESS: &str =
"0x4db0679c568e6a9df6f21da9e243772853d6714b12b6b79c0551d9ea12ef91a";
pub const MESSAGING_L1_CONTRACT_ADDRESS: &str = "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512";
/// Cairo 1 account which panics on validation
pub const INVALID_ACCOUNT_SIERRA_PATH: &str =
"../../contracts/test_artifacts/cairo1/invalid_account/invalid_account.sierra";
/// Argent v0.4.0
pub const ARGENT_ACCOUNT_CLASS_HASH: &str =
"0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f";
// Forking
pub const INTEGRATION_SEPOLIA_HTTP_URL: &str =
"http://rpc.pathfinder.equilibrium.co/integration-sepolia/rpc/v0_10";
pub const MAINNET_URL: &str = "http://rpc.pathfinder.equilibrium.co/mainnet/rpc/v0_10";
pub const MAINNET_HTTPS_URL: &str = "https://rpc.pathfinder.equilibrium.co/mainnet/rpc/v0_10";
pub const INTEGRATION_GENESIS_BLOCK_HASH: &str =
"0x19f675d3fb226821493a6ab9a1955e384bba80f130de625621a418e9a7c0ca3";
/// The number of the last block at which forking can be done; prior to v0.13.4.
pub const INTEGRATION_SAFE_BLOCK: u64 = 64718;
// copied from starknet-rs, because it is not exposed as public type
pub const QUERY_VERSION_OFFSET: Felt =
Felt::from_raw([576460752142434320, 18446744073709551584, 17407, 18446744073700081665]);
pub const DEFAULT_ANVIL_MNEMONIC_PHRASE: &str =
"test test test test test test test test test test test junk";
/// Account at index 0 if DEFAULT_ANVIL_MNEMONIC_PHRASE used
pub const DEFAULT_ETH_ACCOUNT_PRIVATE_KEY: &str =
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/background_devnet.rs | tests/integration/common/background_devnet.rs | use std::collections::HashMap;
use std::fmt::LowerHex;
use std::process::{Command, Output, Stdio};
use std::time;
use anyhow::anyhow;
use lazy_static::lazy_static;
use reqwest::{Client, StatusCode};
use serde_json::json;
use starknet_rs_core::types::{
BlockId, BlockTag, BlockWithTxHashes, BlockWithTxs, Felt, FunctionCall,
MaybePreConfirmedBlockWithTxHashes, MaybePreConfirmedBlockWithTxs,
PreConfirmedBlockWithTxHashes, PreConfirmedBlockWithTxs,
};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider};
use starknet_rs_signers::{LocalWallet, SigningKey};
use tokio::io::AsyncReadExt;
use tokio::net::UnixListener;
use url::Url;
use super::constants::{
ACCOUNTS, HEALTHCHECK_PATH, HOST, PREDEPLOYED_ACCOUNT_INITIAL_BALANCE, RPC_PATH, SEED, WS_PATH,
};
use super::errors::{RpcError, TestError};
use super::reqwest_client::{PostReqwestSender, ReqwestClient};
use super::utils::{FeeUnit, ImpersonationAction, to_hex_felt};
use crate::common::background_server::get_acquired_port;
use crate::common::constants::{
DEVNET_EXECUTABLE_BINARY_PATH, DEVNET_MANIFEST_PATH, STRK_ERC20_CONTRACT_ADDRESS,
};
use crate::common::safe_child::SafeChild;
use crate::common::utils::UniqueAutoDeletableFile;
#[derive(Debug)]
pub struct BackgroundDevnet {
reqwest_client: ReqwestClient,
pub json_rpc_client: JsonRpcClient<HttpTransport>,
port: u16,
pub process: SafeChild,
pub url: String,
rpc_url: Url,
}
lazy_static! {
static ref DEFAULT_CLI_MAP: HashMap<&'static str, String> = HashMap::from([
("--seed", SEED.to_string()),
("--accounts", ACCOUNTS.to_string()),
("--initial-balance", PREDEPLOYED_ACCOUNT_INITIAL_BALANCE.to_string()),
("--port", 0.to_string()) // random port by default
]);
}
async fn wait_for_successful_response(
client: &Client,
healthcheck_url: &str,
sleep_time: time::Duration,
max_retries: usize,
) -> Result<(), anyhow::Error> {
for _ in 0..max_retries {
if let Ok(alive_resp) = client.get(healthcheck_url).send().await {
let status = alive_resp.status();
if status != StatusCode::OK {
return Err(anyhow!("Server responded with: {status}"));
}
return Ok(());
}
tokio::time::sleep(sleep_time).await;
}
Err(anyhow!("Not responsive: {healthcheck_url}"))
}
impl BackgroundDevnet {
pub(crate) async fn spawn() -> Result<Self, TestError> {
BackgroundDevnet::spawn_with_additional_args(&[]).await
}
pub(crate) async fn spawn_forkable_devnet() -> Result<BackgroundDevnet, anyhow::Error> {
let args = ["--state-archive-capacity", "full"];
let devnet = BackgroundDevnet::spawn_with_additional_args(&args).await?;
Ok(devnet)
}
pub fn reqwest_client(&self) -> &ReqwestClient {
&self.reqwest_client
}
/// Takes specified args and adds default values for args that are missing
fn add_default_args<'a>(specified_args: &[&'a str]) -> Vec<&'a str> {
let mut specified_args_vec: Vec<&str> = specified_args.to_vec();
let mut final_args: Vec<&str> = vec![];
// Iterate through default args, and remove from specified args when found
// That way in the end we can just append the non-removed args
for (arg_name, default_value) in DEFAULT_CLI_MAP.iter() {
let value =
match specified_args_vec.iter().position(|arg_candidate| arg_candidate == arg_name)
{
Some(pos) => {
// arg value comes after name
specified_args_vec.remove(pos);
specified_args_vec.remove(pos)
}
None => default_value,
};
final_args.push(arg_name);
final_args.push(value);
}
// simply append those args that don't have an entry in DEFAULT_CLI_MAP
final_args.append(&mut specified_args_vec);
final_args
}
async fn start_safe_process(args: &[&str]) -> Result<SafeChild, TestError> {
// If not on CircleCI, first build the workspace with cargo. Then rely on the built binary.
if std::env::var("CIRCLECI").is_err() {
let Output { status, stderr, .. } = Command::new("cargo")
.args(["build", "--release", "--manifest-path", DEVNET_MANIFEST_PATH])
.stdout(Stdio::null())
.output()
.map_err(|err| {
TestError::DevnetNotStartable(format!("Error spawning build process {err:?}"))
})?;
if !status.success() {
let stderr_str = String::from_utf8_lossy(&stderr);
return Err(TestError::DevnetNotStartable(format!(
"Error during build process {stderr_str}"
)));
}
}
let socket = UniqueAutoDeletableFile::new("socket");
#[cfg(unix)]
let listener = UnixListener::bind(&socket.path).map_err(|e| {
TestError::DevnetNotStartable(format!("Failed to bind to unix socket: {e:?}"))
})?;
let process = Command::new(DEVNET_EXECUTABLE_BINARY_PATH)
.args(Self::add_default_args(args))
.env("UNIX_SOCKET", &socket.path)
.stdout(Stdio::null()) // comment this out for complete devnet stdout
.spawn()
.map_err(|e| TestError::DevnetNotStartable(format!("Spawning error: {e:?}")))?;
#[cfg(unix)]
{
let port =
match tokio::time::timeout(tokio::time::Duration::from_secs(10), listener.accept())
.await
{
Ok(Ok((mut stream, _))) => {
let mut buffer = [0; 2];
stream.read_exact(&mut buffer).await.map_err(|e| {
TestError::DevnetNotStartable(format!(
"Failed to read from socket: {e:?}"
))
})?;
Some(u16::from_be_bytes(buffer))
}
Ok(Err(_e)) => None,
Err(_) => {
println!("Timeout reading from unix socket: {:?}", listener);
None
}
};
Ok(SafeChild { process, port })
}
#[cfg(not(unix))]
Ok(SafeChild { process, port: None })
}
pub(crate) async fn spawn_with_additional_args(args: &[&str]) -> Result<Self, TestError> {
let mut safe_process = Self::start_safe_process(args).await?;
let sleep_time = time::Duration::from_millis(500);
let max_retries = 60;
let port = if let Some(port) = safe_process.port {
port
} else {
get_acquired_port(&mut safe_process, sleep_time, max_retries).await.map_err(|e| {
TestError::DevnetNotStartable(format!("Cannot determine port: {e:?}"))
})?
};
// now we know the port; check if it can be used to poll Devnet's endpoint
let client = Client::new();
let devnet_url = format!("http://{HOST}:{port}");
let healthcheck_url = format!("{devnet_url}{HEALTHCHECK_PATH}").to_string();
wait_for_successful_response(&client, &healthcheck_url, sleep_time, max_retries)
.await
.map_err(|e| TestError::DevnetNotStartable(format!("Server unresponsive: {e:?}")))?;
println!("Spawned background devnet at {devnet_url}");
let devnet_rpc_url = Url::parse(format!("{devnet_url}{RPC_PATH}").as_str())?;
Ok(Self {
reqwest_client: ReqwestClient::new(devnet_url.clone(), client),
json_rpc_client: JsonRpcClient::new(HttpTransport::new(devnet_rpc_url.clone())),
port,
process: safe_process,
url: devnet_url,
rpc_url: devnet_rpc_url,
})
}
pub fn ws_url(&self) -> String {
format!("ws://{HOST}:{}{WS_PATH}", self.port)
}
pub async fn send_custom_rpc(
&self,
method: &str,
params: serde_json::Value,
) -> Result<serde_json::Value, RpcError> {
let mut body_json = json!({
"jsonrpc": "2.0",
"id": 0,
"method": method,
});
if !params.is_null() {
body_json["params"] = params;
}
// Convert HTTP error to RPC error; panic if not possible.
let json_rpc_result: serde_json::Value =
self.reqwest_client().post_json_async(RPC_PATH, body_json).await.map_err(|err| {
let err_msg = err.error_message();
if let Ok(rpc_error) = serde_json::from_str::<RpcError>(&err_msg) {
return rpc_error;
};
if let Ok(err_val) = serde_json::from_str::<serde_json::Value>(&err_msg) {
if let Some(err_prop) = err_val.get("error").cloned() {
if let Ok(rpc_error) = serde_json::from_value::<RpcError>(err_prop) {
return rpc_error;
}
}
}
panic!("Cannot extract RPC error from: {err_msg}")
})?;
if let Some(result) = json_rpc_result.get("result") {
Ok(result.clone())
} else if let Some(error) = json_rpc_result.get("error") {
Err(serde_json::from_value(error.clone()).unwrap())
} else {
Err(RpcError {
code: -1,
message: "Server responded with malformed response".into(),
data: None,
})
}
}
pub fn clone_provider(&self) -> JsonRpcClient<HttpTransport> {
JsonRpcClient::new(HttpTransport::new(self.rpc_url.clone()))
}
/// Mint some FRI at `address` and return the resulting transaction hash.
pub async fn mint(&self, address: impl LowerHex, mint_amount: u128) -> Felt {
self.mint_unit(address, mint_amount, FeeUnit::Fri).await
}
pub async fn mint_unit(
&self,
address: impl LowerHex,
mint_amount: u128,
unit: FeeUnit,
) -> Felt {
let resp_body: serde_json::Value = self
.send_custom_rpc(
"devnet_mint",
json!({
"address": format!("{address:#x}"),
"amount": mint_amount,
"unit": unit,
}),
)
.await
.unwrap();
Felt::from_hex_unchecked(resp_body["tx_hash"].as_str().unwrap())
}
/// Get ETH balance at contract_address, as written in ERC20
pub async fn get_balance_at_block(
&self,
address: &Felt,
block_id: BlockId,
) -> Result<Felt, anyhow::Error> {
let call = FunctionCall {
contract_address: STRK_ERC20_CONTRACT_ADDRESS,
entry_point_selector: get_selector_from_name("balanceOf").unwrap(),
calldata: vec![*address],
};
let balance_raw = self.json_rpc_client.call(call, block_id).await?;
assert_eq!(balance_raw.len(), 2);
let balance_low = balance_raw.first().unwrap().to_biguint();
let balance_high = balance_raw.last().unwrap().to_biguint();
Ok(Felt::from((balance_high << 128) + balance_low))
}
/// Get balance at contract_address, as written in the ERC20 contract corresponding to `unit`
/// from latest state
pub async fn get_balance_latest(
&self,
address: &Felt,
unit: FeeUnit,
) -> Result<Felt, anyhow::Error> {
Self::get_balance_by_tag(self, address, unit, BlockTag::Latest).await
}
/// Get balance at contract_address, as written in the ERC20 contract corresponding to `unit`
/// from pre-confirmed state or latest state
pub async fn get_balance_by_tag(
&self,
address: &Felt,
unit: FeeUnit,
tag: BlockTag,
) -> Result<Felt, anyhow::Error> {
let json_resp = self
.send_custom_rpc(
"devnet_getAccountBalance",
json!({
"address": address,
"unit": unit,
"block_id": Self::tag_to_str(tag),
}),
)
.await
.unwrap();
// response validity asserted in test_balance.rs::assert_balance_endpoint_response
let amount_raw = json_resp["amount"].as_str().unwrap();
Ok(Felt::from_dec_str(amount_raw)?)
}
fn tag_to_str(tag: BlockTag) -> &'static str {
match tag {
BlockTag::Latest => "latest",
BlockTag::PreConfirmed => "pre_confirmed",
BlockTag::L1Accepted => "l1_accepted",
}
}
/// This method returns the private key and the address of the first predeployed account
pub async fn get_first_predeployed_account(&self) -> (LocalWallet, Felt) {
let predeployed_accounts_json =
self.send_custom_rpc("devnet_getPredeployedAccounts", json!({})).await.unwrap();
let first_account = predeployed_accounts_json.as_array().unwrap().first().unwrap();
let account_address = Felt::from_hex_unchecked(first_account["address"].as_str().unwrap());
let private_key = Felt::from_hex_unchecked(first_account["private_key"].as_str().unwrap());
let signer = LocalWallet::from(SigningKey::from_secret_scalar(private_key));
(signer, account_address)
}
pub async fn restart(&self) {
self.send_custom_rpc("devnet_restart", json!({})).await.unwrap();
}
pub async fn fork(&self) -> Result<Self, TestError> {
let args = ["--fork-network", self.url.as_str(), "--accounts", "0"];
BackgroundDevnet::spawn_with_additional_args(&args).await
}
pub async fn fork_with_full_state_archive(&self) -> Result<Self, TestError> {
let args = [
"--fork-network",
self.url.as_str(),
"--accounts",
"0",
"--state-archive-capacity",
"full",
];
BackgroundDevnet::spawn_with_additional_args(&args).await
}
/// Mines a new block and returns its hash
pub async fn create_block(&self) -> Result<Felt, anyhow::Error> {
let block_creation_resp_body: serde_json::Value =
self.send_custom_rpc("devnet_createBlock", json!({})).await.unwrap();
let block_hash_str = block_creation_resp_body["block_hash"].as_str().unwrap();
Ok(Felt::from_hex(block_hash_str)?)
}
pub async fn get_latest_block_with_tx_hashes(
&self,
) -> Result<BlockWithTxHashes, anyhow::Error> {
match self.json_rpc_client.get_block_with_tx_hashes(BlockId::Tag(BlockTag::Latest)).await {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(b)) => Ok(b),
other => Err(anyhow::format_err!("Got unexpected block: {other:?}")),
}
}
pub async fn get_pre_confirmed_block_with_tx_hashes(
&self,
) -> Result<PreConfirmedBlockWithTxHashes, anyhow::Error> {
match self
.json_rpc_client
.get_block_with_tx_hashes(BlockId::Tag(BlockTag::PreConfirmed))
.await
{
Ok(MaybePreConfirmedBlockWithTxHashes::PreConfirmedBlock(b)) => Ok(b),
other => Err(anyhow::format_err!("Got unexpected block: {other:?}")),
}
}
pub async fn get_latest_block_with_txs(&self) -> Result<BlockWithTxs, anyhow::Error> {
match self.json_rpc_client.get_block_with_txs(BlockId::Tag(BlockTag::Latest)).await {
Ok(MaybePreConfirmedBlockWithTxs::Block(b)) => Ok(b),
other => Err(anyhow::format_err!("Got unexpected block: {other:?}")),
}
}
pub async fn get_confirmed_block_with_tx_hashes(
&self,
block_id: &BlockId,
) -> Result<BlockWithTxHashes, anyhow::Error> {
match self.json_rpc_client.get_block_with_tx_hashes(block_id).await {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(block)) => Ok(block),
other => Err(anyhow::format_err!("Got unexpected block response: {other:?}")),
}
}
pub async fn get_pre_confirmed_block_with_txs(
&self,
) -> Result<PreConfirmedBlockWithTxs, anyhow::Error> {
match self.json_rpc_client.get_block_with_txs(BlockId::Tag(BlockTag::PreConfirmed)).await {
Ok(MaybePreConfirmedBlockWithTxs::PreConfirmedBlock(b)) => Ok(b),
other => Err(anyhow::format_err!("Got unexpected block: {other:?}")),
}
}
pub async fn get_l1_accepted_block_with_tx_hashes(
&self,
) -> Result<BlockWithTxHashes, anyhow::Error> {
match self
.json_rpc_client
.get_block_with_tx_hashes(BlockId::Tag(BlockTag::L1Accepted))
.await
{
Ok(MaybePreConfirmedBlockWithTxHashes::Block(b)) => Ok(b),
Err(e) => Err(anyhow::Error::new(e)),
Ok(other) => Err(anyhow::format_err!("Got unexpected block: {other:?}")),
}
}
pub async fn abort_blocks(
&self,
starting_block_id: &BlockId,
) -> Result<Vec<Felt>, anyhow::Error> {
let mut aborted_blocks = self
.send_custom_rpc(
"devnet_abortBlocks",
json!({ "starting_block_id" : starting_block_id }),
)
.await
.map_err(|e| anyhow::Error::msg(e.to_string()))?;
let aborted_blocks = aborted_blocks["aborted"]
.take()
.as_array()
.ok_or(anyhow::Error::msg("Invalid abort response"))?
.clone();
Ok(aborted_blocks
.into_iter()
.map(|block_hash| serde_json::from_value(block_hash).unwrap())
.collect())
}
pub async fn accept_on_l1(&self, starting_block_id: &BlockId) -> Result<Vec<Felt>, RpcError> {
let accepted_block_hashes_raw = self
.send_custom_rpc(
"devnet_acceptOnL1",
json!({ "starting_block_id" : starting_block_id }),
)
.await?;
let accepted_block_hashes =
serde_json::from_value(accepted_block_hashes_raw["accepted"].clone()).unwrap();
Ok(accepted_block_hashes)
}
pub async fn get_config(&self) -> serde_json::Value {
self.send_custom_rpc("devnet_getConfig", json!({})).await.unwrap()
}
pub async fn execute_impersonation_action(
&self,
action: &ImpersonationAction,
) -> Result<(), anyhow::Error> {
let (method_name, params) = match action {
ImpersonationAction::ImpersonateAccount(account) => {
("devnet_impersonateAccount", json!({ "account_address": to_hex_felt(account) }))
}
ImpersonationAction::StopImpersonateAccount(account) => {
("devnet_stopImpersonateAccount", json!({"account_address": to_hex_felt(account)}))
}
ImpersonationAction::AutoImpersonate => ("devnet_autoImpersonate", json!({})),
ImpersonationAction::StopAutoImpersonate => ("devnet_stopAutoImpersonate", json!({})),
};
let result = self.send_custom_rpc(method_name, params).await;
match result {
Ok(_) => Ok(()),
Err(err) => Err(anyhow::Error::msg(err.message.to_string())),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/assertions.rs | tests/integration/common/assertions.rs | /// Asserts that a boolean expression is `true` at runtime, propagating an `Err` if `false`.
#[macro_export]
macro_rules! assert_prop {
($cond:expr) => {
if $cond {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: {}",
stringify!($cond)
))
}
};
($cond:expr, $($arg:tt)+) => {
if $cond {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: {}: {}",
stringify!($cond),
format!($($arg)+)
))
}
};
}
/// Asserts that two expressions are equal to each other, propagating an `Err` if not.
#[macro_export]
macro_rules! assert_eq_prop {
($left:expr, $right:expr) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val == *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left == right)`
left: `{left_val:?}`,
right: `{right_val:?}`"
))
}
}
}
};
($left:expr, $right:expr, $($arg:tt)+) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val == *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left == right)`: {}
left: `{left_val:?}`,
right: `{right_val:?}`"
format!($($arg)+),
))
}
}
}
};
}
/// Asserts that two expressions are not equal to each other, propagating an `Err` if they are.
#[macro_export]
macro_rules! assert_ne_prop {
($left:expr, $right:expr) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val != *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left != right)`
left: `{left_val:?}`,
right: `{right_val:?}`"
))
}
}
}
};
($left:expr, $right:expr, $($arg:tt)+) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val != *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left != right)`: {}
left: `{left_val:?}`,
right: `{right_val:?}`",
format!($($arg)+),
))
}
}
}
};
}
/// Asserts that an expression is greater than or equal to the other, propagating an `Err` if not.
#[macro_export]
macro_rules! assert_gte_prop {
($left:expr, $right:expr) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val >= *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left >= right)`
left: `{left_val:?}`,
right: `{right_val:?}`"
))
}
}
}
};
($left:expr, $right:expr, $($arg:tt)+) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val >= *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left >= right)`: {}
left: `{left_val:?}`,
right: `{right_val:?}`",
format!($($arg)+),
))
}
}
}
};
}
/// Asserts that an expression is less than or equal to the other, propagating an `Err` if not.
#[macro_export]
macro_rules! assert_lte_prop {
($left:expr, $right:expr) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val <= *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left <= right)`
left: `{left_val:?}`,
right: `{right_val:?}`"
))
}
}
}
};
($left:expr, $right:expr, $($arg:tt)+) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val <= *right_val {
Ok(())
} else {
Err(anyhow::anyhow!(
"Assertion failed: `(left <= right)`: {}
left: `{left_val:?}`,
right: `{right_val:?}`",
format!($($arg)+),
))
}
}
}
};
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/tests/integration/common/fees.rs | tests/integration/common/fees.rs | fn extract_overall_fee(simulation_result: &serde_json::Value) -> u128 {
let fee_hex = simulation_result["fee_estimation"]["overall_fee"].as_str().unwrap();
let fee_hex_stripped = fee_hex.strip_prefix("0x").unwrap();
u128::from_str_radix(fee_hex_stripped, 16).unwrap()
}
/// Calculating the fee of a transaction depends on fee weights of vm resources and the resource
/// usage. The fee from vm usage is the heaviest product of cairo resource usage multiplied
/// by cairo resource fee cost, rounded down to the nearest integer. There is a
/// possibility that although some of the resources present in the resp_no_flags are not in
/// resp_skip_validation, this doesn't mean that the fee will be higher, for example:
/// the fee from vm usage is determined from the `steps` and the transaction that skips
/// validation might have less steps, but due to the rounding if the multiplied product
/// falls in the range (7,8] both will be rounded to 7
pub fn assert_fee_in_resp_at_least_equal(
resp_no_flags: &serde_json::Value,
resp_skip_validation: &serde_json::Value,
) {
let no_flags_fee = extract_overall_fee(resp_no_flags);
let skip_validation_fee = extract_overall_fee(resp_skip_validation);
assert!(no_flags_fee.ge(&skip_validation_fee));
}
pub fn assert_difference_if_validation(
resp_no_flags: &serde_json::Value,
resp_skip_validation: &serde_json::Value,
expected_contract_address: &str,
should_skip_fee_invocation: bool,
) {
let no_flags_trace = &resp_no_flags["transaction_trace"];
assert_eq!(
no_flags_trace["validate_invocation"]["contract_address"].as_str().unwrap(),
expected_contract_address
);
assert!(no_flags_trace["state_diff"].as_object().is_some());
let skip_validation_trace = &resp_skip_validation["transaction_trace"];
assert!(skip_validation_trace["validate_invocation"].as_object().is_none());
assert!(skip_validation_trace["state_diff"].as_object().is_some());
assert_eq!(
skip_validation_trace["fee_transfer_invocation"].as_object().is_none(),
should_skip_fee_invocation
);
assert_eq!(
no_flags_trace["fee_transfer_invocation"].as_object().is_none(),
should_skip_fee_invocation
);
assert!(
no_flags_trace["execution_resources"]["l1_gas"].as_u64().unwrap()
>= skip_validation_trace["execution_resources"]["l1_gas"].as_u64().unwrap()
);
assert!(
no_flags_trace["execution_resources"]["l1_data_gas"].as_u64().unwrap()
>= skip_validation_trace["execution_resources"]["l1_data_gas"].as_u64().unwrap()
);
assert!(
no_flags_trace["execution_resources"]["l2_gas"].as_u64().unwrap()
> skip_validation_trace["execution_resources"]["l2_gas"].as_u64().unwrap()
);
assert_fee_in_resp_at_least_equal(resp_no_flags, resp_skip_validation);
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/contract_storage_key.rs | crates/starknet-devnet-types/src/contract_storage_key.rs | use std::fmt::Display;
use super::contract_address::ContractAddress;
use crate::patricia_key::StorageKey;
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ContractStorageKey(ContractAddress, StorageKey);
impl ContractStorageKey {
pub fn new(address: ContractAddress, storage_key: StorageKey) -> Self {
Self(address, storage_key)
}
pub fn get_contract_address(&self) -> &ContractAddress {
&self.0
}
pub fn get_storage_key(&self) -> &StorageKey {
&self.1
}
}
impl Display for ContractStorageKey {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_fmt(format_args!("({0:x}, {1:x})", self.0, self.1.0))
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/lib.rs | crates/starknet-devnet-types/src/lib.rs | pub mod chain_id;
pub mod constants;
pub mod contract_storage_key;
pub mod error;
pub mod patricia_key;
pub mod rpc;
pub mod serde_helpers;
pub mod traits;
mod utils;
// Re export libraries
pub use rpc::{contract_address, contract_class, emitted_event, felt, messaging};
pub use utils::{compile_sierra_contract, compile_sierra_contract_json};
pub use {num_bigint, starknet_api};
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/chain_id.rs | crates/starknet-devnet-types/src/chain_id.rs | use std::fmt::Display;
use std::str::FromStr;
use starknet_rs_core::chain_id::{MAINNET, SEPOLIA};
use starknet_rs_core::utils::{cairo_short_string_to_felt, parse_cairo_short_string};
use starknet_types_core::felt::Felt;
use crate::error::ConversionError;
#[derive(Clone, Copy, Debug)]
pub enum ChainId {
Mainnet,
Testnet,
Custom(Felt),
}
impl ChainId {
/// Used only in tests.
/// It was imported from `starknet_rs_core::chain_id`, but now gives a deprecation warning
/// defined [here](https://github.com/xJonathanLEI/starknet-rs/blob/f6d339c6b897fb38c839485608ca2fe374a6275d/starknet-core/src/chain_id.rs#L10).
/// Instead of ignoring the warning in two places, it's defined here.
const TESTNET: Felt = Felt::from_raw([
398700013197595345,
18446744073709551615,
18446744073709548950,
3753493103916128178,
]);
pub const fn goerli_legacy_id() -> Felt {
Self::TESTNET
}
pub fn to_felt(&self) -> Felt {
Felt::from(self)
}
}
impl Display for ChainId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let felt = Felt::from(self);
let str = parse_cairo_short_string(&felt).map_err(|_| std::fmt::Error)?;
f.write_str(&str)
}
}
impl FromStr for ChainId {
type Err = ConversionError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let uppercase_chain_id_str = s.to_ascii_uppercase();
let chain_id = match uppercase_chain_id_str.as_str() {
"MAINNET" => ChainId::Mainnet,
"TESTNET" => ChainId::Testnet,
_ => {
let felt = cairo_short_string_to_felt(&uppercase_chain_id_str)
.map_err(|err| ConversionError::OutOfRangeError(err.to_string()))?;
ChainId::Custom(felt)
}
};
Ok(chain_id)
}
}
impl From<ChainId> for Felt {
fn from(value: ChainId) -> Self {
match value {
ChainId::Mainnet => MAINNET,
ChainId::Testnet => SEPOLIA,
ChainId::Custom(felt) => felt,
}
}
}
impl From<&ChainId> for Felt {
fn from(value: &ChainId) -> Self {
match value {
ChainId::Mainnet => MAINNET,
ChainId::Testnet => SEPOLIA,
ChainId::Custom(felt) => *felt,
}
}
}
impl From<Felt> for ChainId {
fn from(value: Felt) -> Self {
if value == MAINNET {
ChainId::Mainnet
} else if value == SEPOLIA {
ChainId::Testnet
} else {
ChainId::Custom(value)
}
}
}
impl From<ChainId> for starknet_api::core::ChainId {
fn from(value: ChainId) -> Self {
match value {
ChainId::Mainnet => Self::Mainnet,
ChainId::Testnet => Self::Sepolia,
ChainId::Custom(_) => Self::Other(format!("{value}")),
}
}
}
#[cfg(test)]
mod tests {
use super::ChainId;
#[test]
fn check_conversion_to_starknet_api() {
let t = ChainId::Testnet;
let sat: starknet_api::core::ChainId = t.into();
assert_eq!(t.to_felt().to_hex_string(), sat.as_hex());
}
#[test]
fn test_display() {
assert_eq!(format!("{}", ChainId::Mainnet), "SN_MAIN");
assert_eq!(format!("{}", ChainId::Testnet), "SN_SEPOLIA");
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/patricia_key.rs | crates/starknet-devnet-types/src/patricia_key.rs | use serde::{Deserialize, Deserializer, Serialize};
use starknet_api::core::PATRICIA_KEY_UPPER_BOUND;
use starknet_rs_core::types::Felt;
use crate::error::{DevnetResult, Error};
use crate::serde_helpers::hex_string::{
deserialize_to_prefixed_patricia_key, serialize_patricia_key_to_prefixed_hex,
};
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
pub struct PatriciaKey(pub(crate) Felt);
pub(crate) const PATRICIA_KEY_ZERO: PatriciaKey = PatriciaKey(Felt::ZERO);
impl PatriciaKey {
pub fn new(felt: Felt) -> DevnetResult<Self> {
if Felt::from_hex_unchecked(PATRICIA_KEY_UPPER_BOUND) < felt {
return Err(Error::StarknetApiError(starknet_api::StarknetApiError::OutOfRange {
string: format!("[0x0, {PATRICIA_KEY_UPPER_BOUND})"),
}));
}
Ok(Self(felt))
}
/// Constructs without range checks.
/// Safety: `felt` must be in [0x0, PATRICIA_KEY_UPPER_BOUND).
pub(crate) fn new_unchecked(felt: Felt) -> Self {
debug_assert!(
Felt::from_hex_unchecked(PATRICIA_KEY_UPPER_BOUND) >= felt,
"PatriciaKey out of range"
);
Self(felt)
}
pub fn to_felt(&self) -> Felt {
self.0
}
}
impl Serialize for PatriciaKey {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize_patricia_key_to_prefixed_hex(self, serializer)
}
}
impl<'de> Deserialize<'de> for PatriciaKey {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserialize_to_prefixed_patricia_key(deserializer)
}
}
impl From<starknet_api::core::PatriciaKey> for PatriciaKey {
fn from(value: starknet_api::core::PatriciaKey) -> Self {
Self(*value.key())
}
}
impl From<PatriciaKey> for starknet_api::core::PatriciaKey {
fn from(value: PatriciaKey) -> Self {
Self::from_hex_unchecked(&value.0.to_hex_string())
}
}
impl TryFrom<Felt> for PatriciaKey {
type Error = Error;
fn try_from(value: Felt) -> Result<Self, Self::Error> {
Self::new(value)
}
}
impl From<PatriciaKey> for starknet_api::state::StorageKey {
fn from(value: PatriciaKey) -> Self {
Self(value.into())
}
}
pub type StorageKey = PatriciaKey;
#[cfg(test)]
mod tests {
use super::PatriciaKey;
use crate::felt::felt_from_prefixed_hex;
#[test]
fn creation_of_patricia_key_should_be_successful() {
assert!(
PatriciaKey::new(
felt_from_prefixed_hex(
"0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
)
.unwrap()
)
.is_ok()
);
}
#[test]
fn patricia_key_with_too_large_felt_should_return_error() {
let result = PatriciaKey::new(
felt_from_prefixed_hex(
"0x800000000000000000000000000000000000000000000000000000000000001",
)
.unwrap(),
);
assert!(result.is_err());
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/error.rs | crates/starknet-devnet-types/src/error.rs | use blockifier::transaction::errors::TransactionExecutionError;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum Error {
#[error(transparent)]
StarknetApiError(#[from] starknet_api::StarknetApiError),
#[error("Conversion error: {0}")]
ConversionError(#[from] ConversionError),
#[error(transparent)]
JsonError(#[from] JsonError),
#[error(transparent)]
IoError(#[from] std::io::Error),
#[error(transparent)]
FromHexError(#[from] starknet_rs_core::types::eth_address::FromHexError),
#[error(transparent)]
TransactionExecutionError(#[from] TransactionExecutionError),
// TODO import cairo-lang-starknet to the project so this error could be created with its
// variants
#[error("Sierra compilation error: {reason}")]
SierraCompilationError { reason: String },
#[error("Program error")]
ProgramError,
}
#[derive(Error, Debug)]
pub enum ConversionError {
#[error("Byte array invalid")]
FromByteArrayError,
#[error("Invalid format")]
InvalidFormat,
#[error("Invalid internal structure: {0}")]
InvalidInternalStructure(String),
#[error("Value is out of range: {0}")]
OutOfRangeError(String),
#[error("Error converting from hex string: {0}")]
CustomFromHexError(String),
}
#[derive(Error, Debug)]
pub enum JsonError {
#[error(transparent)]
SerdeJsonError(#[from] serde_json::Error),
#[error("Error: {msg}")]
Custom { msg: String },
}
pub type DevnetResult<T, E = Error> = Result<T, E>;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/utils.rs | crates/starknet-devnet-types/src/utils.rs | use std::io;
use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
use cairo_lang_starknet_classes::contract_class::ContractClass;
use serde_json::ser::Formatter;
use serde_json::{Map, Value};
use crate::error::{DevnetResult, Error, JsonError};
/// The preserve_order feature enabled in the serde_json crate
/// removing a key from the object changes the order of the keys
/// When serde_json is not being used with the preserver order feature
/// deserializing to a serde_json::Value changes the order of the keys
///
/// go through the object by visiting every key and value recursively,
/// and not including them into a new json obj if the condition is met
/// Empty objects are not included
/// Exclude_condition is a function that takes a key and a value and returns a bool
/// If the exclude_condition evaluates to true, the key and value are not included in the new object
pub fn traverse_and_exclude_recursively<F>(
value: &Value,
exclude_condition: &F,
) -> serde_json::Value
where
F: Fn(&String, &Value) -> bool,
{
match value {
Value::Object(object) => {
let mut new_object = Map::new();
for (key, value) in object {
if exclude_condition(key, value) {
continue;
}
let inner_val = traverse_and_exclude_recursively(value, exclude_condition);
new_object.insert(key.to_string(), inner_val);
}
Value::Object(new_object.clone())
}
// arrays are visited like the objects - recursively
Value::Array(array) => {
let mut inner_arr = Vec::<Value>::new();
for value in array {
let inner_val = traverse_and_exclude_recursively(value, exclude_condition);
match inner_val.as_object() {
Some(inner_obj) if inner_obj.is_empty() => {}
_ => inner_arr.push(inner_val),
}
}
Value::Array(inner_arr)
}
// handle non-object, non-array values
_ => value.clone(),
}
}
/// JSON Formatter that serializes an object with the desired spaces
/// So the serialized object can match the object structure when compiling cairo program.
/// When serializing with the default formatter, the JSON string is without any spaces between
/// elements. Example here <https://www.cairo-lang.org/docs/hello_starknet/intro.html#>.
pub struct StarknetFormatter;
impl Formatter for StarknetFormatter {
fn begin_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
writer.write_all(b": ")
}
fn begin_object_key<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
where
W: ?Sized + io::Write,
{
if first { Ok(()) } else { writer.write_all(b", ") }
}
fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
where
W: ?Sized + io::Write,
{
if first { Ok(()) } else { writer.write_all(b", ") }
}
}
pub fn compile_sierra_contract(sierra_contract: &ContractClass) -> DevnetResult<CasmContractClass> {
let sierra_contract_json = serde_json::to_value(sierra_contract)
.map_err(|err| Error::JsonError(JsonError::SerdeJsonError(err)))?;
compile_sierra_contract_json(sierra_contract_json)
}
pub fn compile_sierra_contract_json(
sierra_contract_json: serde_json::Value,
) -> DevnetResult<CasmContractClass> {
let casm_json = usc::compile_contract(sierra_contract_json)
.map_err(|err| Error::SierraCompilationError { reason: err.to_string() })?;
serde_json::from_value::<CasmContractClass>(casm_json)
.map_err(|err| Error::JsonError(JsonError::SerdeJsonError(err)))
}
#[cfg(test)]
pub(crate) mod test_utils {
pub(crate) const CAIRO_0_ACCOUNT_CONTRACT_PATH: &str =
"../../contracts/test_artifacts/cairo0/account.json";
pub(crate) const CAIRO_0_RPC_CONTRACT_PATH: &str =
concat!(env!("CARGO_MANIFEST_DIR"), "/test_data/cairo_0_rpc.json");
pub(crate) const CAIRO_0_ACCOUNT_CONTRACT_HASH: &str =
"0x4d07e40e93398ed3c76981e72dd1fd22557a78ce36c0515f679e27f0bb5bc5f";
/// contract declared in transaction https://alpha4.starknet.io/feeder_gateway/get_transaction?transactionHash=0x01b852f1fe2b13db21a44f8884bc4b7760dc277bb3820b970dba929860275617
/// cairo code is in the same directory as the sierra artifacts
pub(crate) const CAIRO_1_EVENTS_CONTRACT_PATH: &str =
"../../contracts/test_artifacts/cairo1/events/events_2.0.1_compiler.sierra";
pub(crate) const CAIRO_1_CONTRACT_SIERRA_HASH: &str =
"0x113bf26d112a164297e04381212c9bd7409f07591f0a04f539bdf56693eaaf3";
}
#[cfg(test)]
mod tests {
use serde_json::Value;
#[test]
fn serde_remove_elements_from_json() {
let input = r#"
{
"name": "John Doe",
"isStudent": true,
"age":30,
"address": {
"street": "Vlvo",
"city": "Anytown",
"state": "Any"
},
"should_be_removed": [],
"scores":
[
{
"street": "AAA",
"age": 5,
"should_be_removed": []
},
{
"age": 5
}
],
"arr": [90, 85, 95]
}
"#;
let expected_output = r#"
{
"name": "John Doe",
"isStudent": true,
"age":30,
"address": {
"street": "Vlvo",
"city": "Anytown",
"state": "Any"
},
"scores":
[
{
"street": "AAA",
"age": 5
},
{
"age": 5
}
],
"arr": [90, 85, 95]
}
"#;
let value: Value = serde_json::from_str(input).unwrap();
let res = crate::utils::traverse_and_exclude_recursively(&value, &|key, val| {
key == "should_be_removed" && val.is_array() && val.as_array().unwrap().is_empty()
});
assert_eq!(res, serde_json::from_str::<serde_json::Value>(expected_output).unwrap());
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc.rs | crates/starknet-devnet-types/src/rpc.rs | pub mod block;
pub mod contract_address;
pub mod contract_class;
pub mod emitted_event;
pub mod estimate_message_fee;
pub mod eth_address;
pub mod felt;
pub mod gas_modification;
mod macro_utils;
pub mod messaging;
pub mod state;
pub mod transaction_receipt;
pub mod transactions;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.