wip

Author: kariy

Cargo.lock

@@ -12,14 +12,17 @@ use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context, Result};
 use ark_ff::PrimeField;
+use katana_contracts::vrf::CartridgeVrfAccount;
 use katana_genesis::constant::DEFAULT_STRK_FEE_TOKEN_ADDRESS;
 use katana_primitives::chain::ChainId;
+use katana_primitives::class::ClassHash;
 use katana_primitives::utils::get_contract_address;
 use katana_primitives::{ContractAddress, Felt};
+use katana_rpc_types::RpcSierraContractClass;
 use stark_vrf::{generate_public_key, ScalarField};
 use starknet::accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
 use starknet::contract::ContractFactory;
-use starknet::core::types::{BlockId, BlockTag, Call, StarknetError};
+use starknet::core::types::{BlockId, BlockTag, Call, FlattenedSierraClass, StarknetError};
 use starknet::macros::selector;
 use starknet::providers::jsonrpc::HttpTransport;
 use starknet::providers::{JsonRpcClient, Provider, ProviderError};
@@ -99,7 +102,8 @@ pub fn derive_vrf_accounts(
 
     let account_public_key =
         SigningKey::from_secret_scalar(bootstrapper_private_key).verifying_key().scalar();
-    let vrf_account_class_hash = katana_contracts::vrf::CartridgeVrfAccount::HASH;
+
+    let vrf_account_class_hash = CartridgeVrfAccount::HASH;
     // When using UDC with unique=0 (non-unique deployment), the deployer_address
     // used in address computation is 0, not the actual deployer or UDC address.
     let vrf_account_address = get_contract_address(
@@ -136,7 +140,8 @@ pub async fn bootstrap_vrf(
     let vrf_account_address = derived.vrf_account_address;
     let account_public_key =
         SigningKey::from_secret_scalar(bootstrapper_account_private_key).verifying_key().scalar();
-    let vrf_account_class_hash = katana_contracts::vrf::CartridgeVrfAccount::HASH;
+
+    let vrf_account_class_hash = CartridgeVrfAccount::HASH;
 
     // Create the source account for transactions
     let signer =
@@ -149,6 +154,22 @@ pub async fn bootstrap_vrf(
         ExecutionEncoding::New,
     );
 
+    if !is_declared(&provider, vrf_account_class_hash).await? {
+        let class = CartridgeVrfAccount::CLASS.clone();
+        let compiled_hash = CartridgeVrfAccount::CASM_HASH;
+
+        let rpc_class = RpcSierraContractClass::from(class.to_sierra().unwrap());
+        let rpc_class = FlattenedSierraClass::try_from(rpc_class).unwrap();
+
+        let result = account
+            .declare_v3(rpc_class.into(), compiled_hash)
+            .send()
+            .await
+            .expect("fail to declare class");
+
+        assert_eq!(result.class_hash, vrf_account_class_hash, "Class hash mismatch");
+    }
+
     // Deploy VRF account if not already deployed
     if !is_deployed(&provider, vrf_account_address).await? {
         #[allow(deprecated)]
@@ -253,6 +274,17 @@ async fn is_deployed(
     }
 }
 
+async fn is_declared(
+    provider: &JsonRpcClient<HttpTransport>,
+    class_hash: ClassHash,
+) -> Result<bool> {
+    match provider.get_class(BlockId::Tag(BlockTag::PreConfirmed), class_hash).await {
+        Ok(_) => Ok(true),
+        Err(ProviderError::StarknetError(StarknetError::ClassHashNotFound)) => Ok(false),
+        Err(e) => Err(anyhow!("failed to check class declaration: {e}")),
+    }
+}
+
 async fn wait_for_contract(
     provider: &JsonRpcClient<HttpTransport>,
     address: ContractAddress,

crates/cartridge/src/vrf/bootstrap.rs

@@ -7,6 +7,7 @@ version.workspace = true
 
 [dependencies]
 katana-primitives.workspace = true
+katana-rpc-types.workspace = true
 katana-contracts.workspace = true
 
 http.workspace = true

crates/paymaster/Cargo.toml

@@ -18,14 +18,16 @@ use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use std::{env, fs, io};
 
+use katana_contracts::avnu::AvnuForwarder;
 use katana_primitives::chain::{ChainId, NamedChainId};
 use katana_primitives::class::ComputeClassHashError;
 use katana_primitives::utils::get_contract_address;
 use katana_primitives::{ContractAddress, Felt};
+use katana_rpc_types::RpcSierraContractClass;
 use serde::Serialize;
 use starknet::accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
 use starknet::contract::ContractFactory;
-use starknet::core::types::{BlockId, BlockTag, Call, StarknetError};
+use starknet::core::types::{BlockId, BlockTag, Call, FlattenedSierraClass, StarknetError};
 use starknet::macros::selector;
 use starknet::providers::jsonrpc::HttpTransport;
 use starknet::providers::{JsonRpcClient, Provider, ProviderError};
@@ -496,17 +498,7 @@ impl PaymasterService {
             chain_id_felt
         };
 
-        let forwarder_class_hash = katana_contracts::avnu::AvnuForwarder::HASH;
-
-        // When using UDC with unique=0 (non-unique deployment), the deployer_address
-        // used in address computation is 0, not the actual deployer or UDC address.
-        let forwarder_address = get_contract_address(
-            Felt::from(FORWARDER_SALT),
-            forwarder_class_hash,
-            &[self.config.relayer_address.into(), self.config.gas_tank_address.into()],
-            Felt::ZERO,
-        )
-        .into();
+        let forwarder_class_hash = AvnuForwarder::HASH;
 
         // Create the relayer account for transactions
         let secret_key = SigningKey::from_secret_scalar(self.config.relayer_private_key);
@@ -518,6 +510,39 @@ impl PaymasterService {
             ExecutionEncoding::New,
         );
 
+        // declare class if not yet declred
+        match provider.get_class(BlockId::Tag(BlockTag::PreConfirmed), forwarder_class_hash).await {
+            Ok(..) => {}
+
+            Err(ProviderError::StarknetError(StarknetError::ClassHashNotFound)) => {
+                let class = AvnuForwarder::CLASS.clone();
+                let compiled_hash = AvnuForwarder::CASM_HASH;
+
+                let rpc_class = RpcSierraContractClass::from(class.to_sierra().unwrap());
+                let rpc_class = FlattenedSierraClass::try_from(rpc_class).unwrap();
+
+                let result = account
+                    .declare_v3(rpc_class.into(), compiled_hash)
+                    .send()
+                    .await
+                    .expect("fail to declare class");
+
+                assert_eq!(result.class_hash, forwarder_class_hash, "Class hash mismatch");
+            }
+
+            Err(..) => panic!("fail to fetch class"),
+        };
+
+        // When using UDC with unique=0 (non-unique deployment), the deployer_address
+        // used in address computation is 0, not the actual deployer or UDC address.
+        let forwarder_address = get_contract_address(
+            Felt::from(FORWARDER_SALT),
+            forwarder_class_hash,
+            &[self.config.relayer_address.into(), self.config.gas_tank_address.into()],
+            Felt::ZERO,
+        )
+        .into();
+
         // Deploy forwarder if not already deployed
         if !is_deployed(&provider, forwarder_address).await? {
             #[allow(deprecated)]

crates/paymaster/src/lib.rs

@@ -229,6 +229,20 @@ impl ContractClass {
             Self::Legacy(..) => 0,
         }
     }
+
+    pub fn to_sierra(self) -> Option<SierraContractClass> {
+        match self {
+            Self::Class(class) => Some(class),
+            _ => None,
+        }
+    }
+
+    pub fn to_legacy(self) -> Option<LegacyContractClass> {
+        match self {
+            Self::Legacy(class) => Some(class),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Debug, thiserror::Error)]

crates/primitives/src/class.rs

@@ -10,9 +10,7 @@ use katana_primitives::class::{
     compute_legacy_class_hash, compute_sierra_class_hash, ClassHash, ComputeClassHashError,
     ContractClass, LegacyContractClass, SierraContractClass,
 };
-use katana_primitives::{
-    Felt, {self},
-};
+use katana_primitives::{self, Felt};
 use serde::{Deserialize, Serialize};
 use serde_utils::base64;
 use starknet::core::types::{CompressedLegacyContractClass, FlattenedSierraClass};