diff --git a/lwk_simplicity/src/error.rs b/lwk_simplicity/src/error.rs
index 7a301c815..127dae336 100644
--- a/lwk_simplicity/src/error.rs
+++ b/lwk_simplicity/src/error.rs
@@ -76,4 +76,7 @@ pub enum ProgramError {
 
     #[error("Input index exceeds u32 maximum: {0}")]
     InputIndexOverflow(#[from] std::num::TryFromIntError),
+
+    #[error("Invalid control block: {0}")]
+    InvalidControlBlock(String),
 }
diff --git a/lwk_simplicity/src/signer.rs b/lwk_simplicity/src/signer.rs
index 054a79bd2..bd04f381f 100644
--- a/lwk_simplicity/src/signer.rs
+++ b/lwk_simplicity/src/signer.rs
@@ -2,6 +2,8 @@ use crate::error::ProgramError;
 use crate::runner::run_program;
 use crate::scripts::{control_block, create_p2tr_address};
 
+use simplicityhl::elements::taproot;
+
 use std::sync::Arc;
 
 use lwk_common::Network;
@@ -86,6 +88,88 @@ pub fn finalize_transaction(
     Ok(tx)
 }
 
+/// Build an Elements environment from a pre-computed control block (no script pubkey check).
+///
+/// Use this for storage-aware UTXOs whose taproot tree includes hidden storage slot leaves that
+/// differ from the single-CMR-leaf tree that `get_and_verify_env` reconstructs.
+///
+/// # Errors
+/// Returns error if UTXO index is invalid or control block bytes cannot be parsed.
+pub fn get_env_with_cb(
+    tx: &Transaction,
+    program: &CompiledProgram,
+    utxos: &[TxOut],
+    input_index: usize,
+    control_block_bytes: &[u8],
+    network: Network,
+) -> Result<ElementsEnv<Arc<Transaction>>, ProgramError> {
+    let cmr = program.commit().cmr();
+
+    if utxos.len() <= input_index {
+        return Err(ProgramError::UtxoIndexOutOfBounds {
+            input_index,
+            utxo_count: utxos.len(),
+        });
+    }
+
+    let cb = taproot::ControlBlock::from_slice(control_block_bytes)
+        .map_err(|e| ProgramError::InvalidControlBlock(e.to_string()))?;
+
+    Ok(ElementsEnv::new(
+        Arc::new(tx.clone()),
+        utxos
+            .iter()
+            .map(|utxo| ElementsUtxo {
+                script_pubkey: utxo.script_pubkey.clone(),
+                asset: utxo.asset,
+                value: utxo.value,
+            })
+            .collect(),
+        u32::try_from(input_index)?,
+        cmr,
+        cb,
+        None,
+        network.genesis_hash(),
+    ))
+}
+
+/// Finalize a transaction using a pre-computed control block for a storage-aware UTXO.
+///
+/// # Errors
+/// Returns error if the control block is invalid or program execution fails.
+#[allow(clippy::too_many_arguments)]
+pub fn finalize_transaction_with_cb(
+    mut tx: Transaction,
+    program: &CompiledProgram,
+    utxos: &[TxOut],
+    input_index: usize,
+    witness_values: WitnessValues,
+    control_block_bytes: &[u8],
+    network: Network,
+    log_level: TrackerLogLevel,
+) -> Result<Transaction, ProgramError> {
+    let env = get_env_with_cb(&tx, program, utxos, input_index, control_block_bytes, network)?;
+
+    let pruned = run_program(program, witness_values, &env, log_level)?.0;
+
+    let (simplicity_program_bytes, simplicity_witness_bytes) = pruned.to_vec_with_witness();
+    let cmr = pruned.cmr();
+
+    tx.input[input_index].witness = TxInWitness {
+        amount_rangeproof: None,
+        inflation_keys_rangeproof: None,
+        script_witness: vec![
+            simplicity_witness_bytes,
+            simplicity_program_bytes,
+            cmr.as_ref().to_vec(),
+            control_block_bytes.to_vec(),
+        ],
+        pegin_witness: vec![],
+    };
+
+    Ok(tx)
+}
+
 /// Build and verify an Elements environment for program execution.
 ///
 /// # Errors
diff --git a/lwk_wasm/src/simplicity/program.rs b/lwk_wasm/src/simplicity/program.rs
index 45fe56d07..28b1641ab 100644
--- a/lwk_wasm/src/simplicity/program.rs
+++ b/lwk_wasm/src/simplicity/program.rs
@@ -159,6 +159,40 @@ impl SimplicityProgram {
         Ok(signature.serialize().to_hex())
     }
 
+    /// Finalize a transaction with a storage-aware taproot spend info for the specified input.
+    ///
+    /// NOTE: The utxos object is destroyed during the execution of the function, so the argument that was
+    /// passed in the JS code cannot be reused.
+    #[allow(clippy::too_many_arguments)]
+    #[wasm_bindgen(js_name = finalizeTransactionWithSpendInfo)]
+    pub fn finalize_transaction_with_spend_info(
+        &self,
+        tx: &Transaction,
+        spend_info: &super::state_utils::StateTaprootSpendInfo,
+        utxos: Vec<TxOut>,
+        input_index: u32,
+        witness_values: &SimplicityWitnessValues,
+        network: &Network,
+        log_level: SimplicityLogLevel,
+    ) -> Result<Transaction, Error> {
+        let cmr: Cmr = self.inner.commit().cmr().into();
+        let cb_bytes = spend_info.control_block(&cmr)?.to_bytes();
+        let utxos_inner = convert_utxos(&utxos);
+
+        let finalized = signer::finalize_transaction_with_cb(
+            tx.as_ref().clone(),
+            &self.inner,
+            &utxos_inner,
+            input_index as usize,
+            witness_values.to_inner()?,
+            &cb_bytes,
+            network.into(),
+            log_level.into(),
+        )?;
+
+        Ok(finalized.into())
+    }
+
     /// Satisfy and execute this program in a transaction environment.
     ///
     /// NOTE: The utxos object is destroyed during the execution of the function, so the argument that was
diff --git a/lwk_wasm/src/tx_builder.rs b/lwk_wasm/src/tx_builder.rs
index bc58b340f..ab638e066 100644
--- a/lwk_wasm/src/tx_builder.rs
+++ b/lwk_wasm/src/tx_builder.rs
@@ -4,20 +4,58 @@ use lwk_wollet::{elements, UnvalidatedRecipient, Validated};
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    liquidex::ValidatedLiquidexProposal, Address, AssetId, Contract, Error, Network, OutPoint,
-    Pset, Transaction, Wollet,
+    liquidex::ValidatedLiquidexProposal, Address, AssetId, Contract, Error, ExternalUtxo, Network,
+    OutPoint, Pset, Script, Transaction, Wollet,
 };
 
