feat: add encumber aggregate utxo creation method for wallet cli

applications/tari_app_utilities/src/utilities.rs

@@ -27,10 +27,10 @@ use log::*;
 use tari_common::exit_codes::{ExitCode, ExitError};
 use tari_common_types::{
     emoji::EmojiId,
-    types::{BlockHash, PublicKey},
+    types::{BlockHash, PrivateKey, PublicKey, Signature},
 };
 use tari_comms::{peer_manager::NodeId, types::CommsPublicKey};
-use tari_utilities::hex::Hex;
+use tari_utilities::hex::{Hex, HexError};
 use thiserror::Error;
 use tokio::{runtime, runtime::Runtime};
 
@@ -96,6 +96,28 @@ impl From<UniPublicKey> for PublicKey {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct UniSignature(Signature);
+
+impl FromStr for UniSignature {
+    type Err = HexError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let data = s.split(',').collect::<Vec<_>>();
+        let signature = PrivateKey::from_hex(data[0])?;
+        let public_nonce = PublicKey::from_hex(data[1])?;
+
+        let signature = Signature::new(public_nonce, signature);
+        Ok(Self(signature))
+    }
+}
+
+impl From<UniSignature> for Signature {
+    fn from(id: UniSignature) -> Self {
+        id.0
+    }
+}
+
 #[derive(Debug)]
 pub enum UniNodeId {
     PublicKey(PublicKey),

applications/tari_console_wallet/src/automation/commands.rs

@@ -42,7 +42,7 @@ use tari_app_grpc::authentication::salted_password::create_salted_hashed_passwor
 use tari_common_types::{
     emoji::EmojiId,
     transaction::TxId,
-    types::{CommitmentFactory, FixedHash, PrivateKey, PublicKey, Signature},
+    types::{Commitment, CommitmentFactory, FixedHash, PrivateKey, PublicKey, Signature},
 };
 use tari_comms::{
     connectivity::{ConnectivityEvent, ConnectivityRequester},
@@ -54,7 +54,7 @@ use tari_core::transactions::{
     tari_amount::{uT, MicroTari, Tari},
     transaction_components::{OutputFeatures, TransactionOutput, UnblindedOutput},
 };
-use tari_crypto::keys::{PublicKey as TraitPublicKey, SecretKey};
+use tari_crypto::keys::SecretKey;
 use tari_utilities::{hex::Hex, ByteArray};
 use tari_wallet::{
     connectivity_service::WalletConnectivityInterface,
@@ -90,6 +90,7 @@ pub enum WalletCommand {
     CreateKeyPair,
     CreateAggregateSignatureUtxo,
     SignMessage,
+    EncumberAggregateUtxo,
     MakeItRain,
     CoinSplit,
     DiscoverPeer,
@@ -163,6 +164,33 @@ pub async fn create_aggregate_signature_utxo(
         .map_err(CommandError::TransactionServiceError)
 }
 
+/// creates a metadata signature utxo
+async fn encumber_aggregate_utxo(
+    mut wallet_transaction_service: TransactionServiceHandle,
+    fee_per_gram: MicroTari,
+    output_hash: String,
+    signatures: Vec<Signature>,
+    total_script_pubkey: PublicKey,
+    total_offset_pubkey: PublicKey,
+    total_signature_nonce: PublicKey,
+    metadata_signature_nonce: PublicKey,
+    wallet_script_secret_key: String,
+) -> Result<(TxId, Commitment, FixedHash, Commitment, String, String, PublicKey), CommandError> {
+    wallet_transaction_service
+        .encumber_aggregate_utxo(
+            fee_per_gram,
+            output_hash,
+            signatures,
+            total_script_pubkey,
+            total_offset_pubkey,
+            total_signature_nonce,
+            metadata_signature_nonce,
+            wallet_script_secret_key,
+        )
+        .await
+        .map_err(CommandError::TransactionServiceError)
+}
+
 /// publishes a tari-SHA atomic swap HTLC transaction
 pub async fn init_sha_atomic_swap(
     mut wallet_transaction_service: TransactionServiceHandle,
@@ -281,7 +309,7 @@ pub fn sign_message(private_key: String, challenge: String) -> Result<Signature,
     let challenge = challenge.as_bytes();
 
     let nonce = PrivateKey::random(&mut OsRng);
-    let signature = Signature::sign(private_key, nonce.clone(), challenge).map_err(CommandError::FailedSignature)?;
+    let signature = Signature::sign(private_key, nonce, challenge).map_err(CommandError::FailedSignature)?;
 
     Ok(signature)
 }
@@ -723,6 +751,46 @@ pub async fn command_runner(
                 },
                 Err(e) => eprintln!("SignMessage error! {}", e),
             },
+            EncumberAggregateUtxo(args) => match encumber_aggregate_utxo(
+                transaction_service.clone(),
+                args.fee_per_gram,
+                args.output_hash,
+                args.signatures.iter().map(|sgn| sgn.clone().into()).collect::<Vec<_>>(),
+                args.total_script_pubkey.into(),
+                args.total_offset_pubkey.into(),
+                args.total_signature_nonce.into(),
+                args.metadata_signature_nonce.into(),
+                args.wallet_script_secret_key,
+            )
+            .await
+            {
+                Ok((
+                    _tx_id,
+                    output_commitment,
+                    output_hash,
+                    input_commitment,
+                    input_script_hex,
+                    input_commitment_hex,
+                    total_public_offset,
+                )) => {
+                    println!(
+                        "Encumber aggregate utxo: 
+                            1. output_commitment: {},
+                            2. output_hash: {},
+                            3. input_commitment: {},
+                            4. input_stack_hex: {},
+                            5. input_script_hex: {},
+                            6. total_public_offes: {}",
+                        output_commitment.to_hex(),
+                        output_hash.to_hex(),
+                        input_commitment.to_hex(),
+                        input_script_hex,
+                        input_commitment_hex,
+                        total_public_offset.to_hex(),
+                    )
+                },
+                Err(e) => eprintln!("Encumber aggregate utxo! {}", e),
+            },
             SendTari(args) => {
                 match send_tari(
                     transaction_service.clone(),

applications/tari_console_wallet/src/cli.rs

@@ -28,7 +28,10 @@ use std::{
 
 use chrono::{DateTime, Utc};
 use clap::{Args, Parser, Subcommand};
-use tari_app_utilities::{common_cli_args::CommonCliArgs, utilities::UniPublicKey};
+use tari_app_utilities::{
+    common_cli_args::CommonCliArgs,
+    utilities::{UniPublicKey, UniSignature},
+};
 use tari_common::configuration::{ConfigOverrideProvider, Network};
 use tari_comms::multiaddr::Multiaddr;
 use tari_core::transactions::{tari_amount, tari_amount::MicroTari};
@@ -116,8 +119,9 @@ pub enum CliCommands {
     GetBalance,
     SendTari(SendTariArgs),
     BurnTari(BurnTariArgs),
-    CreateKeyPair(CreateKeyPairArgs),
     CreateAggregateSignatureUtxo(CreateAggregateSignatureUtxoArgs),
+    CreateKeyPair(CreateKeyPairArgs),
+    EncumberAggregateUtxo(EncumberAggregateUtxoArgs),
     SignMessage(SignMessageArgs),
     SendOneSided(SendTariArgs),
     SendOneSidedToStealthAddress(SendTariArgs),
@@ -180,6 +184,18 @@ pub struct SignMessageArgs {
     pub challenge: String,
 }
 
+#[derive(Debug, Args, Clone)]
+pub struct EncumberAggregateUtxoArgs {
+    pub fee_per_gram: MicroTari,
+    pub output_hash: String,
+    pub signatures: Vec<UniSignature>,
+    pub total_script_pubkey: UniPublicKey,
+    pub total_offset_pubkey: UniPublicKey,
+    pub total_signature_nonce: UniPublicKey,
+    pub metadata_signature_nonce: UniPublicKey,
+    pub wallet_script_secret_key: String,
+}
+
 #[derive(Debug, Args, Clone)]
 pub struct MakeItRainArgs {
     pub destination: UniPublicKey,

applications/tari_console_wallet/src/wallet_modes.rs

@@ -453,6 +453,7 @@ mod test {
         let mut create_key_pair = false;
         let mut create_aggregate_signature_utxo = false;
         let mut sign_message = false;
+        let mut _encumbered_aggregate_utxo = false;
         let mut make_it_rain = false;
         let mut coin_split = false;
         let mut discover_peer = false;
@@ -465,6 +466,7 @@ mod test {
                 CliCommands::CreateKeyPair(_) => create_key_pair = true,
                 CliCommands::CreateAggregateSignatureUtxo(_) => create_aggregate_signature_utxo = true,
                 CliCommands::SignMessage(_) => sign_message = true,
+                CliCommands::EncumberAggregateUtxo(_) => _encumbered_aggregate_utxo = true,
                 CliCommands::SendOneSided(_) => {},
                 CliCommands::SendOneSidedToStealthAddress(_) => {},
                 CliCommands::MakeItRain(_) => make_it_rain = true,

base_layer/core/src/transactions/transaction_components/transaction_output.rs

@@ -298,8 +298,7 @@ impl TransactionOutput {
     }
 
     // Create commitment signature for the metadata
-
-    fn create_metadata_signature(
+    pub fn create_metadata_signature(
         version: TransactionOutputVersion,
         value: MicroTari,
         spending_key: &BlindingFactor,

base_layer/core/src/transactions/transaction_components/unblinded_output.rs

@@ -201,6 +201,53 @@ impl UnblindedOutput {
         ))
     }
 
+    /// it creates a transaction input given a partial script signature. The public keys
+    /// partial_script_public_key and partial_total_nonce exclude callers private keys use
+    pub fn as_transaction_input_with_partial_signature(
+        &self,
+        factory: &CommitmentFactory,
+        partial_script_public_key: PublicKey,
+        partial_total_nonce: PublicKey,
+    ) -> Result<TransactionInput, TransactionError> {
+        let commitment = factory.commit(&self.spending_key, &self.value.into());
+        let script_nonce_a = PrivateKey::random(&mut OsRng);
+        let script_nonce_b = PrivateKey::random(&mut OsRng);
+        let nonce_commitment = factory.commit(&script_nonce_b, &script_nonce_a);
+
+        let challenge = TransactionInput::build_script_challenge(
+            TransactionInputVersion::get_current_version(),
+            &(&nonce_commitment + &partial_total_nonce),
+            &self.script,
+            &self.input_data,
+            &(&PublicKey::from_secret_key(&self.script_private_key) + &partial_script_public_key),
+            &commitment,
+        );
+        let script_signature = ComSignature::sign(
+            &self.value.into(),
+            &(&self.script_private_key + &self.spending_key),
+            &script_nonce_a,
+            &script_nonce_b,
+            &challenge,
+            factory,
+        )
+        .map_err(|_| TransactionError::InvalidSignatureError("Generating script signature".to_string()))?;
+
+        Ok(TransactionInput::new_current_version(
+            SpentOutput::OutputData {
+                features: self.features.clone(),
+                commitment,
+                script: self.script.clone(),
+                sender_offset_public_key: self.sender_offset_public_key.clone(),
+                covenant: self.covenant.clone(),
+                version: self.version,
+                encrypted_value: self.encrypted_value.clone(),
+                minimum_value_promise: self.minimum_value_promise,
+            },
+            self.input_data.clone(),
+            script_signature,
+        ))
+    }
+
     /// Commits an UnblindedOutput into a TransactionInput that only contains the hash of the spent output data
     pub fn as_compact_transaction_input(
         &self,

base_layer/wallet/src/output_manager_service/handle.rs

@@ -25,7 +25,7 @@ use std::{fmt, fmt::Formatter, sync::Arc};
 use chacha20poly1305::XChaCha20Poly1305;
 use tari_common_types::{
     transaction::TxId,
-    types::{Commitment, HashOutput, PublicKey},
+    types::{Commitment, HashOutput, PublicKey, Signature},
 };
 use tari_core::{
     covenants::Covenant,
@@ -75,6 +75,17 @@ pub enum OutputManagerRequest {
     GetRecipientTransaction(TransactionSenderMessage),
     GetCoinbaseTransaction((TxId, MicroTari, MicroTari, u64)),
     ConfirmPendingTransaction(TxId),
+    EncumberAggregateUtxo {
+        tx_id: TxId,
+        fee_per_gram: MicroTari,
+        output_hash: String,
+        signatures: Vec<Signature>,
+        total_script_pubkey: PublicKey,
+        total_offset_pubkey: PublicKey,
+        total_signature_nonce: PublicKey,
+        metadata_signature_nonce: PublicKey,
+        wallet_script_secret_key: String,
+    },
     PrepareToSendTransaction {
         tx_id: TxId,
         amount: MicroTari,
@@ -142,6 +153,7 @@ pub enum OutputManagerRequest {
 }
 
 impl fmt::Display for OutputManagerRequest {
+    #[allow(clippy::too_many_lines)]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         #[allow(clippy::enum_glob_use)]
         use OutputManagerRequest::*;
@@ -162,6 +174,11 @@ impl fmt::Display for OutputManagerRequest {
                 v.metadata_signature.u().to_hex(),
                 v.metadata_signature.v().to_hex()
             ),
+            EncumberAggregateUtxo { tx_id, output_hash, .. } => write!(
+                f,
+                "Encumber aggregate utxo with tx_id: {} and output_hash: {}",
+                tx_id, output_hash
+            ),
             GetRecipientTransaction(_) => write!(f, "GetRecipientTransaction"),
             ConfirmPendingTransaction(v) => write!(f, "ConfirmPendingTransaction ({})", v),
             PrepareToSendTransaction { message, .. } => write!(f, "PrepareToSendTransaction ({})", message),
@@ -241,8 +258,10 @@ pub enum OutputManagerResponse {
     Balance(Balance),
     OutputAdded,
     ConvertedToTransactionOutput(Box<TransactionOutput>),
+    ConvertedToTransaction(Box<Transaction>),
     OutputMetadataSignatureUpdated,
     RecipientTransactionGenerated(ReceiverTransactionProtocol),
+    EncumberAggregateUtxo(Transaction),
     CoinbaseTransaction(Transaction),
     OutputConfirmed,
     PendingTransactionConfirmed,
@@ -850,6 +869,38 @@ impl OutputManagerHandle {
         }
     }
 
+    pub async fn encumber_aggregate_utxo(
+        &mut self,
+        tx_id: TxId,
+        fee_per_gram: MicroTari,
+        output_hash: String,
+        signatures: Vec<Signature>,
+        total_script_pubkey: PublicKey,
+        total_offset_pubkey: PublicKey,
+        total_signature_nonce: PublicKey,
+        metadata_signature_nonce: PublicKey,
+        wallet_script_secret_key: String,
+    ) -> Result<Transaction, OutputManagerError> {
+        match self
+            .handle
+            .call(OutputManagerRequest::EncumberAggregateUtxo {
+                tx_id,
+                fee_per_gram,
+                output_hash,
+                signatures,
+                total_script_pubkey,
+                total_offset_pubkey,
+                total_signature_nonce,
+                metadata_signature_nonce,
+                wallet_script_secret_key,
+            })
+            .await??
+        {
+            OutputManagerResponse::EncumberAggregateUtxo(transaction) => Ok(transaction),
+            _ => Err(OutputManagerError::UnexpectedApiResponse),
+        }
+    }
+
     pub async fn create_pay_to_self_transaction(
         &mut self,
         tx_id: TxId,