Relayer v2 architecture redesign and new packet worker MVP

.github/workflows/integration.yaml

@@ -100,7 +100,7 @@ jobs:
  run: |
  nix shell .#python .#${{ matrix.chain.package }} -c cargo \
  test -p ibc-integration-test --no-fail-fast -- \
- --nocapture --test-threads=2
+ --nocapture --test-threads=1
 
  ordered-channel-test:
  runs-on: ubuntu-latest

Cargo.toml

@@ -5,6 +5,9 @@ resolver = "2"
 members = [
  "modules",
  "relayer",
+ "relayer-framework",
+ "relayer-framework-guide",
+ "relayer-cosmos",
  "relayer-cli",
  "relayer-rest",
  "telemetry",

clippy.toml

@@ -1 +1 @@
-msrv = "1.60.0"
+msrv = "1.63.0"

docs/architecture/adr-012-ibc-relayer-v1.5.md

@@ -0,0 +1,9 @@
+# ADR 012: IBC Relayer V1.5
+
+## Changelog
+
+* 2022-07-29: Initial Draft
+
+## Problem Statement
+
+## Context

flake.nix

@@ -43,6 +43,10 @@
  apalache
  ;
 
+ inherit (nixpkgs)
+ mdbook
+ ;
+
  python = nixpkgs.python3.withPackages (p: [
  p.toml
  ]);

modules/src/core/ics02_client/client_consensus.rs

@@ -36,6 +36,7 @@ pub trait ConsensusState: Clone + core::fmt::Debug + Send + Sync {
  fn wrap_any(self) -> AnyConsensusState;
 }
 
+#[non_exhaustive]
 #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 #[serde(tag = "type")]
 pub enum AnyConsensusState {

modules/src/core/ics02_client/height.rs

@@ -2,6 +2,7 @@ use crate::prelude::*;
 use core::cmp::Ordering;
 
 use core::num::ParseIntError;
+use core::ops::Add;
 use core::str::FromStr;
 
 use flex_error::{define_error, TraceError};
@@ -68,6 +69,17 @@ impl Height {
  }
 }
 
+impl Add<u64> for Height {
+ type Output = Self;
+
+ fn add(self, delta: u64) -> Self {
+ Self {
+ revision_number: self.revision_number,
+ revision_height: self.revision_height + delta,
+ }
+ }
+}
+
 impl PartialOrd for Height {
  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  Some(self.cmp(other))

modules/src/core/ics04_channel/error.rs

@@ -160,6 +160,9 @@ define_error! {
  InvalidAcknowledgement
  | _ | { "Acknowledgment cannot be empty" },
 
+ InvalidAcknowledgementEvent
+ | _ | { "IBC event is not a write acknowledgement event" },
+
  AcknowledgementExists
  { sequence: Sequence }
  | e | {

modules/src/core/ics04_channel/events.rs

@@ -712,6 +712,17 @@ impl From<WriteAcknowledgement> for IbcEvent {
  }
 }
 
+impl TryFrom<IbcEvent> for WriteAcknowledgement {
+ type Error = Error;
+
+ fn try_from(event: IbcEvent) -> Result<Self, Error> {
+ match event {
+ IbcEvent::WriteAcknowledgement(ev) => Ok(ev),
+ _ => Err(Error::invalid_acknowledgement_event()),
+ }
+ }
+}
+
 impl TryFrom<WriteAcknowledgement> for AbciEvent {
  type Error = Error;
 

modules/src/signer.rs

@@ -17,6 +17,12 @@ define_error! {
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Display)]
 pub struct Signer(String);
 
+impl Signer {
+ pub fn dummy() -> Self {
+ Self("cosmos000000000000000000000000000000000000000".to_string())
+ }
+}
+
 impl FromStr for Signer {
  type Err = SignerError;
 

relayer-cosmos/Cargo.toml

@@ -0,0 +1,54 @@
+[package]
+name = "ibc-relayer-cosmos"
+version = "0.18.0"
+edition = "2021"
+license = "Apache-2.0"
+readme = "README.md"
+keywords = ["blockchain", "consensus", "cosmos", "ibc", "tendermint"]
+repository = "https://github.com/informalsystems/ibc-rs"
+authors = ["Informal Systems <hello@informal.systems>"]
+rust-version = "1.60"
+description = """
+ Implementation of an IBC Relayer in Rust, as a library
+"""
+
+[package.metadata.docs.rs]
+all-features = true
+
+[features]
+default = ["flex-error/std", "flex-error/eyre_tracer"]
+
+[dependencies]
+ibc = { version = "0.18.0", path = "../modules" }
+ibc-proto = { version = "0.20.0", path = "../proto" }
+ibc-relayer = { version = "0.18.0", path = "../relayer" }
+ibc-relayer-framework = { version = "0.18.0", path = "../relayer-framework" }
+
+serde = "1.0"
+serde_derive = "1.0"
+async-trait = "0.1.56"
+flex-error = { version = "0.4.4", default-features = false }
+prost = { version = "0.11" }
+eyre = "0.6.8"
+tokio = "1.19.2"
+itertools = "0.10.3"
+
+[dependencies.tendermint]
+version = "=0.23.9"
+features = ["secp256k1"]
+
+[dependencies.tendermint-rpc]
+version = "=0.23.9"
+features = ["http-client", "websocket-client"]
+
+[dependencies.tendermint-light-client]
+version = "=0.23.9"
+default-features = false
+features = ["rpc-client", "secp256k1", "unstable"]
+
+[dependencies.tendermint-light-client-verifier]
+version = "=0.23.9"
+default-features = false
+
+[dependencies.tendermint-proto]
+version = "=0.23.9"

relayer-cosmos/src/cosmos/context/chain.rs

@@ -0,0 +1,104 @@
+use ibc::core::ics04_channel::events::WriteAcknowledgement;
+use ibc::core::ics04_channel::packet::Sequence;
+use ibc::core::ics24_host::identifier::{ChannelId, ClientId, ConnectionId, PortId};
+use ibc::events::IbcEventType;
+use ibc::signer::Signer;
+use ibc::timestamp::Timestamp;
+use ibc::Height;
+use ibc_relayer::chain::cosmos::types::config::TxConfig;
+use ibc_relayer::chain::cosmos::types::events::channel::extract_packet_and_write_ack_from_tx;
+use ibc_relayer::keyring::KeyEntry;
+use ibc_relayer_framework::traits::contexts::chain::{ChainContext, IbcChainContext};
+use ibc_relayer_framework::traits::contexts::error::HasError;
+use ibc_relayer_framework::traits::contexts::ibc_event::HasIbcEvents;
+use ibc_relayer_framework::traits::contexts::runtime::HasRuntime;
+use ibc_relayer_framework::traits::core::Async;
+use tendermint::abci::responses::Event;
+use tendermint::abci::Event as AbciEvent;
+
+use crate::cosmos::context::runtime::CosmosRuntime;
+use crate::cosmos::error::Error;
+use crate::cosmos::message::CosmosIbcMessage;
+
+#[derive(Clone)]
+pub struct CosmosChainContext<Handle> {
+ pub handle: Handle,
+ pub signer: Signer,
+ pub tx_config: TxConfig,
+ pub key_entry: KeyEntry,
+}
+
+pub struct WriteAcknowledgementEvent(pub WriteAcknowledgement);
+
+impl<Handle: Async> HasError for CosmosChainContext<Handle> {
+ type Error = Error;
+}
+
+impl<Handle: Async> HasRuntime for CosmosChainContext<Handle> {
+ type Runtime = CosmosRuntime;
+
+ fn runtime(&self) -> &CosmosRuntime {
+ &CosmosRuntime
+ }
+}
+
+impl<Handle: Async> ChainContext for CosmosChainContext<Handle> {
+ type Height = Height;
+
+ type Timestamp = Timestamp;
+
+ type Message = CosmosIbcMessage;
+
+ type Event = Event;
+}
+
+impl<Chain, Counterparty> IbcChainContext<CosmosChainContext<Counterparty>>
+ for CosmosChainContext<Chain>
+where
+ Chain: Async,
+ Counterparty: Async,
+{
+ type ClientId = ClientId;
+
+ type ConnectionId = ConnectionId;
+
+ type ChannelId = ChannelId;
+
+ type PortId = PortId;
+
+ type Sequence = Sequence;
+
+ type IbcMessage = CosmosIbcMessage;
+
+ type IbcEvent = Event;
+}
+
+impl TryFrom<AbciEvent> for WriteAcknowledgementEvent {
+ type Error = ();
+
+ fn try_from(event: AbciEvent) -> Result<Self, ()> {
+ if let Ok(IbcEventType::WriteAck) = event.type_str.parse() {
+ let (packet, write_ack) =
+ extract_packet_and_write_ack_from_tx(&event).map_err(|_| ())?;
+
+ let ack = WriteAcknowledgement {
+ height: Height::new(0, 1).unwrap(),
+ packet,
+ ack: write_ack,
+ };
+
+ Ok(WriteAcknowledgementEvent(ack))
+ } else {
+ Err(())
+ }
+ }
+}
+
+impl<Chain, Counterparty> HasIbcEvents<CosmosChainContext<Counterparty>>
+ for CosmosChainContext<Chain>
+where
+ Chain: Async,
+ Counterparty: Async,
+{
+ type WriteAcknowledgementEvent = WriteAcknowledgementEvent;
+}

relayer-cosmos/src/cosmos/context/mod.rs

@@ -0,0 +1,3 @@
+pub mod chain;
+pub mod relay;
+pub mod runtime;