+/// A recipient of newly issued asset units.
+#[wasm_bindgen]
+#[derive(Debug)]
+pub struct IssuanceRecipient {
+    inner: lwk_wollet::IssuanceRecipient,
+}
+
+impl From<IssuanceRecipient> for lwk_wollet::IssuanceRecipient {
+    fn from(value: IssuanceRecipient) -> Self {
+        value.inner
+    }
+}
+
+#[wasm_bindgen]
+impl IssuanceRecipient {
+    /// Create an issuance recipient using the next wallet external address.
+    pub fn wallet(satoshi: u64) -> IssuanceRecipient {
+        IssuanceRecipient {
+            inner: lwk_wollet::IssuanceRecipient::wallet(satoshi),
+        }
+    }
+
+    /// Create an issuance recipient from an address.
+    #[wasm_bindgen(js_name = fromAddress)]
+    pub fn from_address(satoshi: u64, address: &Address) -> IssuanceRecipient {
+        IssuanceRecipient {
+            inner: lwk_wollet::IssuanceRecipient::from_address(satoshi, address.as_ref()),
+        }
+    }
+}
+
 /// A transaction builder
 #[wasm_bindgen]
 #[derive(Debug)]
 pub struct TxBuilder {
     inner: lwk_wollet::TxBuilder,
+    /// Per-input sequence overrides applied in `finish`. Only populated by `setInputSequence`.
+    /// Must be set after all other builder methods — those methods go through
+    /// `From<lwk_wollet::TxBuilder>` which resets this field to an empty vec.
+    input_sequences: Vec<(elements::OutPoint, elements::Sequence)>,
 }
 
 impl From<lwk_wollet::TxBuilder> for TxBuilder {
     fn from(value: lwk_wollet::TxBuilder) -> Self {
-        Self { inner: value }
+        Self {
+            inner: value,
+            input_sequences: vec![],
+        }
     }
 }
 
@@ -34,12 +72,38 @@ impl TxBuilder {
     pub fn new(network: &Network) -> TxBuilder {
         TxBuilder {
             inner: lwk_wollet::TxBuilder::new(network.into()),
+            input_sequences: vec![],
         }
     }
 
-    /// Build the transaction
+    /// Build the transaction, applying any per-input sequence overrides set via
+    /// `setInputSequence`.
     pub fn finish(self, wollet: &Wollet) -> Result<Pset, Error> {
-        Ok(self.inner.finish(wollet.as_ref())?.into())
+        let input_sequences = self.input_sequences;
+        let mut pset = self.inner.finish(wollet.as_ref())?;
+        for input in pset.inputs_mut() {
+            let op = elements::OutPoint::new(input.previous_txid, input.previous_output_index);
+            if let Some(seq) =
+                input_sequences.iter().find_map(|(o, s)| (*o == op).then_some(*s))
+            {
+                input.sequence = Some(seq);
+            }
+        }
+        Ok(pset.into())
+    }
+
+    /// Override the nSequence for a specific input identified by its outpoint.
+    ///
+    /// Must be called **after** all other builder methods, because those methods go through
+    /// `From<lwk_wollet::TxBuilder>` which resets the per-input sequence list to empty.
+    ///
+    /// Pass `0xFFFFFFFE` (ENABLE_LOCKTIME_NO_RBF) to enable absolute locktime without RBF —
+    /// required by Simplicity's `check_lock_height` jet (returns 0 when all inputs are final).
+    #[wasm_bindgen(js_name = setInputSequence)]
+    pub fn set_input_sequence(mut self, outpoint: &OutPoint, sequence: u32) -> TxBuilder {
+        self.input_sequences
+            .push((outpoint.into(), elements::Sequence::from_consensus(sequence)));
+        self
     }
 
     /// Build the transaction for AMP0
@@ -125,6 +189,39 @@ impl TxBuilder {
             .into())
     }
 
