hermes-cli 0.1.0

Hermes: IBC Relayer in Rust
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use futures::stream::{self, StreamExt};
use hermes_cli_components::traits::build::CanLoadBuilder;
use hermes_cli_framework::command::CommandRunner;
use hermes_cli_framework::output::Output;
use hermes_relayer_components::build::traits::builders::birelay_builder::CanBuildBiRelay;
use hermes_relayer_components::relay::traits::packet_clearer::CanClearPackets;
use ibc_relayer_types::core::ics24_host::identifier::{ChainId, ChannelId, ClientId, PortId};

use crate::contexts::app::HermesApp;
use crate::Result;

#[derive(Debug, clap::Parser)]
pub struct PacketsClear {
    #[clap(
        long = "chain",
        required = true,
        value_name = "CHAIN_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the chain to query"
    )]
    chain_id: ChainId,

    #[clap(
        long = "port",
        required = true,
        value_name = "PORT_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the port"
    )]
    port_id: PortId,

    #[clap(
        long = "channel",
        alias = "chan",
        required = true,
        value_name = "CHANNEL_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the channel"
    )]
    channel_id: ChannelId,

    #[clap(
        long = "client",
        required = true,
        value_name = "CLIENT_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the client"
    )]
    client_id: ClientId,

    #[clap(
        long = "counterparty-chain",
        required = true,
        value_name = "COUNTERPARTY_CHAIN_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the counterparty chain to query"
    )]
    counterparty_chain_id: ChainId,

    #[clap(
        long = "counterparty-client",
        required = true,
        value_name = "COUNTERPARTY_CLIENT_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the counterparty client"
    )]
    counterparty_client_id: ClientId,

    #[clap(
        long = "counterparty-port",
        required = true,
        value_name = "COUNTERPARTY_PORT_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the counterparty port"
    )]
    counterparty_port_id: PortId,

    #[clap(
        long = "counterparty-channel",
        required = true,
        value_name = "COUNTERPARTY_CHANNEL_ID",
        help_heading = "REQUIRED",
        help = "Identifier of the counterparty channel"
    )]
    counterparty_channel_id: ChannelId,
}

impl CommandRunner<HermesApp> for PacketsClear {
    async fn run(&self, app: &HermesApp) -> Result<Output> {
        let builder = app.load_builder().await?;

        let relayer = builder
            .build_birelay(
                &self.chain_id,
                &self.counterparty_chain_id,
                &self.client_id,
                &self.counterparty_client_id, // nothing to pass here
            )
            .await?;

        stream::iter(vec![
            relayer.relay_a_to_b.clear_packets(
                &self.channel_id,
                &self.port_id,
                &self.counterparty_channel_id,
                &self.counterparty_port_id,
            ),
            relayer.relay_b_to_a.clear_packets(
                &self.counterparty_channel_id,
                &self.counterparty_port_id,
                &self.channel_id,
                &self.port_id,
            ),
        ])
        .for_each_concurrent(None, |x| async {
            let _ = x.await;
        })
        .await;

        Ok(Output::success("Packet clear"))
    }
}