lfglabs-dev · irisdv · Sep 18, 2025
diff --git a/Cargo.toml b/Cargo.toml
@@ -28,15 +28,15 @@ lazy_static = "1.5.0"
 mongodb = "2.8.2"
 rand = "0.8.5"
 regex = "1.10.6"
-reqwest = {version = "0.11.27", features = ["json"]}
+reqwest = {version = "0.12", features = ["json"]}
 serde = {version = "1.0.209", features = ["derive"]}
 serde_derive = "1.0.183"
 serde_json = "1.0.127"
 serde_urlencoded = "0.7.1"
 solana-sdk = "1.18.23"
-starknet = {git = "https://github.com/xJonathanLEI/starknet-rs", rev = "c974e5cb42e8d8344cee910b76005ec46b4dd3ed"}
-starknet-crypto = {git = "https://github.com/xJonathanLEI/starknet-rs", rev = "c974e5cb42e8d8344cee910b76005ec46b4dd3ed", package = "starknet-crypto"}
-starknet-id = {git = "https://github.com/starknet-id/starknetid.rs", rev = "2b30c2453b96789a628c86d2edebb1023fa2e77d"}
+starknet = { git = "https://github.com/xJonathanLEI/starknet-rs", rev = "85906137d634c86b07de20fa33071e5cf186ce21" }
+starknet-crypto = {git = "https://github.com/xJonathanLEI/starknet-rs", rev = "85906137d634c86b07de20fa33071e5cf186ce21", package = "starknet-crypto"}
+starknet-id = { git = "https://github.com/starknet-id/starknetid.rs", rev = "04958762b3085311d4f0d865941295a6411a694b" }
 tokio = {version = "1.40.0", features = ["macros", "rt-multi-thread"]}
 toml = "0.7.8"
 tower-http = {version = "0.4.4", features = ["cors"]}

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.86.0"
+channel = "1.87.0"
diff --git a/src/config.rs b/src/config.rs
@@ -1,6 +1,6 @@
 use serde::de::{MapAccess, Visitor};
 use serde::{Deserialize, Deserializer};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use starknet::core::utils::cairo_short_string_to_felt;
 use std::collections::HashMap;
 use std::env;