+    /// Add an unblinded output with an arbitrary script pubkey to the post-issuance output list.
+    #[wasm_bindgen(js_name = addPostIssuanceScriptOutput)]
+    pub fn add_post_issuance_script_output(
+        self,
+        script_pubkey: &Script,
+        satoshi: u64,
+        asset: &AssetId,
+    ) -> TxBuilder {
+        self.inner
+            .add_post_issuance_script_output(script_pubkey.as_ref().clone(), satoshi, (*asset).into())
+            .into()
+    }
+
+    /// Add an address-based output to the post-issuance output list.
+    ///
+    /// Like `addPostIssuanceScriptOutput`, outputs are appended after all asset and issuance
+    /// outputs but before L-BTC change and fee, enabling precise vout ordering for covenant
+    /// transactions that depend on output indexes.
+    ///
+    /// Unlike `addPostIssuanceScriptOutput`, a confidential `address` produces a blinded
+    /// output visible to the wallet; an unconfidential address produces an explicit one.
+    #[wasm_bindgen(js_name = addPostIssuanceRecipient)]
+    pub fn add_post_issuance_recipient(
+        self,
+        address: &Address,
+        satoshi: u64,
+        asset: &AssetId,
+    ) -> TxBuilder {
+        self.inner
+            .add_post_issuance_recipient(address.as_ref(), satoshi, (*asset).into())
+            .into()
+    }
+
     /// Issue an asset
     ///
     /// There will be `asset_sats` units of this asset that will be received by
@@ -158,6 +255,32 @@ impl TxBuilder {
             .into())
     }
 
+    /// Issue an asset and send issued units to recipients.
+    ///
+    /// Recipient amounts are summed to determine the issued asset amount.
+    #[wasm_bindgen(js_name = issueAssetToRecipients)]
+    pub fn issue_asset_to_recipients(
+        self,
+        asset_recipients: Vec<IssuanceRecipient>,
+        token_sats: u64,
+        token_receiver: Option<Address>,
+        contract: Option<Contract>,
+        input_outpoint: Option<OutPoint>,
+    ) -> Result<TxBuilder, Error> {
+        let asset_recipients = asset_recipients.into_iter().map(Into::into).collect();
+        Ok(self
+            .inner
+            .issue_asset_to_recipients_at_input(
+                asset_recipients,
+                token_sats,
+                token_receiver.map(Into::into),
+                contract.map(Into::into),
+                input_outpoint.map(Into::into),
+            )?
+            .into())
+    }
+
+
     /// Reissue an asset
     ///
     /// reissue the asset defined by `asset_to_reissue`, provided the reissuance token is owned
@@ -205,6 +328,23 @@ impl TxBuilder {
         self.inner.set_wallet_utxos(outpoints).into()
     }
 
