bindings: add missing constructors, utils, and lock time type

Author: KyrylR

lwk_bindings/src/blockdata/out_point.rs

@@ -45,6 +45,14 @@ impl OutPoint {
         Ok(Arc::new(Self { inner }))
     }
 
+    /// Create an OutPoint from a transaction id and output index.
+    #[uniffi::constructor]
+    pub fn from_parts(txid: &Txid, vout: u32) -> Arc<Self> {
+        Arc::new(Self {
+            inner: elements::OutPoint::new(txid.into(), vout),
+        })
+    }
+
     /// Return the transaction identifier.
     pub fn txid(&self) -> Arc<Txid> {
         Arc::new(self.inner.txid.into())
@@ -58,7 +66,7 @@ impl OutPoint {
 
 #[cfg(test)]
 mod tests {
-    use crate::OutPoint;
+    use crate::{OutPoint, Txid};
     use std::str::FromStr;
 
     #[test]
@@ -82,4 +90,20 @@ mod tests {
 
         assert_eq!(expected_vout, out_point.vout());
     }
+
+    #[test]
+    fn test_out_point_from_parts() {
+        let txid_hex = "0000000000000000000000000000000000000000000000000000000000000001";
+        let txid = Txid::new(&txid_hex.parse().unwrap()).unwrap();
+        let vout = 5;
+
+        let out_point = OutPoint::from_parts(&txid, vout);
+
+        assert_eq!(out_point.txid().to_string(), txid_hex);
+        assert_eq!(out_point.vout(), vout);
+        assert_eq!(
+            out_point.to_string(),
+            format!("[elements]{txid_hex}:{vout}")
+        );
+    }
 }

lwk_bindings/src/blockdata/script.rs

@@ -46,6 +46,22 @@ impl Script {
         Ok(Arc::new(Self { inner }))
     }
 
+    /// Create an empty script (for fee outputs).
+    #[uniffi::constructor]
+    pub fn empty() -> Arc<Self> {
+        Arc::new(Self {
+            inner: elements::Script::new(),
+        })
+    }
+
+    /// Create an OP_RETURN script (for burn outputs).
+    #[uniffi::constructor]
+    pub fn new_op_return(data: Vec<u8>) -> Arc<Self> {
+        Arc::new(Self {
+            inner: elements::Script::new_op_return(&data),
+        })
+    }
+
     /// Return the consensus encoded bytes of the script.
     pub fn bytes(&self) -> Vec<u8> {
         self.inner.as_bytes().to_vec()
@@ -99,4 +115,21 @@ mod tests {
         let burn = Script::new(&"6a".parse().unwrap()).unwrap();
         assert!(burn.is_provably_unspendable());
     }
+
+    #[test]
+    fn test_script_empty() {
+        let script = Script::empty();
+        assert!(script.bytes().is_empty());
+        assert_eq!(script.to_string(), "");
+        assert_eq!(script.to_asm(), "");
+    }
+
+    #[test]
+    fn test_script_op_return() {
+        let data = b"burn".to_vec();
+        let script = Script::new_op_return(data.clone());
+        // OP_RETURN + OP_PUSHBYTES_4 + "burn"
+        assert!(script.is_provably_unspendable());
+        assert!(script.to_asm().starts_with("OP_RETURN"));
+    }
 }

lwk_bindings/src/blockdata/transaction.rs

@@ -4,7 +4,7 @@ use elements::{
     hex::ToHex,
     pset::serialize::{Deserialize, Serialize},
 };
-use lwk_wollet::WalletTx;
+use lwk_wollet::{WalletTx, EC};
 
 use crate::{
     types::{AssetId, Hex},
@@ -103,6 +103,15 @@ impl Transaction {
             .map(|i| Arc::new(i.clone().into()))
             .collect()
     }
+
+    /// Verify transaction amount proofs against UTXOs.
+    ///
+    /// See [`elements::Transaction::verify_tx_amt_proofs`].
+    pub fn verify_tx_amt_proofs(&self, utxos: Vec<Arc<TxOut>>) -> Result<(), LwkError> {
+        let utxos_inner: Vec<elements::TxOut> = utxos.iter().map(|u| u.as_ref().into()).collect();
+        self.inner.verify_tx_amt_proofs(&EC, &utxos_inner)?;
+        Ok(())
+    }
 }
 
 #[cfg(test)]

lwk_bindings/src/blockdata/tx_out_secrets.rs

@@ -2,11 +2,13 @@
 
 use std::sync::Arc;
 
-use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
 use elements::secp256k1_zkp::{Generator, PedersenCommitment, Tag};
 use lwk_wollet::EC;
 
-use crate::types::{AssetId, Hex};
+use crate::types::{
+    AssetBlindingFactor as BindingsAssetBlindingFactor, AssetId, Hex,
+    ValueBlindingFactor as BindingsValueBlindingFactor,
+};
 
 /// Contains unblinded information such as the asset and the value of a transaction output
 #[derive(uniffi::Object, PartialEq, Eq, Debug)]
@@ -28,15 +30,33 @@ impl From<&TxOutSecrets> for elements::TxOutSecrets {
 
 #[uniffi::export]
 impl TxOutSecrets {
+    /// Create TxOutSecrets with explicit blinding factors.
+    #[uniffi::constructor]
+    pub fn new(
+        asset_id: AssetId,
+        asset_bf: &BindingsAssetBlindingFactor,
+        value: u64,
+        value_bf: &BindingsValueBlindingFactor,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            inner: elements::TxOutSecrets::new(
+                asset_id.into(),
+                asset_bf.into(),
+                value,
+                value_bf.into(),
+            ),
+        })
+    }
+
     /// Create TxOutSecrets from explicit (unblinded) values.
     #[uniffi::constructor]
     pub fn from_explicit(asset_id: AssetId, value: u64) -> Arc<Self> {
         Arc::new(Self {
             inner: elements::TxOutSecrets::new(
                 asset_id.into(),
-                AssetBlindingFactor::zero(),
+                elements::confidential::AssetBlindingFactor::zero(),
                 value,
-                ValueBlindingFactor::zero(),
+                elements::confidential::ValueBlindingFactor::zero(),
             ),
         })
     }
@@ -71,8 +91,8 @@ impl TxOutSecrets {
 
     /// Return true if the output is explicit (no blinding factors).
     pub fn is_explicit(&self) -> bool {
-        self.inner.asset_bf == AssetBlindingFactor::zero()
-            && self.inner.value_bf == ValueBlindingFactor::zero()
+        self.inner.asset_bf == elements::confidential::AssetBlindingFactor::zero()
+            && self.inner.value_bf == elements::confidential::ValueBlindingFactor::zero()
     }
 
     /// Get the asset commitment
@@ -118,10 +138,14 @@ impl TxOutSecrets {
 
 #[cfg(test)]
 mod tests {
+    use crate::UniffiCustomTypeConverter;
+    use crate::{types, TxOutSecrets};
+
+    use std::str::FromStr;
+
     use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
     use elements::hex::FromHex;
     use elements::AssetId;
-    use std::str::FromStr;
 
     #[test]
     fn tx_out_secrets() {
@@ -164,4 +188,23 @@ mod tests {
         assert_eq!(txoutsecrets_blinded.asset_commitment().to_string(), ac_hex);
         assert_eq!(txoutsecrets_blinded.value_commitment().to_string(), vc_hex);
     }
+
+    #[test]
+    fn test_tx_out_secrets_new_with_blinding() {
+        let asset_hex = "1111111111111111111111111111111111111111111111111111111111111111";
+        let abf_hex = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        let vbf_hex = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+
+        let asset_id = types::AssetId::into_custom(asset_hex.to_string()).unwrap();
+        let asset_bf = types::AssetBlindingFactor::from_hex(abf_hex).unwrap();
+        let value_bf = types::ValueBlindingFactor::from_hex(vbf_hex).unwrap();
+
+        let secrets = TxOutSecrets::new(asset_id, &asset_bf, 1000, &value_bf);
+
+        assert!(!secrets.is_explicit());
+        assert_eq!(secrets.asset().to_string(), asset_hex);
+        assert_eq!(secrets.asset_bf().to_string(), abf_hex);
+        assert_eq!(secrets.value(), 1000);
+        assert_eq!(secrets.value_bf().to_string(), vbf_hex);
+    }
 }

lwk_bindings/src/error.rs

@@ -209,6 +209,22 @@ impl From<elements::bitcoin::bip32::Error> for LwkError {
     }
 }
 
+impl From<elements::locktime::Error> for LwkError {
+    fn from(value: elements::locktime::Error) -> Self {
+        LwkError::Generic {
+            msg: format!("{value:?}"),
+        }
+    }
+}
+
+impl From<elements::VerificationError> for LwkError {
+    fn from(value: elements::VerificationError) -> Self {
+        LwkError::Generic {
+            msg: format!("{value:?}"),
+        }
+    }
+}
+
 #[cfg(feature = "simplicity")]
 impl From<lwk_simplicity_options::error::ProgramError> for LwkError {
     fn from(value: lwk_simplicity_options::error::ProgramError) -> Self {

lwk_bindings/src/lib.rs

@@ -71,7 +71,8 @@ pub use blockdata::wallet_tx_out::WalletTxOut;
 pub use crate::contract::Contract;
 pub use crate::signer::{Bip, Signer};
 pub use crate::types::{
-    AssetBlindingFactor, Keypair, PublicKey, TxSequence, ValueBlindingFactor, XOnlyPublicKey,
+    AssetBlindingFactor, Keypair, LockTime, PublicKey, TxSequence, ValueBlindingFactor,
+    XOnlyPublicKey,
 };
 pub use crate::wollet::Wollet;
 pub use chain::Chain;