chore: Merge mini-protocols into single crate (#40)

pallas-miniprotocols/examples/blockfetch.rs

@@ -0,0 +1,46 @@
+use net2::TcpStreamExt;
+use pallas_miniprotocols::Point;
+use std::net::TcpStream;
+
+use pallas_miniprotocols::blockfetch::{BatchClient, NoopObserver};
+use pallas_miniprotocols::handshake::{
+    n2n::{Client, VersionTable},
+    MAINNET_MAGIC,
+};
+use pallas_miniprotocols::run_agent;
+use pallas_multiplexer::Multiplexer;
+
+fn main() {
+    env_logger::init();
+
+    //let bearer = TcpStream::connect("localhost:6000").unwrap();
+    let bearer = TcpStream::connect("relays-new.cardano-mainnet.iohk.io:3001").unwrap();
+
+    bearer.set_nodelay(true).unwrap();
+    bearer.set_keepalive_ms(Some(30_000u32)).unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0, 3]).unwrap();
+
+    let mut hs_channel = muxer.use_channel(0);
+    let versions = VersionTable::v4_and_above(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut hs_channel).unwrap();
+    println!("{:?}", last);
+
+    let range = (
+        Point(
+            43847831u64,
+            hex::decode("15b9eeee849dd6386d3770b0745e0450190f7560e5159b1b3ab13b14b2684a45")
+                .unwrap(),
+        ),
+        Point(
+            43847831u64,
+            hex::decode("15b9eeee849dd6386d3770b0745e0450190f7560e5159b1b3ab13b14b2684a45")
+                .unwrap(),
+        ),
+    );
+
+    let mut bf_channel = muxer.use_channel(3);
+    let bf = BatchClient::initial(range, NoopObserver {});
+    let bf_last = run_agent(bf, &mut bf_channel);
+    println!("{:?}", bf_last);
+}

pallas-miniprotocols/examples/chainsync-blocks.rs

@@ -0,0 +1,61 @@
+use pallas_alonzo::{crypto, Block, BlockWrapper, Fragment};
+
+use pallas_miniprotocols::chainsync::{BlockLike, Consumer, NoopObserver};
+use pallas_miniprotocols::handshake::n2c::{Client, VersionTable};
+use pallas_miniprotocols::handshake::MAINNET_MAGIC;
+use pallas_miniprotocols::run_agent;
+use pallas_miniprotocols::Point;
+use pallas_miniprotocols::{DecodePayload, EncodePayload, PayloadDecoder, PayloadEncoder};
+use pallas_multiplexer::Multiplexer;
+use std::os::unix::net::UnixStream;
+
+#[derive(Debug)]
+pub struct Content(Block);
+
+impl EncodePayload for Content {
+    fn encode_payload(&self, _e: &mut PayloadEncoder) -> Result<(), Box<dyn std::error::Error>> {
+        todo!()
+    }
+}
+
+impl DecodePayload for Content {
+    fn decode_payload(d: &mut PayloadDecoder) -> Result<Self, Box<dyn std::error::Error>> {
+        d.tag()?;
+        let bytes = d.bytes()?;
+        let BlockWrapper(_, block) = BlockWrapper::decode_fragment(bytes)?;
+        Ok(Content(block))
+    }
+}
+
+impl BlockLike for Content {
+    fn block_point(&self) -> Result<Point, Box<dyn std::error::Error>> {
+        let hash = crypto::hash_block_header(&self.0.header);
+        Ok(Point(self.0.header.header_body.slot, hash.to_vec()))
+    }
+}
+
+fn main() {
+    env_logger::init();
+
+    // we connect to the unix socket of the local node. Make sure you have the right
+    // path for your environment
+    let bearer = UnixStream::connect("/tmp/node.socket").unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0, 4, 5]).unwrap();
+
+    let mut hs_channel = muxer.use_channel(0);
+    let versions = VersionTable::v1_and_above(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut hs_channel).unwrap();
+    println!("last hanshake state: {:?}", last);
+
+    // some random known-point in the chain to use as starting point for the sync
+    let known_points = vec![Point(
+        45147459,
+        hex::decode("bee16ef28ac02abb50c340a7deff085a77f3a7b84c66250b3318dcb125c19a10").unwrap(),
+    )];
+
+    let mut cs_channel = muxer.use_channel(5);
+    let cs = Consumer::<Content, _>::initial(known_points, NoopObserver {});
+    let cs = run_agent(cs, &mut cs_channel).unwrap();
+    println!("{:?}", cs);
+}

