RGB anchor adds tweaking factor to PSBT

src/bp/dbc/mod.rs

@@ -30,6 +30,6 @@ pub use spk::{
     ScriptEncodeData, ScriptEncodeMethod, SpkCommitment, SpkContainer,
 };
 pub use taproot::{TaprootCommitment, TaprootContainer};
-pub use tx::{compute_lnpbp3_vout, TxCommitment, TxContainer, TxSupplement};
+pub use tx::{TxCommitment, TxContainer, TxSupplement};
 pub use txout::{TxoutCommitment, TxoutContainer};
 pub use types::{Container, Proof};

src/bp/dbc/tx.rs

@@ -32,24 +32,6 @@ pub struct TxContainer {
     pub tweaking_factor: Option<Hmac<sha256::Hash>>,
 }
 
-pub fn compute_lnpbp3_vout(
-    tx: &Transaction,
-    supplement: &TxSupplement,
-) -> usize {
-    compute_vout(supplement.fee, supplement.protocol_factor, tx)
-}
-
-fn compute_vout(fee: u64, entropy: u32, tx: &Transaction) -> usize {
-    let nouts = tx.output.len() as u16;
-    let vout = ((fee + (entropy as u64)) % (nouts as u64)) as u16;
-    vout as usize
-}
-
-fn get_mut_txout(fee: u64, entropy: u32, tx: &mut Transaction) -> &mut TxOut {
-    let tx2 = tx.clone();
-    &mut tx.output[compute_vout(fee, entropy, &tx2)]
-}
-
 #[derive(Clone, PartialEq, Eq, Debug, Display)]
 #[display(Debug)]
 pub struct TxSupplement {
@@ -69,20 +51,28 @@ impl TxContainer {
         source: ScriptEncodeData,
         method: ScriptEncodeMethod,
     ) -> Self {
-        let txout = &tx.output[compute_vout(fee, protocol_factor, &tx)];
-        Self {
-            tx: tx.clone(),
+        let mut me = Self {
+            tx,
             fee,
             protocol_factor,
             txout_container: TxoutContainer::construct(
                 protocol_tag,
-                txout.value,
+                0,
                 pubkey,
                 source,
                 method,
             ),
             tweaking_factor: None,
-        }
+        };
+        me.txout_container.value = me.tx.output[me.vout()].value;
+        me
+    }
+
+    pub fn vout(&self) -> usize {
+        let nouts = self.tx.output.len() as u16;
+        let vout = ((self.fee + (self.protocol_factor as u64)) % (nouts as u64))
+            as u16;
+        vout as usize
     }
 }
 
