Merge pull request #71 from BP-WG/v0.11

Imptove APIs from the point of multiple chain support and better determinism for blinding

Cargo.toml

@@ -13,7 +13,7 @@ default-members = [
 ]
 
 [workspace.package]
-version = "0.11.0-beta.2"
+version = "0.11.0-beta.3"
 authors = ["Dr Maxim Orlovsky <[email protected]>"]
 homepage = "https://github.com/BP-WG"
 repository = "https://github.com/BP-WG/bp-core"
@@ -23,13 +23,13 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 amplify = "4.5.0"
-strict_encoding = "2.6.1"
+strict_encoding = ">=2.6.2"
 strict_types = "1.6.3"
-commit_verify = "0.11.0-beta.2"
-single_use_seals = "0.11.0-beta.2"
+commit_verify = "0.11.0-beta.3"
+single_use_seals = "0.11.0-beta.3"
 bp-consensus = { version = "0.11.0-beta.3", path = "consensus" }
-bp-dbc = { version = "0.11.0-beta.2", path = "./dbc" }
-bp-seals = { version = "0.11.0-beta.2", path = "./seals" }
+bp-dbc = { version = "0.11.0-beta.3", path = "./dbc" }
+bp-seals = { version = "0.11.0-beta.3", path = "./seals" }
 secp256k1 = { version = "0.28.0", features = ["global-context"] }
 serde_crate = { package = "serde", version = "1", features = ["derive"] }
 

consensus/src/coding.rs

@@ -146,8 +146,7 @@ mod _serde {
  })
  } else {
  let bytes = Vec::<u8>::deserialize(deserializer)?;
- Self::try_from(bytes)
- .map_err(|_| D::Error::custom("invalid script length exceeding 4GB"))
+ Ok(Self::from(bytes))
  }
  }
  }

consensus/src/segwit.rs

