wallet-abi web pass #1

Author: KyrylR

crates/cli/src/commands/pre_lock.rs

@@ -24,7 +24,7 @@ use lending_contracts::sdk::parameters::{
     FirstNFTParameters, LendingParameters, SecondNFTParameters,
 };
 
-use lending_contracts::sdk::taproot_unspendable_internal_key;
+use lending_contracts::sdk::{decode_pre_lock_metadata, taproot_unspendable_internal_key};
 use simplicity_contracts::sdk::validation::TxOutExt;
 use simplicityhl::elements::bitcoin::secp256k1;
 use simplicityhl::elements::hashes::Hash;
@@ -37,7 +37,7 @@ use simplicityhl::simplicity::hex::DisplayHex;
 use simplicityhl::tracker::TrackerLogLevel;
 
 use simplicity_contracts::sdk::taproot_pubkey_gen::get_random_seed;
-use simplicity_contracts_cli::explorer::{broadcast_tx, fetch_utxo};
+use simplicity_contracts_cli::explorer::{ExplorerError, broadcast_tx, fetch_utxo};
 use simplicity_contracts_cli::modules::utils::derive_keypair;
 
 use simplicityhl_core::{
@@ -289,13 +289,20 @@ impl PreLock {
                 let borrower_nft_utxo = OutPoint::new(*pre_lock_tx_id, 3);
                 let lender_nft_utxo = OutPoint::new(*pre_lock_tx_id, 4);
                 let op_return_utxo = OutPoint::new(*pre_lock_tx_id, 5);
+                let borrower_output_script_hash_utxo = OutPoint::new(*pre_lock_tx_id, 6);
 
                 let pre_lock_tx_out = fetch_utxo(pre_lock_utxo).await?;
                 let first_parameters_nft_tx_out = fetch_utxo(first_parameters_nft_utxo).await?;
                 let second_parameters_nft_tx_out = fetch_utxo(second_parameters_nft_utxo).await?;
                 let borrower_nft_tx_out = fetch_utxo(borrower_nft_utxo).await?;
                 let lender_nft_tx_out = fetch_utxo(lender_nft_utxo).await?;
                 let op_return_tx_out = fetch_utxo(op_return_utxo).await?;
+                let borrower_output_script_hash_tx_out =
+                    match fetch_utxo(borrower_output_script_hash_utxo).await {
+                        Ok(tx_out) => Some(tx_out),
+                        Err(ExplorerError::OutputIndexOutOfBounds { .. }) => None,
+                        Err(err) => return Err(err.into()),
+                    };
 
                 let (pre_lock_asset_id, _) = pre_lock_tx_out.explicit()?;
                 let (first_parameters_nft_asset_id, first_parameters_nft_value) =
@@ -325,17 +332,31 @@ impl PreLock {
                     .push_bytes()
                     .unwrap();
 
-                let (op_return_pub_key, op_return_asset_id) = op_return_bytes.split_at(32);
-
-                let principal_asset_id: [u8; 32] =
-                    op_return_asset_id.try_into().expect("Length must be 32");
-
-                let borrower_public_key = XOnlyPublicKey::from_slice(op_return_pub_key).unwrap();
+                let borrower_output_script_hash_bytes = borrower_output_script_hash_tx_out
+                    .as_ref()
+                    .filter(|tx_out| tx_out.is_null_data())
+                    .and_then(|tx_out| {
+                        let mut op_return_instr_iter = tx_out.script_pubkey.instructions_minimal();
+                        let _ = op_return_instr_iter.next()?;
+                        op_return_instr_iter
+                            .next()
+                            .and_then(Result::ok)
+                            .and_then(|instruction| instruction.push_bytes())
+                    });
+
+                let metadata =
+                    decode_pre_lock_metadata(op_return_bytes, borrower_output_script_hash_bytes)?;
+                let principal_asset_id = metadata.principal_asset_id();
+                let borrower_public_key =
+                    XOnlyPublicKey::from_slice(&metadata.borrower_pub_key()).unwrap();
 
                 println!("Pre Lock covenant info:");
                 println!("Assets Info:");
                 println!("\tCollateral asset id: {}", pre_lock_asset_id.to_hex());
-                println!("\tPrincipal asset id: {}", principal_asset_id.to_hex());
+                println!(
+                    "\tPrincipal asset id: {}",
+                    AssetId::from_slice(&principal_asset_id)?.to_hex()
+                );
                 println!(
                     "\tFirst Parameters NFT asset id: {}",
                     first_parameters_nft_asset_id.to_hex()
@@ -351,6 +372,18 @@ impl PreLock {
                 println!("\tLender NFT asset id: {}", lender_nft_asset_id.to_hex());
                 println!("Lending Offer Info:");
                 println!("\tBorrower public key: {borrower_public_key}");
+                if let Some(borrower_output_script) = metadata.borrower_output_script() {
+                    println!(
+                        "\tBorrower output script: {}",
+                        borrower_output_script.to_hex()
+                    );
+                }
+                if let Some(borrower_output_script_hash) = metadata.borrower_output_script_hash() {
+                    println!(
+                        "\tBorrower output script hash: {}",
+                        borrower_output_script_hash.to_hex()
+                    );
+                }
                 println!("\tCollateral amount: {}", lending_params.collateral_amount);
                 println!("\tPrincipal amount: {}", lending_params.principal_amount);
                 println!(
@@ -771,6 +804,7 @@ impl PreLock {
                     (*lender_nft_utxo, lender_nft_tx_out.clone()),
                     (*fee_utxo, fee_tx_out.clone()),
                     &pre_lock_arguments,
+                    Some(&to_address.script_pubkey()),
                     *fee_amount,
                     NETWORK,
                 )?;

crates/contracts/src/error.rs

@@ -37,6 +37,18 @@ pub enum PreLockError {
     NotAPreLockTransaction { txid: String },
     #[error("Invalid OP_RETURN metadata bytes: {bytes}")]
     InvalidOpReturnBytes { bytes: String },
+    #[error(
+        "Pre lock borrower output script hashes differ: borrower NFT {borrower_nft_output_script_hash}, principal {principal_output_script_hash}"
+    )]
+    InconsistentBorrowerOutputScriptHashes {
+        borrower_nft_output_script_hash: String,
+        principal_output_script_hash: String,
+    },
+    #[error("Borrower output script hash mismatch: expected {expected_hash}, actual {actual_hash}")]
+    BorrowerOutputScriptHashMismatch {
+        expected_hash: String,
+        actual_hash: String,
+    },
 }
 
 /// Errors from transaction building operations.

crates/contracts/src/pre_lock/mod.rs

@@ -140,7 +140,7 @@ mod pre_lock_tests {
     use crate::sdk::parameters::LendingParameters;
     use crate::sdk::{
         build_pre_lock_cancellation, build_pre_lock_creation, build_pre_lock_lending_creation,
-        taproot_unspendable_internal_key,
+        decode_pre_lock_metadata, extract_arguments_from_tx, taproot_unspendable_internal_key,
     };
 
     use super::*;
@@ -178,6 +178,7 @@ mod pre_lock_tests {
         second_parameters_nft_amount: u64,
         borrower_pub_key: &XOnlyPublicKey,
         lending_params: &LendingParameters,
+        borrower_output_script_hash: Option<[u8; 32]>,
     ) -> Result<((PartiallySignedTransaction, Address), PreLockArguments)> {
         // Calculate script hash for the AssetAuth covenant with the Lender NFT auth
         let asset_auth_arguments = AssetAuthArguments {
@@ -222,9 +223,9 @@ mod pre_lock_tests {
         .script_pubkey();
         let parameters_nft_output_script_hash = hash_script(&script_auth_script);
 
-        // Calculate P2TR script hash
-        let borrower_p2tr_address = get_p2pk_address(borrower_pub_key, NETWORK)?;
-        let borrower_p2tr_script_hash = hash_script(&borrower_p2tr_address.script_pubkey());
+        let borrower_p2tr_script_hash = borrower_output_script_hash.unwrap_or(hash_script(
+            &get_p2pk_address(borrower_pub_key, NETWORK)?.script_pubkey(),
+        ));
 
         let pre_lock_arguments = PreLockArguments::new(
             collateral_asset_id.into_inner().0,
@@ -304,6 +305,7 @@ mod pre_lock_tests {
                     },
                 ),
                 &pre_lock_arguments,
+                None,
                 100,
                 NETWORK,
             )?,
@@ -369,6 +371,7 @@ mod pre_lock_tests {
             second_parameters_amount,
             &test_borrower_key,
             &lending_params,
+            None,
         )?;
 
         let pst = pst.extract_tx()?;
@@ -389,15 +392,86 @@ mod pre_lock_tests {
             .push_bytes()
             .unwrap();
 
-        let (op_return_pub_key, op_return_asset_id) = op_return_bytes.split_at(32);
-
-        let op_return_asset_id: [u8; 32] =
-            op_return_asset_id.try_into().expect("Length must be 32");
+        let borrower_output_script_hash_bytes = pst.output.get(6).and_then(|tx_out| {
+            if !tx_out.is_null_data() {
+                return None;
+            }
+
+            let mut op_return_instr_iter = tx_out.script_pubkey.instructions_minimal();
+            let _ = op_return_instr_iter.next()?;
+            op_return_instr_iter
+                .next()
+                .and_then(Result::ok)
+                .and_then(|instruction| instruction.push_bytes())
+        });
 
-        let op_return_public_key = XOnlyPublicKey::from_slice(op_return_pub_key).unwrap();
+        let metadata =
+            decode_pre_lock_metadata(op_return_bytes, borrower_output_script_hash_bytes)?;
+        let op_return_public_key =
+            XOnlyPublicKey::from_slice(&metadata.borrower_pub_key()).unwrap();
+        let borrower_p2tr_script_hash =
+            hash_script(&get_p2pk_address(&test_borrower_key, NETWORK)?.script_pubkey());
 
         assert!(op_return_public_key.serialize() == test_borrower_key.serialize());
-        assert!(principal_asset_id.into_inner().0 == op_return_asset_id);
+        assert!(principal_asset_id.into_inner().0 == metadata.principal_asset_id());
+        assert_eq!(
+            metadata.borrower_output_script_hash(),
+            Some(borrower_p2tr_script_hash)
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_pre_lock_creation_round_trips_custom_borrower_output_script_hash() -> Result<()> {
+        let keypair = Keypair::from_secret_key(
+            &Secp256k1::new(),
+            &secp256k1::SecretKey::from_slice(&[1u8; 32])?,
+        );
+        let test_borrower_key = keypair.x_only_public_key().0;
+
+        let principal_asset_id = AssetId::from_str(LIQUID_TESTNET_TEST_ASSET_ID_STR)?;
+        let (
+            first_parameters_nft_asset_id,
+            second_parameters_nft_asset_id,
+            borrower_nft_asset_id,
+            lender_nft_asset_id,
+        ) = create_test_assets()?;
+
+        let lending_params = LendingParameters {
+            collateral_amount: 10_000,
+            principal_amount: 4_000,
+            loan_expiration_time: 100,
+            principal_interest_rate: 250,
+        };
+        let (first_parameters_amount, second_parameters_amount) =
+            lending_params.encode_parameters_nft_amounts(2)?;
+        let borrower_output_script_hash = hash_script(&Script::new_p2pkh(&PubkeyHash::hash(
+            &test_borrower_key.serialize(),
+        )));
+
+        let ((pst, _), pre_lock_arguments) = get_creation_pst(
+            *LIQUID_TESTNET_BITCOIN_ASSET,
+            principal_asset_id,
+            first_parameters_nft_asset_id,
+            second_parameters_nft_asset_id,
+            borrower_nft_asset_id,
+            lender_nft_asset_id,
+            first_parameters_amount,
+            second_parameters_amount,
+            &test_borrower_key,
+            &lending_params,
+            Some(borrower_output_script_hash),
+        )?;
+
+        let tx = pst.extract_tx()?;
+        let extracted_arguments = extract_arguments_from_tx(&tx, NETWORK)?;
+
+        assert_eq!(extracted_arguments, pre_lock_arguments);
+        assert_eq!(
+            extracted_arguments.principal_output_script_hash(),
+            borrower_output_script_hash
+        );
 
         Ok(())
     }
@@ -439,6 +513,7 @@ mod pre_lock_tests {
             second_parameters_amount,
             &test_borrower_key,
             &lending_params,
+            None,
         )?;
 
         let pst = pst.extract_tx()?;
@@ -612,6 +687,7 @@ mod pre_lock_tests {
             second_parameters_amount,
             &test_borrower_key,
             &lending_params,
+            None,
         )?;
 
         let pst = pst.extract_tx()?;

crates/contracts/src/sdk/pre_lock/creation.rs

@@ -14,6 +14,7 @@ use crate::script_auth::build_arguments::ScriptAuthArguments;
 use crate::script_auth::get_script_auth_address;
 use crate::sdk::basic::{add_base_input_from_utxo, check_asset_id, check_asset_value};
 use crate::sdk::parameters::{FirstNFTParameters, SecondNFTParameters};
+use crate::sdk::pre_lock::metadata::PreLockMetadata;
 use crate::sdk::taproot_unspendable_internal_key;
 
 /// Create a new pre lock contract.
@@ -40,6 +41,7 @@ pub fn build_pre_lock_creation(
     lender_nft_utxo: (OutPoint, TxOut),
     fee_utxo: (OutPoint, TxOut),
     pre_lock_arguments: &PreLockArguments,
+    borrower_output_script: Option<&Script>,
     fee_amount: u64,
     network: SimplicityNetwork,
 ) -> Result<(PartiallySignedTransaction, Address), TransactionBuildError> {
@@ -192,10 +194,12 @@ pub fn build_pre_lock_creation(
         None,
     ));
 
-    // Add OP_RETURN output with the Borrower public key and the Principal asset id
-    let mut op_return_data = [0u8; 64];
-    op_return_data[..32].copy_from_slice(&pre_lock_arguments.borrower_pub_key());
-    op_return_data[32..].copy_from_slice(&pre_lock_arguments.principal_asset_id());
+    // Persist the borrower signing key and principal asset in the primary metadata output.
+    let metadata = PreLockMetadata::from_pre_lock_arguments(
+        pre_lock_arguments,
+        borrower_output_script.map(simplicityhl::elements::Script::as_bytes),
+    )?;
+    let op_return_data = metadata.encode();
 
     pst.add_output(Output::new_explicit(
         Script::new_op_return(&op_return_data),
@@ -204,6 +208,15 @@ pub fn build_pre_lock_creation(
         None,
     ));
 
+    if let Some(borrower_output_metadata) = metadata.encode_borrower_output_metadata() {
+        pst.add_output(Output::new_explicit(
+            Script::new_op_return(&borrower_output_metadata),
+            0,
+            AssetId::default(),
+            None,
+        ));
+    }
+
     // Return collateral asset change
     if is_collateral_change_needed {
         pst.add_output(Output::new_explicit(