@@ -95,19 +85,23 @@ impl Container for TxContainer {
         supplement: &Self::Supplement,
         host: &Self::Host,
     ) -> Result<Self, Error> {
-        let txout = &host.output
-            [compute_vout(supplement.fee, supplement.protocol_factor, host)];
-        Ok(Self {
+        let mut me = Self {
             protocol_factor: supplement.protocol_factor,
             fee: supplement.fee,
             txout_container: TxoutContainer::reconstruct(
                 proof,
                 &supplement.tag,
-                txout,
+                &TxOut::default(),
             )?,
             tx: host.clone(),
             tweaking_factor: None,
-        })
+        };
+        me.txout_container = TxoutContainer::reconstruct(
+            proof,
+            &supplement.tag,
+            &host.output[me.vout()],
+        )?;
+        Ok(me)
     }
 
     fn deconstruct(self) -> (Proof, Self::Supplement) {
@@ -149,14 +143,12 @@ where
         msg: &MSG,
     ) -> Result<Self, Self::Error> {
         let mut tx = container.tx.clone();
-        let fee = container.fee;
-        let entropy = container.protocol_factor;
 
         let txout_commitment = TxoutCommitment::embed_commit(
             &mut container.txout_container.clone(),
             msg,
         )?;
-        *get_mut_txout(fee, entropy, &mut tx) = txout_commitment.into_inner();
+        tx.output[container.vout()] = txout_commitment.into_inner();
 
         container.tweaking_factor = container.txout_container.tweaking_factor;
 

src/bp/strict_encoding.rs

@@ -13,7 +13,7 @@
 
 use std::io;
 
-use bitcoin::hashes::{hash160, sha256, sha256d, sha512};
+use bitcoin::hashes::{hash160, hmac, sha256, sha256d, sha512, Hash};
 use bitcoin::util::bip32::KeyApplication;
 use bitcoin::util::psbt::PartiallySignedTransaction;
 use bitcoin::{
@@ -51,6 +51,12 @@ impl strict_encoding::Strategy for sha512::Hash {
 impl strict_encoding::Strategy for hash160::Hash {
     type Strategy = strict_encoding::strategies::HashFixedBytes;
 }
+impl<T> strict_encoding::Strategy for hmac::Hmac<T>
+where
+    T: Hash,
+{
+    type Strategy = strict_encoding::strategies::HashFixedBytes;
+}
 
 impl strict_encoding::Strategy for OutPoint {
     type Strategy = strict_encoding::strategies::BitcoinConsensus;

src/rgb/stash/anchor.rs

@@ -15,9 +15,7 @@ use std::collections::{BTreeMap, HashMap};
 
 use amplify::Wrapper;
 use bitcoin::secp256k1;
-use bitcoin::util::psbt::{
-    raw::ProprietaryKey, PartiallySignedTransaction as Psbt,
-};
+use bitcoin::util::psbt::PartiallySignedTransaction as Psbt;
 use bitcoin::util::uint::Uint256;
 use bitcoin::{Transaction, Txid};
 use bitcoin_hashes::{sha256, sha256t, Hash, HashEngine};
@@ -26,6 +24,7 @@ use crate::bp::dbc::{
     self, Container, Proof, ScriptEncodeData, ScriptEncodeMethod, SpkContainer,
     TxCommitment, TxContainer, TxSupplement, TxoutContainer,
 };
+use crate::bp::pasbt::ProprietaryKeyMap;
 use crate::bp::resolvers::{Fee, FeeError};
 use crate::client_side_validation::{
     commit_strategy, CommitEncodeWithStrategy, ConsensusCommit,
@@ -35,7 +34,7 @@ use crate::lnpbp4::{MultimsgCommitment, TooManyMessagesError};
 use crate::rgb::{ContractId, NodeId};
 
 pub const PSBT_OUT_PUBKEY: u8 = 0x1;
-//pub const PSBT_OUT_TWEAK: u8 = 0x2;
+pub const PSBT_OUT_TWEAK: u8 = 0x2;
 
 lazy_static! {
     static ref LNPBP4_TAG: bitcoin::hashes::sha256::Hash =
@@ -91,12 +90,6 @@ impl Anchor {
         let tx = &mut psbt.global.unsigned_tx;
         let num_outs = tx.output.len() as u64;
 
-        let pubkey_key = ProprietaryKey {
-            prefix: b"RGB".to_vec(),
-            subtype: PSBT_OUT_PUBKEY,
-            key: vec![],
-        };
-
         // Compute which transition commitments must go into which output and
         // assemble them in per-output-packs of ContractId: Transition
         // commitment type
@@ -127,10 +120,8 @@ impl Anchor {
             let tx_out = &tx.output[vout];
 
             let pubkey = psbt_out
-                .proprietary
-                .get(&pubkey_key)
+                .proprietary_key(b"RGB".to_vec(), PSBT_OUT_PUBKEY, vec![])
                 .ok_or(Error::NoRequiredPubkey(vout))?;
-            let pubkey = secp256k1::PublicKey::from_slice(pubkey)?;
             // TODO: (new) Add support for Taproot parsing
             let source = match psbt_out
                 .redeem_script
@@ -182,7 +173,18 @@ impl Anchor {
                 TxCommitment::embed_commit(&mut container, &mm_digest).unwrap();
 
             *tx = commitment.into_inner().clone();
-            // TODO: Save tweaking factor from container into PSBT key
+            psbt.outputs
+                .get_mut(container.vout())
+                .map(|output| {
+                    output.insert_proprietary_key(
+                        b"RGB".to_vec(),
+                        PSBT_OUT_TWEAK,
+                        vec![],
+                        &container.tweaking_factor.expect(
+                            "Tweaking factor always present after commitment procedure"
+                        )
+                    )
+                });
 
             multimsg.iter().for_each(|(id, _)| {
                 let contract_id = ContractId::from_inner(id.into_inner());