pallas-miniprotocols/examples/chainsync-headers.rs

@@ -0,0 +1,72 @@
+use minicbor::data::Tag;
+use net2::TcpStreamExt;
+use pallas_alonzo::{crypto, Fragment, Header};
+use pallas_miniprotocols::Point;
+use std::net::TcpStream;
+
+use pallas_miniprotocols::chainsync::{BlockLike, Consumer, NoopObserver};
+use pallas_miniprotocols::handshake::n2n::{Client, VersionTable};
+use pallas_miniprotocols::handshake::MAINNET_MAGIC;
+use pallas_miniprotocols::{
+    run_agent, DecodePayload, EncodePayload, PayloadDecoder, PayloadEncoder,
+};
+use pallas_multiplexer::Multiplexer;
+
+#[derive(Debug)]
+pub struct Content(u32, Header);
+
+impl EncodePayload for Content {
+    fn encode_payload(&self, e: &mut PayloadEncoder) -> Result<(), Box<dyn std::error::Error>> {
+        e.array(2)?;
+        e.u32(self.0)?;
+        e.tag(Tag::Cbor)?;
+        e.bytes(&self.1.encode_fragment()?)?;
+
+        Ok(())
+    }
+}
+
+impl DecodePayload for Content {
+    fn decode_payload(d: &mut PayloadDecoder) -> Result<Self, Box<dyn std::error::Error>> {
+        d.array()?;
+        let unknown = d.u32()?; // WTF is this value?
+        d.tag()?;
+        let bytes = d.bytes()?;
+        let header = Header::decode_fragment(bytes)?;
+        Ok(Content(unknown, header))
+    }
+}
+
+impl BlockLike for Content {
+    fn block_point(&self) -> Result<Point, Box<dyn std::error::Error>> {
+        let hash = crypto::hash_block_header(&self.1);
+        Ok(Point(self.1.header_body.slot, hash.to_vec()))
+    }
+}
+
+fn main() {
+    env_logger::init();
+
+    let bearer = TcpStream::connect("relays-new.cardano-mainnet.iohk.io:3001").unwrap();
+    bearer.set_nodelay(true).unwrap();
+    bearer.set_keepalive_ms(Some(30_000u32)).unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0, 2]).unwrap();
+    let mut hs_channel = muxer.use_channel(0);
+
+    let versions = VersionTable::v4_and_above(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut hs_channel).unwrap();
+    println!("{:?}", last);
+
+    let known_points = vec![Point(
+        43847831u64,
+        hex::decode("15b9eeee849dd6386d3770b0745e0450190f7560e5159b1b3ab13b14b2684a45").unwrap(),
+    )];
+
+    let mut cs_channel = muxer.use_channel(2);
+
+    let cs = Consumer::<Content, _>::initial(known_points, NoopObserver {});
+    let cs = run_agent(cs, &mut cs_channel).unwrap();
+
+    println!("{:?}", cs);
+}

pallas-miniprotocols/examples/handshake-client.rs

@@ -0,0 +1,25 @@
+use net2::TcpStreamExt;
+use std::net::TcpStream;
+
+use pallas_miniprotocols::handshake::n2c::{Client, VersionTable};
+use pallas_miniprotocols::handshake::MAINNET_MAGIC;
+use pallas_miniprotocols::run_agent;
+use pallas_multiplexer::Multiplexer;
+
+fn main() {
+    env_logger::init();
+
+    //let bearer = TcpStream::connect("localhost:6000").unwrap();
+    let bearer = TcpStream::connect("relays-new.cardano-mainnet.iohk.io:3001").unwrap();
+
+    bearer.set_nodelay(true).unwrap();
+    bearer.set_keepalive_ms(Some(30_000u32)).unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0]).unwrap();
+
+    let mut hs_channel = muxer.use_channel(0);
+    let versions = VersionTable::v1_and_above(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut hs_channel).unwrap();
+
+    println!("{:?}", last);
+}

