plutus-ledger-api V2

plutus-ledger-api/CHANGELOG.md

@@ -8,14 +8,14 @@ Changelog](https://keepachangelog.com/en/1.1.0).
 
 ### Added
 
-- Added cardano-serialization-lib conversion traits (`ToCSL` and `FromCSL`)
+- Added cardano-serialization-lib conversion traits (`ToCSL` and `FromCSL`) ([#55](https://github.com/mlabs-haskell/plutus-ledger-api-rust/pull/55))
 - Added v3 plutus ledger types ([#57](https://github.com/mlabs-haskell/plutus-ledger-api-rust/pull/57))
 - Added the ability to derive `IsPlutusData` instances ([#56](https://github.com/mlabs-haskell/plutus-ledger-api-rust/pull/56))
-- Added a few utility functions for Values
+- Added a few utility functions for Values ([#55](https://github.com/mlabs-haskell/plutus-ledger-api-rust/pull/55))
 - Added Display and Debug implementations for
-  CurrencySymbol, TokenName, Value, AddressWithExtraInfo and some other types
+  CurrencySymbol, TokenName, Value, AddressWithExtraInfo and some other types ([#55](https://github.com/mlabs-haskell/plutus-ledger-api-rust/pull/55))
 - Added FromStr implementations for CurrencySymbol, TokenName, Value, Address
-  and some other types
+  and some other types ([#55](https://github.com/mlabs-haskell/plutus-ledger-api-rust/pull/55))
 
 ### Changed
 

plutus-ledger-api/src/aux.rs

@@ -65,7 +65,12 @@ pub fn union_b_tree_maps_with<const N: usize, K: Clone + Ord, V: Clone, F: Fn(&V
     })
 }
 
-pub fn guard_bytes(ctx: &str, bytes: Vec<u8>, expected: usize) -> Result<Vec<u8>, ConversionError> {
+/// Verify that a given bytestring has the expected length
+pub(crate) fn guard_bytes(
+    ctx: &str,
+    bytes: Vec<u8>,
+    expected: usize,
+) -> Result<Vec<u8>, ConversionError> {
     if bytes.len() == expected {
         Ok(bytes)
     } else {
@@ -75,6 +80,8 @@ pub fn guard_bytes(ctx: &str, bytes: Vec<u8>, expected: usize) -> Result<Vec<u8>
     }
 }
 
+/// Nom parser for BigInt
+/// Expects an arbitrary length integer, optionally signed
 pub(crate) fn big_int(i: &str) -> IResult<&str, BigInt, VerboseError<&str>> {
     map_res(
         recognize(tuple((opt(alt((char('-'), char('+')))), many1(digit1)))),

plutus-ledger-api/src/v1/crypto.rs

@@ -8,7 +8,6 @@ use nom::{combinator::map_res, error::VerboseError, IResult};
 use serde::{Deserialize, Serialize};
 
 use crate as plutus_ledger_api;
-use crate::error::ConversionError;
 use crate::{
     csl::{
         csl_to_pla::FromCSL,
@@ -95,6 +94,9 @@ impl std::fmt::Display for LedgerBytes {
     }
 }
 
+/// Nom parser for LedgerBytes
+/// Expects a hexadecimal string of arbitrary length (0 length is allowed)
+/// E.g.: 00112233445566778899aabbcc
 pub(crate) fn ledger_bytes(input: &str) -> IResult<&str, LedgerBytes, VerboseError<&str>> {
     map_res(nom::character::complete::hex_digit0, |hex_bytes: &str| {
         HEXLOWER
@@ -103,30 +105,6 @@ pub(crate) fn ledger_bytes(input: &str) -> IResult<&str, LedgerBytes, VerboseErr
     })(input)
 }
 
-pub(crate) fn hash28(input: &str) -> IResult<&str, LedgerBytes, VerboseError<&str>> {
-    map_res(ledger_bytes, |bytes: LedgerBytes| {
-        if bytes.0.len() == 28 {
-            Ok(bytes)
-        } else {
-            Err(ConversionError::invalid_bytestring_length(
-                "hash28", 28, "equal to", &bytes.0,
-            ))
-        }
-    })(input)
-}
-
-pub(crate) fn hash32(input: &str) -> IResult<&str, LedgerBytes, VerboseError<&str>> {
-    map_res(ledger_bytes, |bytes: LedgerBytes| {
-        if bytes.0.len() == 32 {
-            Ok(bytes)
-        } else {
-            Err(ConversionError::invalid_bytestring_length(
-                "hash32", 32, "equal to", &bytes.0,
-            ))
-        }
-    })(input)
-}
-
 #[cfg(feature = "lbf")]
 impl Json for LedgerBytes {
     fn to_json(&self) -> serde_json::Value {

plutus-ledger-api/src/v1/script.rs

@@ -4,9 +4,6 @@ use cardano_serialization_lib as csl;
 
 #[cfg(feature = "lbf")]
 use lbr_prelude::json::Json;
-use nom::combinator::map;
-use nom::error::{context, VerboseError};
-use nom::IResult;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -18,8 +15,6 @@ use crate::error::ConversionError;
 use crate::plutus_data::IsPlutusData;
 use crate::v1::crypto::LedgerBytes;
 
-use super::crypto::hash28;
-
 ///////////////////
 // ValidatorHash //
 ///////////////////
@@ -43,10 +38,6 @@ impl ValidatorHash {
     }
 }
 
-pub(crate) fn validator_hash(input: &str) -> IResult<&str, ValidatorHash, VerboseError<&str>> {
-    context("validator_hash", map(script_hash, ValidatorHash))(input)
-}
-
 ///////////////////////
 // MintingPolicyHash //
 ///////////////////////
@@ -76,12 +67,6 @@ impl TryFromPLA<MintingPolicyHash> for csl::PolicyID {
     }
 }
 
-pub(crate) fn minting_policy_hash(
-    input: &str,
-) -> IResult<&str, MintingPolicyHash, VerboseError<&str>> {
-    context("minting_policy_hash", map(script_hash, MintingPolicyHash))(input)
-}
-
 ////////////////
 // ScriptHash //
 ////////////////
@@ -115,7 +100,3 @@ impl TryFromPLA<ScriptHash> for csl::ScriptHash {
             .map_err(TryFromPLAError::CSLDeserializeError)
     }
 }
-
-pub(crate) fn script_hash(input: &str) -> IResult<&str, ScriptHash, VerboseError<&str>> {
-    context("script_hash", map(hash28, ScriptHash))(input)
-}

plutus-ledger-api/src/v1/transaction.rs

@@ -7,9 +7,9 @@ use cardano_serialization_lib as csl;
 use lbr_prelude::json::Json;
 use nom::{
     character::complete::char,
-    combinator::{all_consuming, map},
+    combinator::{all_consuming, map, map_res},
     error::{context, VerboseError},
-    sequence::preceded,
+    sequence::{preceded, tuple},
     Finish, IResult,
 };
 use num_bigint::BigInt;
@@ -18,13 +18,16 @@ use serde::{Deserialize, Serialize};
 
 use super::{
     address::{Address, StakingCredential},
-    crypto::{hash32, LedgerBytes, PaymentPubKeyHash},
+    crypto::{ledger_bytes, LedgerBytes, PaymentPubKeyHash},
     datum::{Datum, DatumHash},
     interval::PlutusInterval,
     value::{CurrencySymbol, Value},
 };
 
-use crate::{self as plutus_ledger_api, aux::big_int};
+use crate::{
+    self as plutus_ledger_api,
+    aux::{big_int, guard_bytes},
+};
 use crate::{
     csl::pla_to_csl::{TryFromPLAError, TryToCSL},
     plutus_data::IsPlutusData,
@@ -93,20 +96,19 @@ impl TryFromPLA<Vec<TransactionInput>> for csl::TransactionInputs {
     }
 }
 
+/// Nom parser for TransactionInput
+/// Expects a transaction hash of 32 bytes in hexadecimal followed by a # and an integer index
+/// E.g.: 1122334455667788990011223344556677889900112233445566778899001122#1
 pub(crate) fn transaction_input(
     input: &str,
 ) -> IResult<&str, TransactionInput, VerboseError<&str>> {
-    let (input, tx_id) = transaction_hash(input)?;
-
-    let (input, idx) = preceded(char('#'), big_int)(input)?;
-
-    Ok((
-        input,
-        TransactionInput {
-            transaction_id: tx_id,
-            index: idx,
+    map(
+        tuple((transaction_hash, preceded(char('#'), big_int))),
+        |(transaction_id, index)| TransactionInput {
+            transaction_id,
+            index,
         },
-    ))
+    )(input)
 }
 
 impl FromStr for TransactionInput {
@@ -146,6 +148,16 @@ impl fmt::Display for TransactionHash {
     }
 }
 
+impl TransactionHash {
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, ConversionError> {
+        Ok(TransactionHash(LedgerBytes(guard_bytes(
+            "ScriptHash",
+            bytes,
+            32,
+        )?)))
+    }
+}
+
 impl FromCSL<csl::TransactionHash> for TransactionHash {
     fn from_csl(value: &csl::TransactionHash) -> Self {
         TransactionHash(LedgerBytes(value.to_bytes()))
@@ -159,8 +171,16 @@ impl TryFromPLA<TransactionHash> for csl::TransactionHash {
     }
 }
 
+/// Nom parser for TransactionHash
+/// Expects a hexadecimal string representation of 32 bytes
+/// E.g.: 1122334455667788990011223344556677889900112233445566778899001122
 pub(crate) fn transaction_hash(input: &str) -> IResult<&str, TransactionHash, VerboseError<&str>> {
-    context("transaction_hash", map(hash32, TransactionHash))(input)
+    context(
+        "transaction_hash",
+        map_res(ledger_bytes, |LedgerBytes(bytes)| {
+            TransactionHash::from_bytes(bytes)
+        }),
+    )(input)
 }
 
 impl FromStr for TransactionHash {