Decode local-TX-submission errors

examples/crawler/src/main.rs

@@ -6,7 +6,7 @@ use pallas::{
     ledger::traverse::{MultiEraBlock, MultiEraTx},
     network::{
         facades::NodeClient,
-        miniprotocols::{chainsync::NextResponse, Point},
+        miniprotocols::{chainsync::NextResponse, localtxsubmission::NodeErrorDecoder, Point},
     },
 };
 
@@ -28,9 +28,13 @@ async fn main() -> Result<()> {
     let args = Args::parse();
 
     // Connect to the local node over the file socket
-    let mut client = NodeClient::connect(args.socket_path.clone(), args.network_magic)
-        .await
-        .unwrap();
+    let mut client = NodeClient::connect(
+        args.socket_path.clone(),
+        args.network_magic,
+        NodeErrorDecoder::default(),
+    )
+    .await
+    .unwrap();
 
     // Find an intersection point using the points on the command line
     // The response would tell us what point we found, and what the current tip is

examples/n2c-miniprotocols/src/main.rs

@@ -8,13 +8,14 @@ use pallas::{
         miniprotocols::{
             chainsync,
             localstate::queries_v16::{self, Addr, Addrs},
+            localtxsubmission::NodeErrorDecoder,
             Point, PRE_PRODUCTION_MAGIC,
         },
     },
 };
 use tracing::info;
 
-async fn do_localstate_query(client: &mut NodeClient) {
+async fn do_localstate_query(client: &mut NodeClient<'_, NodeErrorDecoder>) {
     let client = client.statequery();
 
     client.acquire(None).await.unwrap();
@@ -81,7 +82,7 @@ async fn do_localstate_query(client: &mut NodeClient) {
     client.send_release().await.unwrap();
 }
 
-async fn do_chainsync(client: &mut NodeClient) {
+async fn do_chainsync<'a>(client: &'a mut NodeClient<'a, NodeErrorDecoder>) {
     let known_points = vec![Point::Specific(
         43847831u64,
         hex::decode("15b9eeee849dd6386d3770b0745e0450190f7560e5159b1b3ab13b14b2684a45").unwrap(),
@@ -125,11 +126,16 @@ async fn main() {
 
     // we connect to the unix socket of the local node. Make sure you have the right
     // path for your environment
-    let mut client = NodeClient::connect(SOCKET_PATH, PRE_PRODUCTION_MAGIC)
-        .await
-        .unwrap();
+    let mut client = NodeClient::connect(
+        SOCKET_PATH,
+        PRE_PRODUCTION_MAGIC,
+        NodeErrorDecoder::default(),
+    )
+    .await
+    .unwrap();
 
     // execute an arbitrary "Local State" query against the node
+
     do_localstate_query(&mut client).await;
 
     // execute the chainsync flow from an arbitrary point in the chain

pallas-codec/Cargo.toml

@@ -16,6 +16,7 @@ authors = [
 
 [features]
 default = []
+half = ["minicbor/half"]
 
 [dependencies]
 hex = "0.4.3"

pallas-network/Cargo.toml

@@ -14,8 +14,10 @@ authors = ["Santiago Carmuega <[email protected]>", "Pi Lanningham <pi.lannin
 byteorder = "1.4.3"
 hex = "0.4.3"
 itertools = "0.13.0"
-pallas-codec = { version = "=0.29.0", path = "../pallas-codec" }
+pallas-codec = { version = "=0.29.0", path = "../pallas-codec", features = ["half"] }
 pallas-crypto = { version = "=0.29.0", path = "../pallas-crypto" }
+pallas-primitives = { version = "=0.29.0", path = "../pallas-primitives" }
+pallas-utxorpc = { version = "=0.29.0", path = "../pallas-utxorpc" }
 rand = "0.8.5"
 socket2 = "0.5.5"
 thiserror = "1.0.31"

pallas-network/src/facades.rs

@@ -281,17 +281,17 @@ impl PeerServer {
 }
 
 /// Client of N2C Ouroboros
-pub struct NodeClient {
+pub struct NodeClient<'a, ErrDecoder> {
     plexer: RunningPlexer,
     handshake: handshake::N2CClient,
     chainsync: chainsync::N2CClient,
     statequery: localstate::Client,
-    submission: localtxsubmission::Client,
+    submission: localtxsubmission::Client<'a, ErrDecoder>,
     monitor: txmonitor::Client,
 }
 
-impl NodeClient {
-    pub fn new(bearer: Bearer) -> Self {
+impl<'a, ErrDecoder> NodeClient<'a, ErrDecoder> {
+    pub fn new(bearer: Bearer, local_tx_error_decoder: ErrDecoder) -> Self {
         let mut plexer = multiplexer::Plexer::new(bearer);
 
         let hs_channel = plexer.subscribe_client(PROTOCOL_N2C_HANDSHAKE);
@@ -307,18 +307,22 @@ impl NodeClient {
             handshake: handshake::Client::new(hs_channel),
             chainsync: chainsync::Client::new(cs_channel),
             statequery: localstate::Client::new(sq_channel),
-            submission: localtxsubmission::Client::new(tx_channel),
+            submission: localtxsubmission::Client::new(tx_channel, local_tx_error_decoder),
             monitor: txmonitor::Client::new(mo_channel),
         }
     }
 
     #[cfg(unix)]
-    pub async fn connect(path: impl AsRef<Path>, magic: u64) -> Result<Self, Error> {
+    pub async fn connect(
+        path: impl AsRef<Path>,
+        magic: u64,
+        err_decoder: ErrDecoder,
+    ) -> Result<Self, Error> {
         let bearer = Bearer::connect_unix(path)
             .await
             .map_err(Error::ConnectFailure)?;
 
-        let mut client = Self::new(bearer);
+        let mut client = Self::new(bearer, err_decoder);
 
         let versions = handshake::n2c::VersionTable::v10_and_above(magic);
 
@@ -413,7 +417,7 @@ impl NodeClient {
         &mut self.statequery
     }
 
-    pub fn submission(&mut self) -> &mut localtxsubmission::Client {
+    pub fn submission(&'a mut self) -> &mut localtxsubmission::Client<'a, ErrDecoder> {
         &mut self.submission
     }