ash_sdk 0.4.5

Ash Rust SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2023, E36 Knots

// Module that contains code to interact with Subnet-EVM precompiles

include!(concat!(env!("OUT_DIR"), "/warp_messenger.rs"));

use crate::{avalanche::blockchains::AvalancheBlockchain, errors::*};
use avalanche_types::ids::Id;
use ethers::{
    core::types::{Address, BlockNumber, Log, H256},
    providers::{Http, Middleware, Provider},
};

/// WarpMessenger precompile address
pub const WARP_MESSENGER_ADDRESS: &str = "0x0200000000000000000000000000000000000005";

/// WarpMessenger precompile HTTP provider
#[derive(Debug, Clone)]
pub struct WarpMessengerHttp {
    pub chain_id: Id,
    pub contract: WarpMessenger<Provider<Http>>,
}

impl WarpMessengerHttp {
    /// Create a new WarpMessengerHttp instance
    pub fn new(chain: &AvalancheBlockchain) -> Result<WarpMessengerHttp, AshError> {
        let client = chain.get_ethers_provider()?;
        let warp_messenger = WarpMessenger::new(
            WARP_MESSENGER_ADDRESS.parse::<Address>().unwrap(),
            client.into(),
        );

        Ok(WarpMessengerHttp {
            chain_id: chain.id,
            contract: warp_messenger,
        })
    }

    /// Get the blockchain ID as seen by the WarpMessenger precompile
    pub async fn get_blockchain_id(&self) -> Result<H256, AshError> {
        let blockchain_id = self
            .contract
            .get_blockchain_id()
            .call()
            .await
            .map_err(|e| RpcError::EthCallFailure {
                contract_addr: self.contract.address().to_string(),
                function_name: "getBlockchainID".to_string(),
                msg: e.to_string(),
            })?;

        Ok(H256::from_slice(&blockchain_id))
    }

    /// Get SendWarpMessage event logs emitted between 2 blocks
    /// Filter by destination_chain_id, destination_address and sender
    /// Return the list of event logs ordered
    pub async fn get_send_warp_message_logs(
        &self,
        from_block: BlockNumber,
        to_block: BlockNumber,
        destination_chain_id: Option<H256>,
        destination_address: Option<Address>,
        sender: Option<Address>,
    ) -> Result<Vec<Log>, AshError> {
        // Do not use the auto generated event filter because it does not work for some reason
        // let mut event_filter = self
        //     .contract
        //     .event::<SendWarpMessageFilter>()
        //     .from_block(from_block)
        //     .to_block(to_block);

        let mut event_filter = ethers::types::Filter::new()
            .address(self.contract.address())
            .from_block(from_block)
            .to_block(to_block);

        event_filter = match destination_chain_id {
            Some(chain_id) => event_filter.topic1(chain_id),
            None => event_filter,
        };
        event_filter = match destination_address {
            Some(address) => event_filter.topic2(address),
            None => event_filter,
        };
        event_filter = match sender {
            Some(address) => event_filter.topic3(address),
            None => event_filter,
        };

        let events = self
            .contract
            .client()
            .provider()
            .get_logs(&event_filter)
            .await
            .map_err(|e| RpcError::EthLogsFailure {
                contract_addr: self.contract.address().to_string(),
                msg: e.to_string(),
            })?;

        Ok(events)
    }
}