@@ -32,14 +32,14 @@ pub_struct!(Clone, Deserialize; Database {
 });
 
 pub_struct!(Clone, Deserialize; Contracts {
-    starknetid: FieldElement,
-    naming: FieldElement,
-    verifiers: Vec<FieldElement>,
-    old_verifier: FieldElement,
-    pop_verifier: FieldElement,
-    pp_verifier: FieldElement,
-    argent_multicall: FieldElement,
-    free_domains: FieldElement,
+    starknetid: Felt,
+    naming: Felt,
+    verifiers: Vec<Felt>,
+    old_verifier: Felt,
+    pop_verifier: Felt,
+    pp_verifier: Felt,
+    argent_multicall: Felt,
+    free_domains: Felt,
 });
 
 pub_struct!(Clone, Deserialize; Paymaster {
@@ -54,30 +54,30 @@ pub_struct!(Clone, Deserialize; Starkscan {
 
 pub_struct!(Clone, Deserialize; Solana {
     rpc_url: String,
-    private_key: FieldElement,
+    private_key: Felt,
 });
 
 pub_struct!(Clone, Debug, Deserialize; AltcoinData {
-    address: FieldElement,
+    address: Felt,
     min_price: u64,
     max_price: u64,
     decimals: u32,
     max_quote_validity: i64,
-    auto_renew_contract: Option<FieldElement>,
+    auto_renew_contract: Option<Felt>,
 });
 
 #[derive(Debug, Deserialize)]
 struct TempAltcoins {
     avnu_api: String,
-    private_key: FieldElement,
+    private_key: Felt,
     #[serde(flatten)]
     data: HashMap<String, AltcoinData>,
 }
 
 pub_struct!(Clone, Debug; Altcoins {
     avnu_api: String,
-    private_key: FieldElement,
-    data: HashMap<FieldElement, AltcoinData>,
+    private_key: Felt,
+    data: HashMap<Felt, AltcoinData>,
 });
 
 pub_struct!(Clone, Debug, Deserialize; Variables {
@@ -111,13 +111,13 @@ pub_struct!(Clone, Debug, Deserialize; Evm {
 pub struct OffchainResolvers(HashMap<String, OffchainResolver>);
 
 pub_struct!(Clone, Debug, Deserialize; EvmRecordVerifier {
-    verifier_contracts: Vec<FieldElement>,
+    verifier_contracts: Vec<Felt>,
     field: String,
     handler: HandlerType,
 });
 
 pub_struct!(Clone, Debug, Deserialize; FreeDomains {
-    priv_key: FieldElement,
+    priv_key: Felt,
 });
 
 #[derive(Deserialize)]
@@ -152,9 +152,9 @@ pub_struct!(Clone, Deserialize; Config {
     altcoins: Altcoins,
     offchain_resolvers: OffchainResolvers,
     evm: Evm,
-    evm_networks: HashMap<u64, FieldElement>,
+    evm_networks: HashMap<u64, Felt>,
     evm_records_verifiers: HashMap<String, EvmRecordVerifier>,
-    subscription_to_altcoin: HashMap<FieldElement, String>,
+    subscription_to_altcoin: HashMap<Felt, String>,
     free_domains: FreeDomains,
     watchtower: Watchtower,
 });
@@ -175,7 +175,7 @@ pub_struct!(Clone, Deserialize; WatchtowerTypes {
 
 impl Altcoins {
     fn new(temp: TempAltcoins) -> Self {
-        let data: HashMap<FieldElement, AltcoinData> = temp
+        let data: HashMap<Felt, AltcoinData> = temp
             .data
             .into_values()
             .map(|val| {
@@ -347,14 +347,14 @@ impl Default for Config {
                 github_api_url: "https://api.github.com".to_string(),
             },
             contracts: Contracts {
-                starknetid: FieldElement::default(),
-                naming: FieldElement::default(),
+                starknetid: Felt::default(),
+                naming: Felt::default(),
                 verifiers: vec![],
-                old_verifier: FieldElement::default(),
-                pop_verifier: FieldElement::default(),
-                pp_verifier: FieldElement::default(),
-                argent_multicall: FieldElement::default(),
-                free_domains: FieldElement::default(),
+                old_verifier: Felt::default(),
+                pop_verifier: Felt::default(),
+                pp_verifier: Felt::default(),
+                argent_multicall: Felt::default(),
+                free_domains: Felt::default(),
             },
             paymaster: Paymaster {
                 api_key: "default_api_key".to_string(),
@@ -368,11 +368,11 @@ impl Default for Config {
             reversed_resolvers: HashMap::new(),
             solana: Solana {
                 rpc_url: "https://solana-api.example.com".to_string(),
-                private_key: FieldElement::default(),
+                private_key: Felt::default(),
             },
             altcoins: Altcoins {
                 avnu_api: "https://api.example.com".to_string(),
-                private_key: FieldElement::default(),
+                private_key: Felt::default(),
                 data: HashMap::new(),
             },
             offchain_resolvers: OffchainResolvers(HashMap::new()),
@@ -383,7 +383,7 @@ impl Default for Config {
             evm_records_verifiers: HashMap::new(),
             subscription_to_altcoin: HashMap::new(),
             free_domains: FreeDomains {
-                priv_key: FieldElement::default(),
+                priv_key: Felt::default(),
             },
             watchtower: Watchtower {
                 enabled: false,

diff --git a/src/ecdsa_sign.rs b/src/ecdsa_sign.rs
@@ -2,13 +2,13 @@ use crypto_bigint::{Encoding, NonZero, U256};
 use rand::{rngs::StdRng, Rng, SeedableRng};
 use starknet::core::{
     crypto::{EcdsaSignError, ExtendedSignature},
-    types::FieldElement,
+    types::Felt,
 };
 use starknet_crypto::{rfc6979_generate_k, sign, SignError};
 
 pub fn non_determinist_ecdsa_sign(
-    private_key: &FieldElement,
-    message_hash: &FieldElement,
+    private_key: &Felt,
+    message_hash: &Felt,
 ) -> Result<ExtendedSignature, EcdsaSignError> {
     // Seed-retry logic ported from `cairo-lang`
     let mut seed = Some(from_random());
@@ -25,15 +25,15 @@ pub fn non_determinist_ecdsa_sign(
             Err(SignError::InvalidK) => {
                 // Bump seed and retry
                 seed = match seed {
-                    Some(prev_seed) => Some(prev_seed + FieldElement::ONE),
-                    None => Some(FieldElement::ONE),
+                    Some(prev_seed) => Some(prev_seed + Felt::ONE),
+                    None => Some(Felt::ONE),
                 };
             }
         };
     }
 }
 
-fn from_random() -> FieldElement {
+fn from_random() -> Felt {
     const PRIME: NonZero<U256> = NonZero::from_uint(U256::from_be_hex(
         "0800000000000011000000000000000000000000000000000000000000000001",
     ));
@@ -46,7 +46,7 @@ fn from_random() -> FieldElement {
     let secret_scalar = random_u256.rem(&PRIME);
 
     // It's safe to unwrap here as we're 100% sure it's not out of range
-    let secret_scalar = FieldElement::from_byte_slice_be(&secret_scalar.to_be_bytes()).unwrap();
+    let secret_scalar = Felt::from_bytes_be(&secret_scalar.to_be_bytes());
 
     secret_scalar
 }
diff --git a/src/endpoints/addr_has_rev.rs b/src/endpoints/addr_has_rev.rs
@@ -11,7 +11,7 @@ use axum::{
 use axum_auto_routes::route;
 use mongodb::bson::doc;
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc;
 
 #[derive(Serialize)]
@@ -21,7 +21,7 @@ pub struct AddrToDomainData {
 
 #[derive(Deserialize)]
 pub struct AddrHasRevQuery {
-    addr: FieldElement,
+    addr: Felt,
 }
 
 #[route(get, "/addr_has_rev", crate::endpoints::addr_has_rev)]

diff --git a/src/endpoints/addr_to_available_ids.rs b/src/endpoints/addr_to_available_ids.rs
@@ -13,7 +13,7 @@ use axum_auto_routes::route;
 use futures::StreamExt;
 use mongodb::bson::doc;
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc;
 
 #[derive(Serialize)]
@@ -23,7 +23,7 @@ pub struct AvailableIds {
 
 #[derive(Deserialize)]
 pub struct AddrQuery {
-    addr: FieldElement,
+    addr: Felt,
 }
 
 #[route(get, "/addr_to_available_ids", crate::endpoints::addr_to_available_ids)]
@@ -72,12 +72,15 @@ pub async fn handler(
                         if let Some(doc) = doc_opt {
                             let domain_rs = doc.get_str("domain");
                             if let Ok(domain) = domain_rs {
-                                if get_custom_resolver(&domains, domain ,&state).await.is_none() {
+                                if get_custom_resolver(&domains, domain, &state)
+                                    .await
+                                    .is_none()
+                                {
                                     continue;
                                 }
                             }
                         }
-                        ids.push(FieldElement::from_hex_be(&token_id).unwrap().to_string());
+                        ids.push(Felt::from_hex(&token_id).unwrap().to_string());
                     }
                 }
             }

diff --git a/src/endpoints/addr_to_domain.rs b/src/endpoints/addr_to_domain.rs
@@ -17,7 +17,7 @@ use mongodb::{
     Cursor,
 };
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc;
 
 #[derive(Serialize)]
@@ -28,7 +28,7 @@ pub struct AddrToDomainData {
 
 #[derive(Deserialize)]
 pub struct AddrToDomainQuery {
-    addr: FieldElement,
+    addr: Felt,
 }
 
 async fn read_cursor(mut cursor: Cursor<Document>) -> Result<AddrToDomainData> {

diff --git a/src/endpoints/addr_to_external_domains.rs b/src/endpoints/addr_to_external_domains.rs
@@ -11,7 +11,7 @@ use axum_auto_routes::route;
 use futures::StreamExt;
 use mongodb::bson::doc;
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc; // for stream handling
 
 #[derive(Serialize)]
@@ -21,7 +21,7 @@ pub struct DomainData {
 
 #[derive(Deserialize)]
 pub struct DomainQuery {
-    addr: FieldElement,
+    addr: Felt,
 }
 
 #[route(
@@ -58,8 +58,7 @@ pub async fn handler(
                         let domain_slice =
                             doc.get_str("domain_slice").unwrap_or_default().to_owned();
                         let resolver =
-                            FieldElement::from_hex_be(doc.get_str("resolver").unwrap_or_default())
-                                .unwrap();
+                            Felt::from_hex(doc.get_str("resolver").unwrap_or_default()).unwrap();
                         match state.conf.custom_resolvers.get(&to_hex(&resolver)) {
                             // a resolver can be associated to multiple domains, eg: argent.stark and ag.stark
                             Some(parents) => {

diff --git a/src/endpoints/addr_to_full_ids.rs b/src/endpoints/addr_to_full_ids.rs
@@ -16,7 +16,7 @@ use mongodb::{
     options::AggregateOptions,
 };
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc;
 
 #[derive(Serialize, Deserialize)]
@@ -42,7 +42,7 @@ struct NFTPP {
 
 #[derive(Deserialize)]
 pub struct AddrQuery {
-    addr: FieldElement,
+    addr: Felt,
 }
 
 #[derive(Serialize)]
@@ -155,11 +155,9 @@ pub async fn handler(
             let mut temp_full_ids = Vec::new();
             while let Some(doc) = cursor.next().await {
                 if let Ok(doc) = doc {
-                    let id = FieldElement::from_hex_be(
-                        &doc.get_str("id").unwrap_or_default().to_owned(),
-                    )
-                    .unwrap()
-                    .to_string();
+                    let id = Felt::from_hex(&doc.get_str("id").unwrap_or_default().to_owned())
+                        .unwrap()
+                        .to_string();
                     let domain = doc.get_str("domain").ok().map(String::from);
                     let domain_expiry = doc.get_i64("domain_expiry").ok();
                     temp_full_ids.push(TempsFullId {

diff --git a/src/endpoints/addr_to_token_id.rs b/src/endpoints/addr_to_token_id.rs
@@ -10,7 +10,7 @@ use axum::{
 use axum_auto_routes::route;
 use mongodb::bson::{doc, Bson};
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc;
 
 #[derive(Serialize)]
@@ -20,7 +20,7 @@ pub struct TokenIdData {
 
 #[derive(Deserialize)]
 pub struct TokenIdQuery {
-    addr: FieldElement,
+    addr: Felt,
 }
 
 #[route(get, "/addr_to_token_id", crate::endpoints::addr_to_token_id)]
@@ -50,7 +50,7 @@ pub async fn handler(
             headers.insert("Cache-Control", HeaderValue::from_static("max-age=30"));
 
             if let Some(doc) = doc {
-                let id = FieldElement::from_hex_be(doc.get_str("id").unwrap_or_default())
+                let id = Felt::from_hex(doc.get_str("id").unwrap_or_default())
                     .unwrap()
                     .to_string();
                 let data = TokenIdData { token_id: id };

diff --git a/src/endpoints/addrs_to_domains.rs b/src/endpoints/addrs_to_domains.rs
@@ -13,7 +13,7 @@ use mongodb::{
     Cursor,
 };
 use serde::{Deserialize, Serialize};
-use starknet::core::types::FieldElement;
+use starknet::core::types::Felt;
 use std::sync::Arc;
 
 #[derive(Serialize, Debug)]
@@ -24,7 +24,7 @@ struct AddrToDomainData {
 
 #[derive(Deserialize)]
 pub struct AddrToDomainsQuery {
-    addresses: Vec<FieldElement>,
+    addresses: Vec<Felt>,
 }
 
 async fn process_cursor(