Merge branch 'main' of github.com:kkrt-labs/kakarot-rpc into dev/upda…

…te-nonce-for-evm-accounts

crates/core/src/client/config.rs

@@ -61,7 +61,7 @@ impl Network {
 
 #[derive(Default, Clone)]
 /// Configuration for the Starknet RPC client.
-pub struct StarknetConfig {
+pub struct KakarotRpcConfig {
     /// Starknet network.
     pub network: Network,
     /// Kakarot contract address.
@@ -74,15 +74,15 @@ pub struct StarknetConfig {
     pub contract_account_class_hash: FieldElement,
 }
 
-impl StarknetConfig {
+impl KakarotRpcConfig {
     pub fn new(
         network: Network,
         kakarot_address: FieldElement,
         proxy_account_class_hash: FieldElement,
         externally_owned_account_class_hash: FieldElement,
         contract_account_class_hash: FieldElement,
     ) -> Self {
-        StarknetConfig {
+        KakarotRpcConfig {
             network,
             kakarot_address,
             proxy_account_class_hash,
@@ -113,7 +113,7 @@ impl StarknetConfig {
         let externally_owned_account_class_hash = field_element_from_env("EXTERNALLY_OWNED_ACCOUNT_CLASS_HASH")?;
         let contract_account_class_hash = field_element_from_env("CONTRACT_ACCOUNT_CLASS_HASH")?;
 
-        Ok(StarknetConfig::new(
+        Ok(KakarotRpcConfig::new(
             network,
             kakarot_address,
             proxy_account_class_hash,
@@ -159,7 +159,7 @@ impl JsonRpcClientBuilder<HttpTransport> {
     /// let starknet_provider: JsonRpcClient<HttpTransport> =
     ///     JsonRpcClientBuilder::with_http(&config).unwrap().build();
     /// ```
-    pub fn with_http(config: &StarknetConfig) -> Result<Self> {
+    pub fn with_http(config: &KakarotRpcConfig) -> Result<Self> {
         let url = config.network.provider_url()?;
         let transport = HttpTransport::new(url);
         Ok(Self::new(transport))

crates/core/src/client/mod.rs

@@ -34,7 +34,7 @@ use starknet::providers::{MaybeUnknownErrorCode, Provider, ProviderError, Starkn
 use starknet::signers::LocalWallet;
 
 use self::api::{KakarotEthApi, KakarotStarknetApi};
-use self::config::{Network, StarknetConfig};
+use self::config::{KakarotRpcConfig, Network};
 use self::constants::gas::{BASE_FEE_PER_GAS, MAX_PRIORITY_FEE_PER_GAS, MINIMUM_GAS_FEE};
 use self::constants::{
     CHAIN_ID, CHUNK_SIZE_LIMIT, COUNTER_CALL_MAINNET, COUNTER_CALL_TESTNET1, COUNTER_CALL_TESTNET2,
@@ -71,11 +71,11 @@ pub struct KakarotClient<P: Provider + Send + Sync> {
 impl<P: Provider + Send + Sync + 'static> KakarotClient<P> {
     /// Create a new `KakarotClient`.
     pub fn new(
-        starknet_config: StarknetConfig,
+        starknet_config: KakarotRpcConfig,
         starknet_provider: Arc<P>,
         starknet_account: SingleOwnerAccount<Arc<P>, LocalWallet>,
     ) -> Self {
-        let StarknetConfig {
+        let KakarotRpcConfig {
             kakarot_address,
             proxy_account_class_hash,
             externally_owned_account_class_hash,

crates/core/src/mock/mock_starknet.rs

@@ -16,7 +16,7 @@ use super::constants::{
     CONTRACT_ACCOUNT_CLASS_HASH, EXTERNALLY_OWNED_ACCOUNT_CLASS_HASH, KAKAROT_ADDRESS, KAKAROT_TESTNET_ADDRESS,
     PROXY_ACCOUNT_CLASS_HASH,
 };
-use crate::client::config::{Network, SequencerGatewayProviderBuilder, StarknetConfig};
+use crate::client::config::{KakarotRpcConfig, Network, SequencerGatewayProviderBuilder};
 use crate::client::KakarotClient;
 
 /// A fixture for a Starknet RPC call.
@@ -212,7 +212,7 @@ pub fn mock_starknet_provider(fixtures: Option<Vec<StarknetRpcFixture>>) -> Json
 
 pub fn init_testnet_client() -> KakarotClient<SequencerGatewayProvider> {
     let kakarot_address = FieldElement::from_hex_be(KAKAROT_TESTNET_ADDRESS).unwrap();
-    let config = StarknetConfig::new(
+    let config = KakarotRpcConfig::new(
         Network::Goerli1Gateway,
         kakarot_address,
         Default::default(),
@@ -232,7 +232,7 @@ pub fn init_mock_client(
     let starknet_provider = Arc::new(mock_starknet_provider(fixtures));
     let starknet_account = mock_account(starknet_provider.clone());
 
-    let config = StarknetConfig::new(
+    let config = KakarotRpcConfig::new(
         Network::Katana,
         *KAKAROT_ADDRESS,
         *PROXY_ACCOUNT_CLASS_HASH,

crates/core/tests/api.rs

@@ -0,0 +1,173 @@
+mod tests {
+
+    use std::str::FromStr;
+
+    use ethers::abi::Token;
+    use kakarot_rpc_core::client::api::KakarotEthApi;
+    use kakarot_rpc_core::mock::constants::ACCOUNT_ADDRESS_EVM;
+    use kakarot_rpc_core::models::balance::{TokenBalance, TokenBalances};
+    use kakarot_test_utils::deploy_helpers::KakarotTestEnvironmentContext;
+    use kakarot_test_utils::execution_helpers::execute_eth_tx;
+    use kakarot_test_utils::fixtures::kakarot_test_env_ctx;
+    use reth_primitives::{Address, BlockId, BlockNumberOrTag, Bytes, H256, U256};
+    use reth_rpc_types::{Filter, FilterBlockOption, FilterChanges, Log, ValueOrArray};
+    use rstest::*;
+    use starknet::core::types::FieldElement;
+
+    #[rstest]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_eoa_balance(kakarot_test_env_ctx: KakarotTestEnvironmentContext) {
+        // Given
+        let (client, kakarot) = kakarot_test_env_ctx.resources();
+
+        // When
+        let eoa_balance = client
+            .balance(kakarot.eoa_addresses.eth_address, BlockId::Number(reth_primitives::BlockNumberOrTag::Latest))
+            .await
+            .unwrap();
+        let eoa_balance = FieldElement::from_bytes_be(&eoa_balance.to_be_bytes()).unwrap();
+
+        // Then
+        assert_eq!(FieldElement::from_dec_str("1000000000000000000").unwrap(), eoa_balance);
+    }
+
+    #[rstest]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_token_balances(kakarot_test_env_ctx: KakarotTestEnvironmentContext) {
+        // Given
+        let (client, kakarot, _, erc20_eth_address) = kakarot_test_env_ctx.resources_with_contract("ERC20");
+
+        // When
+        let to = Address::from_slice(&kakarot.eoa_addresses.eth_address.to_fixed_bytes()[..]);
+        let amount = U256::from(10_000);
+        execute_eth_tx(
+            &kakarot_test_env_ctx,
+            "ERC20",
+            "mint",
+            vec![Token::Address(to.into()), Token::Uint(amount.into())],
+        )
+        .await;
+
+        // Then
+        let balances = client.token_balances(kakarot.eoa_addresses.eth_address, vec![erc20_eth_address]).await.unwrap();
+        assert_eq!(
+            TokenBalances {
+                address: kakarot.eoa_addresses.eth_address,
+                token_balances: vec![TokenBalance {
+                    token_address: erc20_eth_address,
+                    token_balance: Some(U256::from(10_000)),
+                    error: None
+                }]
+            },
+            balances
+        );
+    }
+
+    #[rstest]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_storage_at(kakarot_test_env_ctx: KakarotTestEnvironmentContext) {
+        // Given
+        let (client, _, _, counter_eth_address) = kakarot_test_env_ctx.resources_with_contract("Counter");
+        // When
+        execute_eth_tx(&kakarot_test_env_ctx, "Counter", "inc", vec![]).await;
+
+        // Then
+        let count = client
+            .storage_at(counter_eth_address, U256::from(0), BlockId::Number(BlockNumberOrTag::Latest))
+            .await
+            .unwrap();
+        assert_eq!(U256::from(1), count);
+    }
+
+    #[rstest]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_get_logs(kakarot_test_env_ctx: KakarotTestEnvironmentContext) {
+        // Given
+        let (client, kakarot, _, erc20_eth_address) = kakarot_test_env_ctx.resources_with_contract("ERC20");
+
+        // When
+        let amount = U256::from(10_000);
+        let mint_tx_hash = execute_eth_tx(
+            &kakarot_test_env_ctx,
+            "ERC20",
+            "mint",
+            vec![
+                Token::Address(Address::from_slice(&kakarot.eoa_addresses.eth_address.to_fixed_bytes()[..]).into()),
+                Token::Uint(amount.into()),
+            ],
+        )
+        .await;
+
+        let to = Address::from_slice(ACCOUNT_ADDRESS_EVM.as_bytes());
+        let transfer_tx_hash = execute_eth_tx(
+            &kakarot_test_env_ctx,
+            "ERC20",
+            "transfer",
+            vec![Token::Address(to.into()), Token::Uint(amount.into())],
+        )
+        .await;
+
+        let filter = Filter {
+            block_option: FilterBlockOption::Range {
+                from_block: Some(BlockNumberOrTag::Number(0)),
+                to_block: Some(BlockNumberOrTag::Number(100)),
+            },
+            address: ValueOrArray::Value(erc20_eth_address).into(),
+            topics: [
+                ValueOrArray::Value(None).into(),
+                ValueOrArray::Value(None).into(),
+                ValueOrArray::Value(None).into(),
+                ValueOrArray::Value(None).into(),
+            ],
+        };
+        let logs = client.get_logs(filter).await.unwrap();
+
+        // Then
+        match logs {
+            FilterChanges::Logs(logs) => {
+                assert_eq!(2, logs.len());
+                assert_eq!(
+                    Log {
+                        address: erc20_eth_address,
+                        topics: vec![
+                            H256::from_str("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
+                                .unwrap(), // keccak256(“Transfer(address,address,uint256)”)
+                            H256::from_low_u64_be(0u64),                   // from
+                            H256::from(kakarot.eoa_addresses.eth_address)  // to
+                        ],
+                        data: Bytes::from_str("0x0000000000000000000000000000000000000000000000000000000000002710")
+                            .unwrap(), // amount
+                        block_hash: logs[0].block_hash, // block hash changes so just set to event value
+                        block_number: logs[0].block_number, // block number changes so just set to event value
+                        transaction_hash: Some(mint_tx_hash),
+                        transaction_index: None,
+                        log_index: None,
+                        removed: false
+                    },
+                    logs[0]
+                );
+                assert_eq!(
+                    Log {
+                        address: erc20_eth_address,
+                        topics: vec![
+                            H256::from_str("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
+                                .unwrap(), // keccak256("Transfer(address,address,uint256)")
+                            H256::from(kakarot.eoa_addresses.eth_address), // from
+                            H256::from(*ACCOUNT_ADDRESS_EVM)               // to
+                        ],
+                        data: Bytes::from_str("0x0000000000000000000000000000000000000000000000000000000000002710")
+                            .unwrap(), // amount
+                        block_hash: logs[1].block_hash, // block hash changes so just set to event value
+                        block_number: logs[1].block_number, // block number changes so just set to event value
+                        transaction_hash: Some(transfer_tx_hash),
+                        transaction_index: None,
+                        log_index: None,
+                        removed: false
+                    },
+                    logs[1]
+                );
+            }
+            _ => panic!("Expected FilterChanges::Logs variant, got {:?}", logs),
+        }
+    }
+}

crates/core/tests/contracts.rs

@@ -0,0 +1,34 @@
+use kakarot_rpc_core::client::api::KakarotEthApi;
+use kakarot_rpc_core::client::constants::TX_ORIGIN_ZERO;
+use kakarot_test_utils::deploy_helpers::KakarotTestEnvironmentContext;
+use kakarot_test_utils::execution_helpers::execute_eth_tx;
+use kakarot_test_utils::fixtures::kakarot_test_env_ctx;
+use reth_primitives::BlockId;
+use rstest::*;
+
+#[rstest]
+#[tokio::test(flavor = "multi_thread")]
+async fn test_counter(kakarot_test_env_ctx: KakarotTestEnvironmentContext) {
+    // Given
+    let (client, _, counter, counter_eth_address) = kakarot_test_env_ctx.resources_with_contract("Counter");
+
+    // When
+    let hash = execute_eth_tx(&kakarot_test_env_ctx, "Counter", "inc", vec![]).await;
+    client.transaction_receipt(hash).await.expect("increment transaction failed");
+
+    let count_selector = counter.abi.function("count").unwrap().short_signature();
+    let counter_bytes = client
+        .call(
+            *TX_ORIGIN_ZERO,
+            counter_eth_address,
+            count_selector.into(),
+            BlockId::Number(reth_primitives::BlockNumberOrTag::Latest),
+        )
+        .await
+        .unwrap();
+
+    let num = *counter_bytes.last().expect("Empty byte array");
+
+    // Then
+    assert_eq!(num, 1);
+}