PoC of schema

Author: KyrylR

crates/wallet-abi/src/error.rs

@@ -1,5 +1,3 @@
-use lwk_wollet::blocking::EsploraClient;
-use std::sync::{MutexGuard, PoisonError};
 use lwk_wollet::elements::UnblindError;
 use thiserror::Error;
 
@@ -100,7 +98,7 @@ pub enum WalletAbiError {
     LWKWollet(#[from] lwk_wollet::Error),
 
     #[error("TXOut unblinding error: {0}")]
-    Unblind(#[from] UnblindError)
+    Unblind(#[from] UnblindError),
 }
 
 /// Errors that occur during binary or hex encoding/decoding operations.

crates/wallet-abi/src/lib.rs

@@ -28,7 +28,7 @@ pub use lwk_common::Network;
 pub use lwk_simplicity::error::ProgramError;
 pub use lwk_simplicity::runner::run_program;
 pub use lwk_simplicity::signer::{finalize_transaction, get_and_verify_env, get_sighash_all};
-pub use schema::bundle::*;
+pub use schema::runtime_params::*;
 pub use scripts::{
     control_block, create_p2tr_address, get_new_asset_entropy, hash_script, load_program,
     simplicity_leaf_version, tap_data_hash,

crates/wallet-abi/src/runtime/input_resolution.rs

@@ -44,17 +44,20 @@
 //! ```
 //!
 
-use crate::runtime::params::RuntimeParamsEnvelope;
-use crate::runtime::{get_finalizer_spec_key, WalletRuntimeConfig};
-use crate::{AmountFilter, AssetFilter, AssetVariant, FinalizerSpec, InputBlinder, InputIssuance, InputIssuanceKind, InputSchema, LockFilter, UTXOSource, WalletAbiError, WalletSourceFilter};
+use crate::runtime::{WalletRuntimeConfig, get_finalizer_spec_key};
+use crate::{
+    AmountFilter, AssetFilter, AssetVariant, FinalizerSpec, InputBlinder, InputIssuance,
+    InputIssuanceKind, InputSchema, LockFilter, RuntimeParams, UTXOSource, WalletAbiError,
+    WalletSourceFilter,
+};
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 
 use lwk_wollet::elements::confidential::{Asset, AssetBlindingFactor, Value, ValueBlindingFactor};
 use lwk_wollet::elements::hashes::Hash;
 use lwk_wollet::elements::pset::{Input, PartiallySignedTransaction};
-use lwk_wollet::elements::{secp256k1_zkp, AssetId, ContractHash, OutPoint, TxOut, TxOutSecrets};
-use lwk_wollet::{WalletTxOut, EC};
+use lwk_wollet::elements::{AssetId, ContractHash, OutPoint, TxOut, TxOutSecrets, secp256k1_zkp};
+use lwk_wollet::{EC, WalletTxOut};
 
 type CandidateScore = (u64, u64, u64, String, u32);
 
@@ -92,7 +95,7 @@ struct ResolvedInputMaterial {
 /// add_balance(&mut balances, "L-BTC", 2).unwrap();
 /// assert_eq!(balances.get("L-BTC"), Some(&12));
 /// ```
-fn add_balance(
+pub(super) fn add_balance(
     map: &mut BTreeMap<AssetId, u64>,
     asset_id: AssetId,
     amount_sat: u64,
@@ -190,7 +193,7 @@ fn validate_output_input_index(
 /// assert_eq!(derive(3, InputIssuanceKind::Reissue(base)), base);
 /// assert_ne!(derive(3, InputIssuanceKind::New(base)), base);
 /// ```
-fn derive_issuance_entropy(outpoint: OutPoint, issuance: &InputIssuance) -> Midstate {
+pub(super) fn derive_issuance_entropy(outpoint: OutPoint, issuance: &InputIssuance) -> Midstate {
     match issuance.kind {
         InputIssuanceKind::New => AssetId::generate_asset_entropy(
             outpoint,
@@ -256,13 +259,13 @@ fn apply_issuance_to_pset_input(
         Some(issuance.token_amount_sat)
     };
 
-    if let InputIssuanceKind::Reissue = issuance.kind {
+    if issuance.kind == InputIssuanceKind::Reissue {
         // TODO: investigate the purpose of this field, and make it functionally correct.
         let mut nonce = secrets.asset_bf.into_inner();
         if nonce == secp256k1_zkp::ZERO_TWEAK {
             let mut one = [0u8; 32];
             one[0] = 1;
-            nonce = secp256k1_zkp::Tweak::from_slice(&one).expect("tweak from [0,..,1] is correct")
+            nonce = secp256k1_zkp::Tweak::from_slice(&one).expect("tweak from [0,..,1] is correct");
         }
         pset_input.issuance_blinding_nonce = Some(nonce);
     }
@@ -374,7 +377,7 @@ impl WalletRuntimeConfig {
     /// Build demand from output specs and store issuance-linked entries as deferred.
     fn resolve_output_demands(
         &self,
-        params: &RuntimeParamsEnvelope,
+        params: &RuntimeParams,
         state: &mut ResolutionState,
     ) -> Result<(), WalletAbiError> {
         // Convert output-level asset requirements into equation demand.
@@ -533,12 +536,16 @@ impl WalletRuntimeConfig {
         let mut pset_input = Input::from_prevout(material.outpoint);
         pset_input.sequence = Some(input.sequence);
         pset_input.witness_utxo = Some(material.tx_out.clone());
+        pset_input.amount = Some(material.secrets.value);
+        pset_input.asset = Some(material.secrets.asset);
 
         if let Some(issuance) = input.issuance.as_ref() {
             apply_issuance_to_pset_input(&mut pset_input, issuance, &material.secrets)?;
         }
 
-        pset_input.proprietary.insert(get_finalizer_spec_key(), input.finalizer.encode());
+        pset_input
+            .proprietary
+            .insert(get_finalizer_spec_key(), input.finalizer.encode());
         pst.add_input(pset_input);
 
         Ok(())
@@ -615,7 +622,7 @@ impl WalletRuntimeConfig {
     fn resolve_declared_inputs(
         &self,
         pst: &mut PartiallySignedTransaction,
-        params: &RuntimeParamsEnvelope,
+        params: &RuntimeParams,
         wallet_snapshot: &[WalletTxOut],
         state: &mut ResolutionState,
     ) -> Result<(), WalletAbiError> {
@@ -697,7 +704,11 @@ impl WalletRuntimeConfig {
         let tx_out = self.fetch_tx_out(&selected.outpoint)?;
         let mut pset_input = Input::from_prevout(selected.outpoint);
         pset_input.witness_utxo = Some(tx_out);
-        pset_input.proprietary.insert(get_finalizer_spec_key(), FinalizerSpec::Wallet.encode());
+        pset_input.amount = Some(selected.unblinded.value);
+        pset_input.asset = Some(selected.unblinded.asset);
+        pset_input
+            .proprietary
+            .insert(get_finalizer_spec_key(), FinalizerSpec::Wallet.encode());
         pst.add_input(pset_input);
 
         add_balance(
@@ -772,7 +783,7 @@ impl WalletRuntimeConfig {
     pub(super) fn resolve_inputs(
         &self,
         pst: PartiallySignedTransaction,
-        params: &RuntimeParamsEnvelope,
+        params: &RuntimeParams,
     ) -> Result<PartiallySignedTransaction, WalletAbiError> {
         // Phase 1: initialize demand/supply state and load wallet snapshot once.
         // We keep all equation state in a dedicated struct so each phase mutates a single object.

crates/wallet-abi/src/runtime/mod.rs

@@ -1,12 +1,11 @@
-pub mod params;
 pub mod utils;
 
 mod input_resolution;
+mod output_resolution;
 
 use crate::error::WalletAbiError;
-use crate::runtime::params::RuntimeParamsEnvelope;
 use crate::schema::tx_create::{TransactionInfo, TxCreateRequest, TxCreateResponse};
-use crate::{FinalizerSpec, InputSchema, LockFilter, SchemaBundle, UTXOSource};
+use crate::{FinalizerSpec, InputSchema, LockFilter, RuntimeParams, UTXOSource};
 
 use std::path::Path;
 use std::str::FromStr;
@@ -25,15 +24,15 @@ use lwk_wollet::blocking::EsploraClient;
 use lwk_wollet::elements::hex::ToHex;
 use lwk_wollet::elements::pset::PartiallySignedTransaction;
 use lwk_wollet::elements::pset::raw::ProprietaryKey;
-use lwk_wollet::elements::{OutPoint, Script, TxOut, TxOutSecrets, secp256k1_zkp};
+use lwk_wollet::elements::{Address, OutPoint, Script, TxOut, TxOutSecrets, secp256k1_zkp};
 use lwk_wollet::elements_miniscript::ToPublicKey;
 use lwk_wollet::secp256k1::{Keypair, XOnlyPublicKey};
 use lwk_wollet::{EC, Wollet, WolletDescriptor};
 use simplicityhl::elements::{Transaction, encode};
 use simplicityhl::tracker::TrackerLogLevel;
 
 pub(crate) fn get_finalizer_spec_key() -> ProprietaryKey {
-    ProprietaryKey::from_pset_pair(1, "finalizer-spec".as_bytes().to_vec())
+    ProprietaryKey::from_pset_pair(1, b"finalizer-spec".to_vec())
 }
 
 #[derive(Debug)]
@@ -120,16 +119,18 @@ impl WalletRuntimeConfig {
         )?)
     }
 
-    pub fn signer_address(&self) -> Result<XOnlyPublicKey, WalletAbiError> {
-        let keypair = self.signer_keypair()?;
+    pub fn signer_x_only_public_key(&self) -> Result<XOnlyPublicKey, WalletAbiError> {
+        Ok(self.signer_keypair()?.x_only_public_key().0)
+    }
+
+    pub fn signer_receive_address(&self) -> Result<Address, WalletAbiError> {
+        let descriptor = self.get_descriptor()?;
 
-        Ok(keypair.x_only_public_key().0)
+        Ok(descriptor.address(0, self.network.address_params())?)
     }
 
     pub(crate) fn signer_keypair(&self) -> Result<Keypair, WalletAbiError> {
-        let x_private = self.x_private(Bip::Bip87)?;
-
-        Ok(x_private.to_keypair(&EC))
+        Ok(self.x_private(Bip::Bip87)?.to_keypair(&EC))
     }
 
     pub fn sync_wallet(&mut self) -> Result<(), WalletAbiError> {
@@ -184,42 +185,35 @@ impl WalletRuntimeConfig {
     ) -> Result<TxCreateResponse, WalletAbiError> {
         self.ensure_defaults()?;
 
-        let bundle = SchemaBundle::from_uri(&request.schema_uri)?;
-        let params = RuntimeParamsEnvelope::from_request_params(&request.params)?;
-
-        self.pre_sync_inputs(&params.inputs)?;
+        self.pre_sync_inputs(&request.params.inputs)?;
 
-        let finalized_tx = self.finalize(&params)?;
+        let finalized_tx = self.finalize(&request.params)?;
 
-        let txid = finalized_tx.txid().to_string();
+        let txid = finalized_tx.txid();
 
         let inner_esplora = self
             .esplora
             .lock()
             .map_err(|e| WalletAbiError::EsploraPoisoned(e.to_string()))?;
 
-        let published_txid = if request.broadcast {
-            Some(inner_esplora.broadcast(&finalized_tx)?)
-        } else {
-            None
-        };
+        if request.broadcast {
+            let published_txid = inner_esplora.broadcast(&finalized_tx)?;
+            assert_eq!(txid, published_txid);
+        }
 
         let response = TxCreateResponse::ok(
             request,
-            &bundle.schema_id,
-            &bundle.schema_version,
             TransactionInfo {
                 tx_hex: encode::serialize_hex(&finalized_tx),
                 txid,
             },
-            published_txid,
             None,
         );
 
         Ok(response)
     }
 
-    fn finalize(&self, params: &RuntimeParamsEnvelope) -> Result<Transaction, WalletAbiError> {
+    fn finalize(&self, params: &RuntimeParams) -> Result<Transaction, WalletAbiError> {
         let fee_estimation_build = self.build_transaction(params, 1u64)?;
 
         let finalized_tx = self.finalize_all_inputs(fee_estimation_build)?;
@@ -243,13 +237,14 @@ impl WalletRuntimeConfig {
 
     fn build_transaction(
         &self,
-        params: &RuntimeParamsEnvelope,
+        params: &RuntimeParams,
         fee_target_sat: u64,
     ) -> Result<PartiallySignedTransaction, WalletAbiError> {
         let mut pst = PartiallySignedTransaction::new_v2();
         pst.global.tx_data.fallback_locktime = params.locktime;
 
         pst = self.resolve_inputs(pst, params)?;
+        pst = self.balance_out(pst, params, fee_target_sat)?;
 
         Ok(pst)
     }
@@ -300,7 +295,7 @@ impl WalletRuntimeConfig {
                         input_index,
                     )?;
 
-                    let witness = resolve_witness(&witness, &self, &env)?;
+                    let witness = resolve_witness(&witness, self, &env)?;
 
                     let pruned = run_program(&program, witness, &env, TrackerLogLevel::None)?.0;
 
@@ -313,7 +308,7 @@ impl WalletRuntimeConfig {
                         simplicity_program_bytes,
                         cmr.as_ref().to_vec(),
                         control_block(cmr, internal_key.pubkey.to_x_only_pubkey()).serialize(),
-                    ])
+                    ]);
                 }
             }
         }
@@ -335,7 +330,7 @@ impl WalletRuntimeConfig {
                     }
                 },
                 UTXOSource::Provided { .. } => {}
-            };
+            }
         }
 
         Ok(())