+    /// Set the exact order in which selected wallet and external inputs are added.
+    #[wasm_bindgen(js_name = setInputOrder)]
+    pub fn set_input_order(self, outpoints: Vec<OutPoint>) -> TxBuilder {
+        let outpoints: Vec<elements::OutPoint> = outpoints.into_iter().map(Into::into).collect();
+        self.inner.set_input_order(outpoints).into()
+    }
+
+    /// Adds external UTXOs
+    ///
+    /// Note: unblinded UTXOs with the same scriptpubkeys as the wallet, are considered external.
+    #[wasm_bindgen(js_name = addExternalUtxos)]
+    pub fn add_external_utxos(self, utxos: Vec<ExternalUtxo>) -> Result<TxBuilder, Error> {
+        let utxos: Vec<lwk_wollet::ExternalUtxo> =
+            utxos.iter().map(lwk_wollet::ExternalUtxo::from).collect();
+        Ok(self.inner.add_external_utxos(utxos)?.into())
+    }
+
     /// Return a string representation of the transaction builder (mostly for debugging)
     #[wasm_bindgen(js_name = toString)]
     pub fn to_string_js(&self) -> String {
@@ -240,6 +380,14 @@ impl TxBuilder {
     pub fn add_input_rangeproofs(self, add_rangeproofs: bool) -> TxBuilder {
         self.inner.add_input_rangeproofs(add_rangeproofs).into()
     }
+
+    /// Set the fallback locktime on the transaction as a block height.
+    #[wasm_bindgen(js_name = setFallbackLocktimeHeight)]
+    pub fn set_fallback_locktime_height(self, height: u32) -> Result<TxBuilder, Error> {
+        let locktime = elements::LockTime::from_height(height)
+            .map_err(|e| Error::Generic(e.to_string()))?;
+        Ok(self.inner.set_fallback_locktime(locktime).into())
+    }
 }
 
 impl Display for TxBuilder {
@@ -264,19 +412,19 @@ mod tests {
         let policy = network.policy_asset();
 
         let mut builder = TxBuilder::new(&network);
-        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [], fee_rate: 100.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: None, add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
+        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [], post_issuance_recipients: [], fee_rate: 100.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: None, add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
 
         builder = builder.fee_rate(Some(200.0));
-        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [], fee_rate: 200.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: None, add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
+        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [], post_issuance_recipients: [], fee_rate: 200.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: None, add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
 
         builder = builder.add_burn(1000, &policy);
-        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [Recipient { satoshi: 1000, script_pubkey: Script(OP_RETURN), blinding_pubkey: None, asset: 6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d }], fee_rate: 200.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: None, add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
+        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [Recipient { satoshi: 1000, script_pubkey: Script(OP_RETURN), blinding_pubkey: None, asset: 6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d }], post_issuance_recipients: [], fee_rate: 200.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: None, add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
 
         let o = OutPoint::new(
             "[elements]b93dbfb3fa1929b6f82ed46c4a5d8e1c96239ca8b3d9fce00c321d7dadbdf6e0:0",
         )
         .unwrap();
         builder = builder.set_wallet_utxos(vec![o]);
-        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [Recipient { satoshi: 1000, script_pubkey: Script(OP_RETURN), blinding_pubkey: None, asset: 6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d }], fee_rate: 200.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: Some([OutPoint { txid: b93dbfb3fa1929b6f82ed46c4a5d8e1c96239ca8b3d9fce00c321d7dadbdf6e0, vout: 0 }]), add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
+        assert_eq!(builder.to_string(), "TxBuilder { network: Liquid, recipients: [Recipient { satoshi: 1000, script_pubkey: Script(OP_RETURN), blinding_pubkey: None, asset: 6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d }], post_issuance_recipients: [], fee_rate: 200.0, ct_discount: true, issuance_request: None, drain_lbtc: false, drain_to: None, external_utxos: [], selected_utxos: Some([OutPoint { txid: b93dbfb3fa1929b6f82ed46c4a5d8e1c96239ca8b3d9fce00c321d7dadbdf6e0, vout: 0 }]), add_input_rangeproofs: true, is_liquidex_make: false, liquidex_proposals: [] }");
     }
 }
diff --git a/lwk_wollet/src/error.rs b/lwk_wollet/src/error.rs
index dd62e4a75..7d9cf673d 100644
--- a/lwk_wollet/src/error.rs
+++ b/lwk_wollet/src/error.rs
@@ -226,6 +226,9 @@ pub enum Error {
     #[error("Missing wallet UTXO {0}")]
     MissingWalletUtxo(OutPoint),
 
+    #[error("Input order contains duplicated outpoint {0}")]
+    DuplicatedOutpoint(OutPoint),
+
     #[error("Transaction has empty witness, did you forget to sign and finalize?")]
     EmptyWitness,
 
diff --git a/lwk_wollet/src/lib.rs b/lwk_wollet/src/lib.rs
index 8d74016b9..28c134cdc 100644
--- a/lwk_wollet/src/lib.rs
+++ b/lwk_wollet/src/lib.rs
@@ -133,6 +133,7 @@ pub use crate::model::{
     WalletTxOut,
 };
 pub use crate::pegin::fed_peg_script;
+pub use crate::pset_create::IssuanceRecipient;
 #[cfg(feature = "registry")]
 pub use crate::registry::RegistryAssetData;
 pub use crate::tx_details::{TxDetails, TxOpt, TxOutDetails, TxsOpt};
diff --git a/lwk_wollet/src/pset_create.rs b/lwk_wollet/src/pset_create.rs
index 24557a630..9193a6ed4 100644
--- a/lwk_wollet/src/pset_create.rs
+++ b/lwk_wollet/src/pset_create.rs
@@ -3,7 +3,7 @@ use crate::contract::Contract;
 use crate::elements::confidential::AssetBlindingFactor;
 use crate::elements::issuance::ContractHash;
 use crate::elements::pset::{Output, PartiallySignedTransaction};
-use crate::elements::{Address, AssetId, OutPoint, Transaction, TxOut, TxOutSecrets, Txid};
+use crate::elements::{Address, AssetId, OutPoint, Script, Transaction, TxOut, TxOutSecrets, Txid};
 use crate::error::Error;
 use crate::hashes::Hash;
 use crate::model::{Recipient, WalletTxOut};
@@ -19,10 +19,80 @@ pub const SECP256K1_SURJECTIONPROOF_MAX_N_INPUTS: usize = 256;
 // We make issuance and reissuance are mutually exclusive for simplicity
 pub enum IssuanceRequest {
     None,
-    Issuance(u64, Option<Address>, u64, Option<Address>, Option<Contract>),
+    Issuances(Vec<IssuanceRequestItem>),
     Reissuance(AssetId, u64, Option<Address>, Option<Transaction>),
 }
 
+#[derive(Debug)]
+pub struct IssuanceRequestItem {
+    pub asset_recipients: Vec<IssuanceRecipient>,
+    pub token_sats: u64,
+    pub token_receiver: Option<Address>,
+    pub contract: Option<Contract>,
+    pub input_outpoint: Option<OutPoint>,
+}
+
+/// Recipient of newly issued asset units.
+#[derive(Debug, Clone)]
+pub struct IssuanceRecipient {
+    satoshi: u64,
+    script_pubkey: Option<Script>,
+    blinding_pubkey: Option<crate::elements::secp256k1_zkp::PublicKey>,
+}
+
+impl IssuanceRecipient {
+    /// Create an issuance recipient using the next wallet external address.
+    pub fn wallet(satoshi: u64) -> Self {
+        Self {
+            satoshi,
+            script_pubkey: None,
+            blinding_pubkey: None,
+        }
+    }
+
+    /// Create an issuance recipient from an address.
+    pub fn from_address(satoshi: u64, address: &Address) -> Self {
+        Self {
+            satoshi,
+            script_pubkey: Some(address.script_pubkey()),
+            blinding_pubkey: address.blinding_pubkey,
+        }
+    }
+
+    /// Create an issuance recipient from a generic recipient.
+    ///
+    /// The recipient asset is ignored and replaced with the newly issued asset
+    /// when the PSET is created.
+    pub fn from_recipient(recipient: Recipient) -> Self {
+        Self {
+            satoshi: recipient.satoshi,
+            script_pubkey: Some(recipient.script_pubkey),
+            blinding_pubkey: recipient.blinding_pubkey,
+        }
+    }
+
+    pub(crate) fn satoshi(&self) -> u64 {
+        self.satoshi
+    }
+
+    pub(crate) fn into_recipient(
+        self,
+        wollet: &Wollet,
+        asset: AssetId,
+        last_unused_external: &mut u32,
+    ) -> Result<Recipient, Error> {
+        match self.script_pubkey {
+            Some(script_pubkey) => Ok(Recipient {
+                satoshi: self.satoshi,
+                script_pubkey,
+                blinding_pubkey: self.blinding_pubkey,
+                asset,
+            }),
+            None => wollet.addressee_external(self.satoshi, asset, last_unused_external),
+        }
+    }
+}
+
 impl Wollet {
     fn get_tx(&self, txid: &Txid) -> Result<Transaction, Error> {
         self.cache.tx(txid).ok_or(Error::MissingTransaction)
diff --git a/lwk_wollet/src/tx_builder.rs b/lwk_wollet/src/tx_builder.rs
index 17cf9bcd7..fed91bea1 100644
--- a/lwk_wollet/src/tx_builder.rs
+++ b/lwk_wollet/src/tx_builder.rs
@@ -4,7 +4,10 @@ use crate::{
     hashes::Hash,
     liquidex::{self, LiquidexError, Validated},
     model::{ExternalUtxo, IssuanceDetails, Recipient},
-    pset_create::{validate_address, IssuanceRequest, SECP256K1_SURJECTIONPROOF_MAX_N_INPUTS},
+    pset_create::{
+        validate_address, IssuanceRecipient, IssuanceRequest, IssuanceRequestItem,
+        SECP256K1_SURJECTIONPROOF_MAX_N_INPUTS,
+    },
     Contract, DownloadTxResult, Error, LiquidexProposal, Network, UnvalidatedRecipient, Update,
     Wollet, EC,
 };
@@ -13,8 +16,8 @@ use elements::{
     issuance::ContractHash,
     pset::{raw::ProprietaryKey, Output, PartiallySignedTransaction, PsbtSighashType},
     secp256k1_zkp::{self, RangeProof, SurjectionProof, ZERO_TWEAK},
-    Address, AssetId, BlindAssetProofs, BlindValueProofs, EcdsaSighashType, OutPoint, Script,
-    Transaction, TxOut, TxOutSecrets,
+    Address, AssetId, BlindAssetProofs, BlindValueProofs, EcdsaSighashType, LockTime, OutPoint,
+    Script, Transaction, TxOut, TxOutSecrets,
 };
 use lwk_common::calculate_fee;
 use rand::thread_rng;
@@ -53,6 +56,16 @@ pub fn extract_issuances(tx: &Transaction) -> Vec<IssuanceDetails> {
     r
 }
 
+fn sum_issuance_recipients(recipients: &[IssuanceRecipient]) -> Result<u64, Error> {
+    recipients.iter().try_fold(0u64, |sum, recipient| {
+        if recipient.satoshi() == 0 {
+            return Err(Error::InvalidAmount);
+        }
+        sum.checked_add(recipient.satoshi())
+            .ok_or(Error::InvalidAmount)
+    })
+}
+
 /// "Clone" of Wollet.add_input
 fn add_external_input(
     pset: &mut PartiallySignedTransaction,
@@ -155,6 +168,40 @@ pub(crate) fn add_input_inner(
     Ok(idx)
 }
 
+fn apply_issuance_request_item(
+    wollet: &Wollet,
+    pset: &mut PartiallySignedTransaction,
+    input_indexes_by_outpoint: &HashMap<OutPoint, usize>,
+    item: IssuanceRequestItem,
+    last_unused_external: &mut u32,
+) -> Result<(), Error> {
+    let satoshi_asset = sum_issuance_recipients(&item.asset_recipients)?;
+    let idx = match item.input_outpoint {
+        Some(outpoint) => *input_indexes_by_outpoint
+            .get(&outpoint)
+            .ok_or(Error::MissingWalletUtxo(outpoint))?,
+        None => 0,
+    };
+
+    let (asset, token) =
+        wollet.set_issuance(pset, idx, satoshi_asset, item.token_sats, item.contract)?;
+
+    for recipient in item.asset_recipients {
+        let addressee = recipient.into_recipient(wollet, asset, last_unused_external)?;
+        wollet.add_output(pset, &addressee)?;
+    }
+
+    if item.token_sats > 0 {
+        let addressee = match item.token_receiver {
+            Some(address) => Recipient::from_address(item.token_sats, &address, token),
+            None => wollet.addressee_external(item.token_sats, token, last_unused_external)?,
+        };
+        wollet.add_output(pset, &addressee)?;
+    }
+
+    Ok(())
+}
+
 /// A transaction builder
 ///
 /// See [`WolletTxBuilder`] for usage from rust.
@@ -169,6 +216,7 @@ pub(crate) fn add_input_inner(
 pub struct TxBuilder {
     network: Network,
     recipients: Vec<Recipient>,
+    post_issuance_recipients: Vec<Recipient>,
     fee_rate: f32,
     ct_discount: bool,
     issuance_request: IssuanceRequest,
@@ -177,9 +225,12 @@ pub struct TxBuilder {
     external_utxos: Vec<ExternalUtxo>,
 
     selected_utxos: Option<Vec<OutPoint>>,
+    input_order: Option<Vec<OutPoint>>,
 
     add_input_rangeproofs: bool,
 
+    fallback_locktime: Option<LockTime>,
+
     // LiquiDEX fields
     is_liquidex_make: bool,
     liquidex_proposals: Vec<LiquidexProposal<Validated>>,
@@ -191,6 +242,7 @@ impl TxBuilder {
         TxBuilder {
             network,
             recipients: vec![],
+            post_issuance_recipients: vec![],
             fee_rate: 100.0,
             ct_discount: true,
             issuance_request: IssuanceRequest::None,
@@ -198,7 +250,9 @@ impl TxBuilder {
             drain_to: None,
             external_utxos: vec![],
             selected_utxos: None,
+            input_order: None,
             add_input_rangeproofs: true,
+            fallback_locktime: None,
             is_liquidex_make: false,
             liquidex_proposals: vec![],
         }
@@ -282,6 +336,48 @@ impl TxBuilder {
         Ok(self)
     }
 
+    /// Add an unblinded output with an arbitrary script pubkey to the post-issuance output list.
+    ///
+    /// Outputs are appended after all asset and issuance outputs but before L-BTC change and fee,
+    /// enabling precise vout ordering for covenant transactions that depend on output indexes.
+    pub fn add_post_issuance_script_output(
+        mut self,
+        script_pubkey: Script,
+        satoshi: u64,
+        asset: AssetId,
+    ) -> Self {
+        self.post_issuance_recipients.push(Recipient {
+            satoshi,
+            script_pubkey,
+            blinding_pubkey: None,
+            asset,
+        });
+        self
+    }
+
+    /// Add an address-based output to the post-issuance output list.
+    ///
+    /// Like [`add_post_issuance_script_output`], outputs are appended after all asset and issuance
+    /// outputs but before L-BTC change and fee, enabling precise vout ordering for covenant
+    /// transactions that depend on output indexes.
+    ///
+    /// Unlike [`add_post_issuance_script_output`], a confidential `address` produces a blinded
+    /// output visible to the wallet; an unconfidential address produces an explicit one.
+    pub fn add_post_issuance_recipient(
+        mut self,
+        address: &Address,
+        satoshi: u64,
+        asset: AssetId,
+    ) -> Self {
+        self.post_issuance_recipients.push(Recipient {
+            satoshi,
+            script_pubkey: address.script_pubkey(),
+            blinding_pubkey: address.blinding_pubkey,
+            asset,
+        });
+        self
+    }
+
     /// Fee rate in sats/kvb
     /// Multiply sats/vb value by 1000 i.e. 1.0 sat/byte = 1000.0 sat/kvb
     pub fn fee_rate(mut self, fee_rate: Option<f32>) -> Self {
@@ -334,6 +430,11 @@ impl TxBuilder {
         self
     }
 
+    pub fn set_fallback_locktime(mut self, locktime: LockTime) -> Self {
+        self.fallback_locktime = Some(locktime);
+        self
+    }
+
     /// Issue an asset
     ///
     /// There will be `asset_sats` units of this asset that will be received by
@@ -347,35 +448,86 @@ impl TxBuilder {
     ///
     /// Can't be used if `reissue_asset` has been called
     pub fn issue_asset(
-        mut self,
+        self,
         asset_sats: u64,
         asset_receiver: Option<Address>,
         token_sats: u64,
         token_receiver: Option<Address>,
         contract: Option<Contract>,
     ) -> Result<Self, Error> {
-        if !matches!(self.issuance_request, IssuanceRequest::None) {
-            return Err(Error::IssuanceAlreadySet);
-        }
         if let Some(addr) = asset_receiver.as_ref() {
             validate_address(&addr.to_string(), self.network())?;
         }
+        let asset_recipients = match asset_receiver {
+            Some(address) => vec![IssuanceRecipient::from_address(asset_sats, &address)],
+            None if asset_sats > 0 => vec![IssuanceRecipient::wallet(asset_sats)],
+            None => vec![],
+        };
+        self.issue_asset_to_recipients(asset_recipients, token_sats, token_receiver, contract)
+    }
+
+    /// Issue an asset and send issued units to recipients.
+    ///
+    /// Recipient amounts are summed to determine the issued asset amount.
+    pub fn issue_asset_to_recipients(
+        self,
+        asset_recipients: Vec<IssuanceRecipient>,
+        token_sats: u64,
+        token_receiver: Option<Address>,
+        contract: Option<Contract>,
+    ) -> Result<Self, Error> {
+        self.issue_asset_to_recipients_at_input(
+            asset_recipients,
+            token_sats,
+            token_receiver,
+            contract,
+            None,
+        )
+    }
+
+    /// Issue an asset and send issued units to recipients from a specific transaction input.
+    ///
+    /// Recipient amounts are summed to determine the issued asset amount. When `input_outpoint` is
+    /// `None`, the issuance is attached to input 0, matching the legacy `issue_asset_to_recipients`
+    /// behavior.
+    pub fn issue_asset_to_recipients_at_input(
+        mut self,
+        asset_recipients: Vec<IssuanceRecipient>,
+        token_sats: u64,
+        token_receiver: Option<Address>,
+        contract: Option<Contract>,
+        input_outpoint: Option<OutPoint>,
+    ) -> Result<Self, Error> {
+        if matches!(self.issuance_request, IssuanceRequest::Reissuance(..)) {
+            return Err(Error::IssuanceAlreadySet);
+        }
         if let Some(addr) = token_receiver.as_ref() {
             validate_address(&addr.to_string(), self.network())?;
         }
+        let asset_sats = sum_issuance_recipients(&asset_recipients)?;
         if asset_sats == 0 && token_sats == 0 {
             return Err(Error::InvalidAmount);
         }
         if asset_sats > 21_000_000 * 100_000_000 {
             return Err(Error::IssuanceAmountGreaterThanBtcMax);
         }
-        self.issuance_request = IssuanceRequest::Issuance(
-            asset_sats,
-            asset_receiver,
+
+        let item = IssuanceRequestItem {
+            asset_recipients,
             token_sats,
             token_receiver,
             contract,
-        );
+            input_outpoint,
+        };
+
+        match &mut self.issuance_request {
+            IssuanceRequest::None => {
+                self.issuance_request = IssuanceRequest::Issuances(vec![item]);
+            }
+            IssuanceRequest::Issuances(items) => items.push(item),
+            IssuanceRequest::Reissuance(..) => unreachable!("checked above"),
+        }
+
         Ok(self)
     }
 
@@ -454,6 +606,16 @@ impl TxBuilder {
         self
     }
 
+    /// Set the exact order in which selected wallet and external inputs are added.
+    ///
+    /// This is intended for covenant transactions whose programs depend on input indexes. When set,
+    /// no automatic wallet input selection is performed; every input required by the transaction must
+    /// be present in this list and available either as a wallet UTXO or as an external UTXO.
+    pub fn set_input_order(mut self, input_order: Vec<OutPoint>) -> Self {
+        self.input_order = Some(input_order);
+        self
+    }
+
     /// Set data to create a PSET from which you
     /// can create a LiquiDEX proposal
     pub fn liquidex_make(
@@ -884,6 +1046,10 @@ impl TxBuilder {
         // Init PSET
         let mut pset = PartiallySignedTransaction::new_v2();
 
+        if let Some(locktime) = self.fallback_locktime {
+            pset.global.tx_data.fallback_locktime = Some(locktime);
+        }
+
         let genesis_block_hash = self.network().genesis_hash().to_byte_array().to_vec();
         // Add genesis block hash as defined in ELIP-101 https://github.com/ElementsProject/ELIPs/blob/main/elip-0101.mediawiki
         // TODO: upstream to rust elements
@@ -916,9 +1082,60 @@ impl TxBuilder {
             }
         }
 
+        let mut input_indexes_by_outpoint = HashMap::new();
+        let mut manual_satoshi_in_by_asset: HashMap<AssetId, u64> = HashMap::new();
+        let external_utxos_by_outpoint: HashMap<OutPoint, &ExternalUtxo> = self
+            .external_utxos
+            .iter()
+            .map(|utxo| (utxo.outpoint, utxo))
+            .collect();
+
+        if let Some(input_order) = &self.input_order {
+            for outpoint in input_order {
+                if input_indexes_by_outpoint.contains_key(outpoint) {
+                    return Err(Error::DuplicatedOutpoint(*outpoint));
+                }
+
+                if let Some(utxo) = utxos.get(outpoint) {
+                    let idx = wollet.add_input(
+                        &mut pset,
+                        &mut inp_txout_sec,
+                        &mut inp_weight,
+                        utxo,
+                        self.add_input_rangeproofs,
+                    )?;
+                    input_indexes_by_outpoint.insert(*outpoint, idx);
+                    *manual_satoshi_in_by_asset
+                        .entry(utxo.unblinded.asset)
+                        .or_default() += utxo.unblinded.value;
+                } else if let Some(utxo) = external_utxos_by_outpoint.get(outpoint) {
+                    let idx = add_external_input(
+                        &mut pset,
+                        &mut inp_txout_sec,
+                        &mut inp_weight,
+                        utxo,
+                        self.add_input_rangeproofs,
+                    )?;
+                    input_indexes_by_outpoint.insert(*outpoint, idx);
+                    *manual_satoshi_in_by_asset
+                        .entry(utxo.unblinded.asset)
+                        .or_default() += utxo.unblinded.value;
+                } else {
+                    return Err(Error::MissingWalletUtxo(*outpoint));
+                }
+            }
+        }
+
         // Assets that belongs to this transaction
         // all the ones with a recipient
         let mut assets: HashSet<_> = addressees_asset.iter().map(|a| a.asset).collect();
+        // and all the ones with post-issuance recipients
+        assets.extend(
+            self.post_issuance_recipients
+                .iter()
+                .filter(|a| a.asset != policy_asset)
+                .map(|a| a.asset),
+        );
         // and all the ones of utxos that are being added
         for utxo in &self.external_utxos {
             assets.insert(utxo.unblinded.asset);
@@ -936,48 +1153,63 @@ impl TxBuilder {
                 wollet.add_output(&mut pset, addressee)?;
                 satoshi_out += addressee.satoshi;
             }
-
-            // Add all external asset utxos
-            for utxo in &self.external_utxos {
-                if utxo.unblinded.asset != asset {
-                    continue;
+            satoshi_out += self
+                .post_issuance_recipients
+                .iter()
+                .filter(|a| a.asset == asset)
+                .map(|a| a.satoshi)
+                .sum::<u64>();
+
+            if self.input_order.is_some() {
+                satoshi_in = *manual_satoshi_in_by_asset.get(&asset).unwrap_or(&0);
+            } else {
+                // Add all external asset utxos
+                for utxo in &self.external_utxos {
+                    if utxo.unblinded.asset != asset {
+                        continue;
+                    }
+                    let idx = add_external_input(
+                        &mut pset,
+                        &mut inp_txout_sec,
+                        &mut inp_weight,
+                        utxo,
+                        self.add_input_rangeproofs,
+                    )?;
+                    input_indexes_by_outpoint.insert(utxo.outpoint, idx);
+                    satoshi_in += utxo.unblinded.value;
                 }
-                add_external_input(
-                    &mut pset,
-                    &mut inp_txout_sec,
-                    &mut inp_weight,
-                    utxo,
-                    self.add_input_rangeproofs,
-                )?;
-                satoshi_in += utxo.unblinded.value;
             }
 
-            if self.selected_utxos.is_some() {
+            if self.input_order.is_some() {
+                // Manual input order is authoritative; do not add more inputs.
+            } else if self.selected_utxos.is_some() {
                 // Add only selected asset utxos
                 for utxo in &selected_utxos {
                     if utxo.unblinded.asset != asset {
                         continue;
                     }
-                    wollet.add_input(
+                    let idx = wollet.add_input(
                         &mut pset,
                         &mut inp_txout_sec,
                         &mut inp_weight,
                         utxo,
                         self.add_input_rangeproofs,
                     )?;
+                    input_indexes_by_outpoint.insert(utxo.outpoint, idx);
                     satoshi_in += utxo.unblinded.value;
                 }
             } else {
                 // Add more asset utxos until we cover the amount to send
                 if satoshi_in < satoshi_out {
                     for utxo in utxos.values().filter(|u| u.unblinded.asset == asset) {
-                        wollet.add_input(
+                        let idx = wollet.add_input(
                             &mut pset,
                             &mut inp_txout_sec,
                             &mut inp_weight,
                             utxo,
                             self.add_input_rangeproofs,
                         )?;
+                        input_indexes_by_outpoint.insert(utxo.outpoint, idx);
                         satoshi_in += utxo.unblinded.value;
                         if satoshi_in >= satoshi_out {
                             break;
@@ -1012,46 +1244,61 @@ impl TxBuilder {
             wollet.add_output(&mut pset, &addressee)?;
             satoshi_out += addressee.satoshi;
         }
+        satoshi_out += self
+            .post_issuance_recipients
+            .iter()
+            .filter(|a| a.asset == policy_asset)
+            .map(|a| a.satoshi)
+            .sum::<u64>();
 
-        // Add all external L-BTC utxos
-        for utxo in &self.external_utxos {
-            if utxo.unblinded.asset != policy_asset {
-                continue;
+        if self.input_order.is_some() {
+            satoshi_in = *manual_satoshi_in_by_asset.get(&policy_asset).unwrap_or(&0);
+        } else {
+            // Add all external L-BTC utxos
+            for utxo in &self.external_utxos {
+                if utxo.unblinded.asset != policy_asset {
+                    continue;
+                }
+                let idx = add_external_input(
+                    &mut pset,
+                    &mut inp_txout_sec,
+                    &mut inp_weight,
+                    utxo,
+                    self.add_input_rangeproofs,
+                )?;
+                input_indexes_by_outpoint.insert(utxo.outpoint, idx);
+                satoshi_in += utxo.unblinded.value;
             }
-            add_external_input(
-                &mut pset,
-                &mut inp_txout_sec,
-                &mut inp_weight,
-                utxo,
-                self.add_input_rangeproofs,
-            )?;
-            satoshi_in += utxo.unblinded.value;
         }
 
-        if self.selected_utxos.is_some() {
+        if self.input_order.is_some() {
+            // Manual input order is authoritative; do not add more inputs.
+        } else if self.selected_utxos.is_some() {
             for utxo in &selected_utxos {
                 if utxo.unblinded.asset != policy_asset {
                     continue;
                 }
-                wollet.add_input(
+                let idx = wollet.add_input(
                     &mut pset,
                     &mut inp_txout_sec,
                     &mut inp_weight,
                     utxo,
                     self.add_input_rangeproofs,
                 )?;
+                input_indexes_by_outpoint.insert(utxo.outpoint, idx);
                 satoshi_in += utxo.unblinded.value;
             }
         } else {
             // FIXME: For implementation simplicity now we always add all L-BTC inputs
             for utxo in utxos.values().filter(|u| u.unblinded.asset == policy_asset) {
-                wollet.add_input(
+                let idx = wollet.add_input(
                     &mut pset,
                     &mut inp_txout_sec,
                     &mut inp_weight,
                     utxo,
                     self.add_input_rangeproofs,
                 )?;
+                input_indexes_by_outpoint.insert(utxo.outpoint, idx);
                 satoshi_in += utxo.unblinded.value;
             }
         }
@@ -1059,40 +1306,15 @@ impl TxBuilder {
         // Set (re)issuance data
         match self.issuance_request {
             IssuanceRequest::None => {}
-            IssuanceRequest::Issuance(
-                satoshi_asset,
-                address_asset,
-                satoshi_token,
-                address_token,
-                contract,
-            ) => {
-                // At least a L-BTC input for the fee was added.
-                let idx = 0;
-                let (asset, token) =
-                    wollet.set_issuance(&mut pset, idx, satoshi_asset, satoshi_token, contract)?;
-
-                if satoshi_asset > 0 {
-                    let addressee = match address_asset {
-                        Some(address) => Recipient::from_address(satoshi_asset, &address, asset),
-                        None => wollet.addressee_external(
-                            satoshi_asset,
-                            asset,
-                            &mut last_unused_external,
-                        )?,
-                    };
-                    wollet.add_output(&mut pset, &addressee)?;
-                }
-
-                if satoshi_token > 0 {
-                    let addressee = match address_token {
-                        Some(address) => Recipient::from_address(satoshi_token, &address, token),
-                        None => wollet.addressee_external(
-                            satoshi_token,
-                            token,
-                            &mut last_unused_external,
-                        )?,
-                    };
-                    wollet.add_output(&mut pset, &addressee)?;
+            IssuanceRequest::Issuances(items) => {
+                for item in items {
+                    apply_issuance_request_item(
+                        wollet,
+                        &mut pset,
+                        &input_indexes_by_outpoint,
+                        item,
+                        &mut last_unused_external,
+                    )?;
                 }
             }
             IssuanceRequest::Reissuance(asset, satoshi_asset, address_asset, issuance_tx) => {
@@ -1166,6 +1388,10 @@ impl TxBuilder {
             }
         }
 
+        for addressee in &self.post_issuance_recipients {
+            wollet.add_output(&mut pset, addressee)?;
+        }
+
         // Add a temporary fee, and always add a change or drain output,
         // then we'll tweak those values to match the given fee rate.
         let temp_fee = 1;
@@ -1561,6 +1787,25 @@ impl<'a> WolletTxBuilder<'a> {
         })
     }
 
+    /// Wrapper of [`TxBuilder::issue_asset_to_recipients()`]
+    pub fn issue_asset_to_recipients(
+        self,
+        asset_recipients: Vec<IssuanceRecipient>,
+        token_sats: u64,
+        token_receiver: Option<Address>,
+        contract: Option<Contract>,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            wollet: self.wollet,
+            inner: self.inner.issue_asset_to_recipients(
+                asset_recipients,
+                token_sats,
+                token_receiver,
+                contract,
+            )?,
+        })
+    }
+
     /// Wrapper of [`TxBuilder::reissue_asset()`]
     pub fn reissue_asset(
         self,