pallas-miniprotocols/examples/handshake-node.rs

@@ -0,0 +1,25 @@
+use net2::TcpStreamExt;
+use std::net::TcpStream;
+
+use pallas_miniprotocols::handshake::n2n::{Client, VersionTable};
+use pallas_miniprotocols::handshake::MAINNET_MAGIC;
+use pallas_miniprotocols::run_agent;
+use pallas_multiplexer::Multiplexer;
+
+fn main() {
+    env_logger::init();
+
+    //let bearer = TcpStream::connect("localhost:6000").unwrap();
+    let bearer = TcpStream::connect("relays-new.cardano-mainnet.iohk.io:3001").unwrap();
+
+    bearer.set_nodelay(true).unwrap();
+    bearer.set_keepalive_ms(Some(30_000u32)).unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0]).unwrap();
+    let mut channel = muxer.use_channel(0);
+
+    let versions = VersionTable::v4_and_above(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut channel).unwrap();
+
+    println!("{:?}", last);
+}

pallas-miniprotocols/examples/localstate-chainpoint.rs

@@ -0,0 +1,28 @@
+use pallas_miniprotocols::handshake::n2c::{Client, VersionTable};
+use pallas_miniprotocols::handshake::MAINNET_MAGIC;
+use pallas_miniprotocols::localstate::queries::RequestV10;
+use pallas_miniprotocols::localstate::{queries::QueryV10, OneShotClient};
+use pallas_miniprotocols::run_agent;
+use pallas_multiplexer::Multiplexer;
+use std::os::unix::net::UnixStream;
+
+fn main() {
+    env_logger::init();
+
+    // we connect to the unix socket of the local node. Make sure you have the right
+    // path for your environment
+    let bearer = UnixStream::connect("/tmp/node.socket").unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0, 7]).unwrap();
+
+    let mut hs_channel = muxer.use_channel(0);
+    let versions = VersionTable::only_v10(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut hs_channel).unwrap();
+    println!("last hanshake state: {:?}", last);
+
+    let mut ls_channel = muxer.use_channel(7);
+
+    let cs = OneShotClient::<QueryV10>::initial(None, RequestV10::GetChainPoint);
+    let cs = run_agent(cs, &mut ls_channel).unwrap();
+    println!("{:?}", cs);
+}

pallas-miniprotocols/examples/txsubmission-naive.rs

@@ -0,0 +1,31 @@
+use net2::TcpStreamExt;
+use std::net::TcpStream;
+
+use pallas_miniprotocols::handshake::n2c::{Client, VersionTable};
+use pallas_miniprotocols::handshake::MAINNET_MAGIC;
+use pallas_miniprotocols::run_agent;
+use pallas_miniprotocols::txsubmission::NaiveProvider;
+use pallas_multiplexer::Multiplexer;
+
+fn main() {
+    env_logger::init();
+
+    //let bearer = TcpStream::connect("localhost:6000").unwrap();
+    let bearer = TcpStream::connect("relays-new.cardano-mainnet.iohk.io:3001").unwrap();
+
+    bearer.set_nodelay(true).unwrap();
+    bearer.set_keepalive_ms(Some(30_000u32)).unwrap();
+
+    let mut muxer = Multiplexer::setup(bearer, &vec![0, 4]).unwrap();
+
+    let mut hs_channel = muxer.use_channel(0);
+    let versions = VersionTable::v1_and_above(MAINNET_MAGIC);
+    let last = run_agent(Client::initial(versions), &mut hs_channel).unwrap();
+    println!("{:?}", last);
+
+    let mut ts_channel = muxer.use_channel(4);
+    let ts = NaiveProvider::initial(vec![]);
+    let ts = run_agent(ts, &mut ts_channel).unwrap();
+
+    println!("{:?}", ts);
+}