Update dependancies and fixups to FFI bindings

Cargo.toml

@@ -14,9 +14,9 @@ name = "simplicity"
 path = "src/lib.rs"
 
 [dependencies]
-bitcoin = { version = "0.28", optional = true }
-bitcoin_hashes = "0.10"
+bitcoin = { version = "0.29.2", optional = true }
+bitcoin_hashes = "0.11"
 byteorder = "1.3"
-elements = { version = "0.19", optional = true }
-miniscript = "7.0"
+elements = { version = "0.21.1", optional = true }
+miniscript = "9.0.0"
 simplicity_sys = { version = "0.1.0", path = "./simplicity-sys" }

src/jet/bitcoin/environment.rs

@@ -12,6 +12,8 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
+use bitcoin::PackedLockTime;
+
 /// Environment for Bitcoin Simplicity
 pub struct BitcoinEnv {
     pub tx: bitcoin::Transaction,
@@ -28,7 +30,7 @@ impl Default for BitcoinEnv {
         // FIXME: Review and check if the defaults make sense
         BitcoinEnv::new(bitcoin::Transaction {
             version: 2,
-            lock_time: 0,
+            lock_time: PackedLockTime::ZERO,
             input: vec![],
             output: vec![],
         })

src/jet/bitcoin/exec.rs

@@ -11,7 +11,7 @@ pub(crate) fn version(mac: &mut BitMachine, env: &BitcoinEnv) -> Result<(), JetF
 }
 
 pub(crate) fn lock_time(mac: &mut BitMachine, env: &BitcoinEnv) -> Result<(), JetFailed> {
-    mac.write_u32(env.tx.lock_time);
+    mac.write_u32(env.tx.lock_time.0);
     Ok(())
 }
 
@@ -22,7 +22,7 @@ pub(crate) fn inputs_hash(mac: &mut BitMachine, env: &BitcoinEnv) -> Result<(),
         eng.write_u32::<LittleEndian>(input.previous_output.vout)
             .unwrap();
         eng.write_u64::<LittleEndian>(99_998_000).unwrap(); // value FIXME
-        eng.write_u32::<LittleEndian>(input.sequence).unwrap();
+        eng.write_u32::<LittleEndian>(input.sequence.0).unwrap();
     }
     mac.write_bytes(&sha256::Hash::from_engine(eng)[..]);
     Ok(())

src/jet/elements/c_env.rs