@@ -394,9 +394,7 @@ impl Witness {
  }
 
  pub fn from_consensus_stack(witness: impl IntoIterator<Item = Vec<u8>>) -> Witness {
- let iter = witness.into_iter().map(|vec| {
- ByteStr::try_from(vec).expect("witness stack element length exceeds 2^32 bytes")
- });
+ let iter = witness.into_iter().map(ByteStr::from);
  let stack =
  VarIntArray::try_from_iter(iter).expect("witness stack size exceeds 2^32 elements");
  Witness(stack)

dbc/src/anchor.rs

@@ -25,12 +25,13 @@
 //! defined by LNPBP-4.
 
 use std::error::Error;
+use std::marker::PhantomData;
 
 use bc::{Tx, Txid};
 use commit_verify::mpc::{self, Message, ProtocolId};
 use strict_encoding::{StrictDumb, StrictEncode};
 
-use crate::LIB_NAME_BPCORE;
+use crate::{DbcMethod, Method, LIB_NAME_BPCORE};
 
 mod dbc {
  pub use crate::Proof;
@@ -67,7 +68,7 @@ pub enum VerifyError<E: Error> {
  derive(Serialize, Deserialize),
  serde(crate = "serde_crate", rename_all = "camelCase")
 )]
-pub struct Anchor<L: mpc::Proof + StrictDumb, D: dbc::Proof> {
+pub struct Anchor<L: mpc::Proof + StrictDumb, D: dbc::Proof<M>, M: DbcMethod = Method> {
  /// Transaction containing deterministic bitcoin commitment.
  pub txid: Txid,
 
@@ -76,6 +77,10 @@ pub struct Anchor<L: mpc::Proof + StrictDumb, D: dbc::Proof> {
 
  /// Proof of the DBC commitment.
  pub dbc_proof: D,
+
+ #[doc(hidden)]
+ #[strict_type(skip)]
+ pub _method: PhantomData<M>,
 }
 
 /// Error merging two [`Anchor`]s.
@@ -94,19 +99,20 @@ pub enum MergeError {
  DbcMismatch,
 }
 
-impl<D: dbc::Proof> Anchor<mpc::MerkleProof, D> {
+impl<D: dbc::Proof<M>, M: DbcMethod> Anchor<mpc::MerkleProof, D, M> {
  /// Reconstructs anchor containing merkle block
  pub fn into_merkle_block(
  self,
  protocol_id: impl Into<ProtocolId>,
  message: impl Into<Message>,
- ) -> Result<Anchor<mpc::MerkleBlock, D>, mpc::InvalidProof> {
+ ) -> Result<Anchor<mpc::MerkleBlock, D, M>, mpc::InvalidProof> {
  let lnpbp4_proof =
  mpc::MerkleBlock::with(&self.mpc_proof, protocol_id.into(), message.into())?;
  Ok(Anchor {
  txid: self.txid,
  mpc_proof: lnpbp4_proof,
  dbc_proof: self.dbc_proof,
+ _method: default!(),
  })
  }
 
@@ -115,7 +121,7 @@ impl<D: dbc::Proof> Anchor<mpc::MerkleProof, D> {
  &self,
  protocol_id: impl Into<ProtocolId>,
  message: impl Into<Message>,
- ) -> Result<Anchor<mpc::MerkleBlock, D>, mpc::InvalidProof> {
+ ) -> Result<Anchor<mpc::MerkleBlock, D, M>, mpc::InvalidProof> {
  self.clone().into_merkle_block(protocol_id, message)
  }
 
@@ -145,13 +151,13 @@ impl<D: dbc::Proof> Anchor<mpc::MerkleProof, D> {
  }
 }
 
-impl<D: dbc::Proof> Anchor<mpc::MerkleBlock, D> {
+impl<D: dbc::Proof<M>, M: DbcMethod> Anchor<mpc::MerkleBlock, D, M> {
  /// Conceals all LNPBP-4 data except specific protocol and produces merkle
  /// proof anchor.
  pub fn to_merkle_proof(
  &self,
  protocol: impl Into<ProtocolId>,
- ) -> Result<Anchor<mpc::MerkleProof, D>, mpc::LeafNotKnown> {
+ ) -> Result<Anchor<mpc::MerkleProof, D, M>, mpc::LeafNotKnown> {
  self.clone().into_merkle_proof(protocol)
  }
 
@@ -160,12 +166,13 @@ impl<D: dbc::Proof> Anchor<mpc::MerkleBlock, D> {
  pub fn into_merkle_proof(
  self,
  protocol: impl Into<ProtocolId>,
- ) -> Result<Anchor<mpc::MerkleProof, D>, mpc::LeafNotKnown> {
+ ) -> Result<Anchor<mpc::MerkleProof, D, M>, mpc::LeafNotKnown> {
  let lnpbp4_proof = self.mpc_proof.to_merkle_proof(protocol.into())?;
  Ok(Anchor {
  txid: self.txid,
  mpc_proof: lnpbp4_proof,
  dbc_proof: self.dbc_proof,
+ _method: default!(),
  })
  }
 

dbc/src/lib.rs

@@ -60,4 +60,4 @@ pub mod tapret;
 mod proof;
 
 pub use anchor::Anchor;
-pub use proof::{Method, MethodParseError, Proof};
+pub use proof::{DbcMethod, Method, MethodParseError, Proof};

dbc/src/opret/mod.rs

@@ -72,7 +72,7 @@ pub struct OpretProof(());
 impl StrictSerialize for OpretProof {}
 impl StrictDeserialize for OpretProof {}
 
-impl Proof for OpretProof {
+impl Proof<Method> for OpretProof {
  type Error = EmbedVerifyError<OpretError>;
  const METHOD: Method = Method::OpretFirst;
 

dbc/src/proof.rs

@@ -29,6 +29,19 @@ use strict_encoding::{StrictDecode, StrictDeserialize, StrictDumb, StrictEncode,
 
 use crate::LIB_NAME_BPCORE;
 
+/// Trait defining DBC method - or enumberation of allowed DBC methods used by
+/// proofs, single-use-seals etc.
+pub trait DbcMethod:
+ Copy
+ + Eq
+ + Ord
+ + std::hash::Hash
+ + strict_encoding::StrictDumb
+ + strict_encoding::StrictEncode
+ + strict_encoding::StrictDecode
+{
+}
+
 /// wrong deterministic bitcoin commitment closing method id '{0}'.
 #[derive(Clone, PartialEq, Eq, Debug, Display, Error, From)]
 #[display(doc_comments)]
@@ -57,6 +70,8 @@ pub enum Method {
  TapretFirst = 0x01,
 }
 
+impl DbcMethod for Method {}
+
 impl FromStr for Method {
  type Err = MethodParseError;
 
@@ -70,14 +85,14 @@ impl FromStr for Method {
 }
 
 /// Deterministic bitcoin commitment proof types.
-pub trait Proof:
+pub trait Proof<M: DbcMethod = Method>:
  Clone + Eq + Debug + CommitEncode + StrictSerialize + StrictDeserialize + StrictDumb
 {
  /// Verification error.
  type Error: Error;
 
  /// Returns DBC method used by the proof.
- const METHOD: Method;
+ const METHOD: M;
 
  /// Verifies DBC proof against the provided transaction.
  fn verify(&self, msg: &mpc::Commitment, tx: &Tx) -> Result<(), Self::Error>;

dbc/src/tapret/mod.rs

@@ -382,7 +382,7 @@ impl TapretProof {
  }
 }
 
-impl Proof for TapretProof {
+impl Proof<Method> for TapretProof {
  type Error = ConvolveVerifyError;
  const METHOD: Method = Method::TapretFirst;
 

seals/src/lib.rs

@@ -45,3 +45,11 @@ extern crate serde_crate as serde;
 
 pub mod resolver;
 pub mod txout;
+mod secret;
+
+pub use secret::SecretSeal;
+
+/// Method for closing BP single-use-seals.
+pub trait SealCloseMethod: dbc::DbcMethod {}
+
+impl SealCloseMethod for dbc::Method {}

seals/src/secret.rs

@@ -0,0 +1,93 @@
+// Bitcoin protocol single-use-seals library.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Written in 2019-2023 by
+// Dr Maxim Orlovsky <[email protected]>
+//
+// Copyright (C) 2019-2023 LNP/BP Standards Association. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::str::FromStr;
+
+use amplify::{Bytes32, Wrapper};
+use baid58::{Baid58ParseError, Chunking, FromBaid58, ToBaid58, CHUNKING_32CHECKSUM};
+use commit_verify::{CommitmentId, Conceal};
+
+use crate::txout::{BlindSeal, SealTxid};
+
+/// Confidential version of transaction outpoint-based single-use-seal
+#[derive(Wrapper, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, From)]
+#[wrapper(Index, RangeOps, BorrowSlice, Hex)]
+#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
+#[strict_type(lib = dbc::LIB_NAME_BPCORE)]
+#[derive(CommitEncode)]
+#[commit_encode(strategy = strict)]
+#[cfg_attr(
+ feature = "serde",
+ derive(Serialize, Deserialize),
+ serde(crate = "serde_crate", transparent)
+)]
+pub struct SecretSeal(
+ #[from]
+ #[from([u8; 32])]
+ Bytes32,
+);
+
+impl<Id: SealTxid> Conceal for BlindSeal<Id> {
+ type Concealed = SecretSeal;
+
+ #[inline]
+ fn conceal(&self) -> Self::Concealed { self.commitment_id() }
+}
+
+impl ToBaid58<32> for SecretSeal {
+ const HRI: &'static str = "utxob";
+ const CHUNKING: Option<Chunking> = CHUNKING_32CHECKSUM;
+ fn to_baid58_payload(&self) -> [u8; 32] { self.0.into_inner() }
+ fn to_baid58_string(&self) -> String { self.to_string() }
+}
+impl FromBaid58<32> for SecretSeal {}
+impl FromStr for SecretSeal {
+ type Err = Baid58ParseError;
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ SecretSeal::from_baid58_maybe_chunked_str(s, ':', ' ')
+ }
+}
+impl Display for SecretSeal {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ if f.alternate() {
+ write!(f, "{::^}", self.to_baid58())
+ } else {
+ write!(f, "{::^.3}", self.to_baid58())
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn secret_seal_baid58() {
+ let baid58 = "utxob:2eFrirU-RjqLnqR74-AKRfdnc9M-DpvSRjmZG-mFPrw7nvu-Te1wy83";
+ let seal: SecretSeal = baid58.parse().unwrap();
+ assert_eq!(baid58, seal.to_string());
+ assert_eq!(baid58.replace('-', ""), format!("{seal:#}"));
+ assert_eq!(seal.to_string(), seal.to_baid58_string());
+ let reconstructed = SecretSeal::from_str(&baid58.replace('-', "")).unwrap();
+ assert_eq!(reconstructed, seal);
+ }
+}