@@ -43,24 +43,43 @@ fn new_raw_input(
 ) -> CRawInput {
     unsafe {
         let mut raw_input = std::mem::MaybeUninit::<CRawInput>::uninit();
+
+        let (issue_nonce_ptr, issue_entropy_ptr, issue_amt_ptr, issue_infl_key_ptr) =
+            if inp.has_issuance() {
+                (
+                    inp.asset_issuance.asset_blinding_nonce.as_ptr(),
+                    inp.asset_issuance.asset_entropy.as_ptr(),
+                    value_ptr(inp.asset_issuance.amount, &inp_data.issuance_amount),
+                    value_ptr(
+                        inp.asset_issuance.inflation_keys,
+                        &inp_data.issuance_inflation_keys,
+                    ),
+                )
+            } else {
+                (
+                    std::ptr::null(),
+                    std::ptr::null(),
+                    std::ptr::null(),
+                    std::ptr::null(),
+                )
+            };
         c_set_rawInput(
             raw_input.as_mut_ptr(),
-            opt_ptr(annex_ptr(&inp_data.annex).as_ref()), // FIXME: ACTUALLY STORE ANNEX
-            std::ptr::null(),                             // FIXME: ACTUALLY STORE PEGIN
+            opt_ptr(annex_ptr(&inp_data.annex).as_ref()),
+            inp.pegin_data()
+                .map(|x| x.genesis_hash.as_ptr())
+                .unwrap_or(std::ptr::null()),
             &script_ptr(&inp.script_sig),
             inp.previous_output.txid.as_ptr(),
             inp.previous_output.vout as c_uint,
             asset_ptr(in_utxo.asset, &inp_data.asset),
             value_ptr(in_utxo.value, &inp_data.value),
             &script_ptr(&in_utxo.script_pubkey),
-            inp.sequence as c_uint,
-            inp.asset_issuance.asset_blinding_nonce.as_ptr(), // FIXME: CHECK ASSET ISSUANCE IS NOT NULL. EASIER WITH NEW ELEMENTS VERSION.
-            inp.asset_issuance.asset_entropy.as_ptr(),
-            value_ptr(inp.asset_issuance.amount, &inp_data.issuance_amount),
-            value_ptr(
-                inp.asset_issuance.inflation_keys,
-                &inp_data.issuance_inflation_keys,
-            ),
+            inp.sequence.0 as c_uint,
+            issue_nonce_ptr, // FIXME: CHECK ASSET ISSUANCE IS NOT NULL. EASIER WITH NEW ELEMENTS VERSION.
+            issue_entropy_ptr,
+            issue_amt_ptr,
+            issue_infl_key_ptr,
             &range_proof_ptr(&inp_data.amount_range_proof),
             &range_proof_ptr(&inp_data.inflation_keys_range_proof),
         );
@@ -125,7 +144,7 @@ pub(super) fn new_tx(tx: &elements::Transaction, in_utxos: &[ElementsUtxo]) -> *
             raw_inputs.len() as c_uint,
             raw_outputs.as_ptr(),
             raw_outputs.len() as c_uint,
-            tx.lock_time as c_uint,
+            tx.lock_time.0 as c_uint,
         );
         let raw_tx = raw_tx.assume_init();
         elements_simplicity_mallocTransaction(&raw_tx)

src/jet/elements/environment.rs

@@ -312,7 +312,7 @@ impl SimplicityHash for elements::TxIn {
         eng.input(&self.previous_output.txid);
         eng.write_u32::<LittleEndian>(self.previous_output.vout)
             .unwrap();
-        eng.write_u32::<LittleEndian>(self.sequence).unwrap();
+        eng.write_u32::<LittleEndian>(self.sequence.0).unwrap();
         if self.has_issuance() {
             self.asset_issuance.simplicity_hash(eng);
         } else {

src/jet/elements/exec.rs

@@ -27,7 +27,7 @@ pub(crate) fn version(mac: &mut BitMachine, env: &ElementsEnv) -> Result<(), Jet
 }
 
 pub(crate) fn lock_time(mac: &mut BitMachine, env: &ElementsEnv) -> Result<(), JetFailed> {
-    mac.write_u32(env.tx.lock_time);
+    mac.write_u32(env.tx.lock_time.0);
     Ok(())
 }
 
@@ -118,7 +118,7 @@ pub(crate) fn input_sequence(mac: &mut BitMachine, env: &ElementsEnv) -> Result<
 
     if is_valid_idx {
         let seq = env.tx.input[idx].sequence;
-        mac.write_u32(seq);
+        mac.write_u32(seq.0);
     } else {
         // 32 bits for sequence.
         mac.skip(32);
@@ -347,7 +347,7 @@ pub(crate) fn current_script_hash(
 pub(crate) fn current_sequence(mac: &mut BitMachine, env: &ElementsEnv) -> Result<(), JetFailed> {
     let curr_idx = env.ix as usize;
     let curr_inp = &env.tx.input[curr_idx];
-    mac.write_u32(curr_inp.sequence);
+    mac.write_u32(curr_inp.sequence.0);
     Ok(())
 }
 
@@ -358,7 +358,7 @@ pub(crate) fn current_issuance_blinding(
     let curr_idx = env.ix as usize;
     let curr_inp = &env.tx.input[curr_idx];
 
-    if curr_inp.has_issuance {
+    if curr_inp.has_issuance() {
         blinding_issuance(mac, &curr_inp.asset_issuance);
         Ok(())
     } else {
@@ -373,7 +373,7 @@ pub(crate) fn current_issuance_contract(
     let curr_idx = env.ix as usize;
     let curr_inp = &env.tx.input[curr_idx];
 
-    if curr_inp.has_issuance {
+    if curr_inp.has_issuance() {
         contract_issuance(mac, &curr_inp.asset_issuance);
         Ok(())
     } else {
@@ -388,7 +388,7 @@ pub(crate) fn current_issuance_entropy(
     let curr_idx = env.ix as usize;
     let curr_inp = &env.tx.input[curr_idx];
 
-    if curr_inp.has_issuance {
+    if curr_inp.has_issuance() {
         entropy_issuance(mac, &curr_inp.asset_issuance);
         Ok(())
     } else {
@@ -412,7 +412,7 @@ pub(crate) fn current_issuance_token_amount(
     let curr_idx = env.ix as usize;
     let curr_inp = &env.tx.input[curr_idx];
 
-    if curr_inp.has_issuance {
+    if curr_inp.has_issuance() {
         inflation_amt_issuance(mac, &curr_inp.asset_issuance)
     } else {
         Err(JetFailed)

src/jet/elements/tests.rs

@@ -13,8 +13,8 @@ use bitcoin_hashes::Hash;
 use elements::secp256k1_zkp::Tweak;
 use elements::taproot::ControlBlock;
 use elements::{
-    confidential, AssetId, AssetIssuance, BlockHash, OutPoint, Transaction, TxIn, TxInWitness,
-    TxOut, TxOutWitness,
+    confidential, AssetId, AssetIssuance, BlockHash, OutPoint, PackedLockTime, Sequence,
+    Transaction, TxIn, TxInWitness, TxOut, TxOutWitness,
 };
 
 #[test]
@@ -81,15 +81,14 @@ fn exec_sighash_all() {
     let asset = confidential::Asset::Explicit(AssetId::from_inner(Midstate::from_inner(asset)));
     let tx = Transaction {
         version: 2,
-        lock_time: 0,
+        lock_time: PackedLockTime::ZERO,
         input: vec![TxIn {
             previous_output: OutPoint {
                 txid: elements::Txid::from_inner(tx_id),
                 vout: 0,
             },
-            sequence: 0xfffffffe,
+            sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
             is_pegin: false,
-            has_issuance: false,
             // perhaps make this an option in elements upstream?
             asset_issuance: AssetIssuance {
                 asset_blinding_nonce: Tweak::from_inner([0; 32]).expect("tweak from inner"),
@@ -142,7 +141,7 @@ fn exec_sighash_all() {
         script_cmr,
         ctrl_block,
         None,
-        BlockHash::default(),
+        BlockHash::all_zeros(),
     );
 
     let mut bits: BitIter<_> = sighash_all::ELEMENTS_CHECK_SIGHASH_ALL
@@ -175,15 +174,14 @@ fn test_ffi_env() {
     let asset = confidential::Asset::Explicit(AssetId::from_inner(Midstate::from_inner(asset)));
     let tx = Transaction {
         version: 2,
-        lock_time: 100,
+        lock_time: PackedLockTime(100),
         input: vec![TxIn {
             previous_output: OutPoint {
                 txid: elements::Txid::from_inner(tx_id),
                 vout: 0,
             },
-            sequence: 0xfffffffe,
+            sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
             is_pegin: false,
-            has_issuance: false,
             // perhaps make this an option in elements upstream?
             asset_issuance: AssetIssuance {
                 asset_blinding_nonce: Tweak::from_inner([0; 32]).expect("tweak from inner"),
@@ -236,7 +234,7 @@ fn test_ffi_env() {
         script_cmr,
         ctrl_block,
         None,
-        BlockHash::default(),
+        BlockHash::all_zeros(),
     );
 
     let mut mac = BitMachine {