From a0b54351d7303f0ee9339c96411ed33d4c2989a0 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 18:59:43 +0000 Subject: [PATCH 01/10] simplicity-sys: split up bitcoin and elements build Don't actually build bitcoin yet; just refactor build.rs --- simplicity-sys/build.rs | 138 ++++++++++++++++++++++++++++------------ 1 file changed, 98 insertions(+), 40 deletions(-) diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index 14470d74..065166ce 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -7,56 +7,105 @@ fn main() { // rerun if changes to the C code println!("cargo:rerun-if-changed=depend"); let simplicity_path = Path::new("depend/simplicity"); - let jet_files: Vec<_> = vec![ - "frame.c", - "jets.c", - "jets-secp256k1.c", - "rsort.c", - "sha256.c", - "elements/env.c", - "elements/ops.c", - "elements/elementsJets.c", - "elements/txEnv.c", - ] - .into_iter() - .map(|x| simplicity_path.join(x)) - .collect(); + let mut files = vec![]; + + // 1. Base files. + files.extend( + [ + "frame.c", + "jets.c", + "jets-secp256k1.c", + "rsort.c", + "sha256.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + // 2. Test files. + if cfg!(feature = "test-utils") { + files.extend( + [ + "bitstream.c", + "dag.c", + "deserialize.c", + "eval.c", + "type.c", + "typeInference.c", + "ctx8Pruned.c", + "ctx8Unpruned.c", + "hashBlock.c", + "schnorr0.c", + "schnorr6.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + } + + // Split into Bitcoin and Elements. + let mut elements_files = files.clone(); + let mut bitcoin_files = files; + + // 3B. Bitcoin base files. + bitcoin_files.extend( + [ + "bitcoin/env.c", + "bitcoin/ops.c", + "bitcoin/bitcoinJets.c", + "bitcoin/txEnv.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + + // 3E. Elements base files. + elements_files.extend( + [ + "elements/env.c", + "elements/ops.c", + "elements/elementsJets.c", + "elements/txEnv.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + + if cfg!(feature = "test-utils") { + // 4B. Bitcoin base files. + bitcoin_files.extend( + [ + "bitcoin/exec.c", + "bitcoin/primitive.c", + // "bitcoin/checkSigHashAllTx1.c", // no sighashall test + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + + // 4E. Elements base files. + elements_files.extend( + [ + "elements/exec.c", + "elements/primitive.c", + "elements/checkSigHashAllTx1.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + } + + // General build let mut build = cc::Build::new(); build .std("c11") .flag_if_supported("-fno-inline-functions") .opt_level(2) - .files(jet_files) .file(Path::new("depend/wrapper.c")) .file(Path::new("depend/env.c")) .file(Path::new("depend/jets_wrapper.c")) .include(simplicity_path.join("include")); - if cfg!(feature = "test-utils") { - let test_files: Vec<_> = vec![ - "bitstream.c", - "dag.c", - "deserialize.c", - "eval.c", - "type.c", - "typeInference.c", - "elements/exec.c", - "elements/primitive.c", - "ctx8Pruned.c", - "ctx8Unpruned.c", - "hashBlock.c", - "schnorr0.c", - "schnorr6.c", - "elements/checkSigHashAllTx1.c", - ] - .into_iter() - .map(|x| simplicity_path.join(x)) - .collect(); - - build.files(test_files); - } - if cfg!(not(fuzzing)) { build.define("PRODUCTION", None); } @@ -66,5 +115,14 @@ fn main() { build.include("wasm-sysroot"); } - build.compile("ElementsSimplicity"); + let mut _bitcoin_build = build.clone(); + let mut elements_build = build; + + // Bitcoin build + // TODO + + // Elements build + elements_build + .files(elements_files) + .compile("ElementsSimplicity"); } From 8607ed8a35ebfee79658b2a54ca2618c84a81b0d Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 21:02:43 +0000 Subject: [PATCH 02/10] simplicity-sys: split env.c into bitcoin_env.c For dumb "C polymorphism" reasons we have two structures in the C code named txEnv. We can call the corresponding Rust structures different things, but we need to access them from the C file env.c, which provides some C wrappers for FFI stuff. Since you can't have two different structs with the same name in one compilation unit, split it into two: add depend/bitcoin_env.c holding the Bitcoin txEnv wrappers, alongside the existing depend/env.c for Elements. --- simplicity-sys/build.rs | 3 ++- simplicity-sys/depend/bitcoin_env.c | 31 +++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 simplicity-sys/depend/bitcoin_env.c diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index 065166ce..4643be4a 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -58,6 +58,7 @@ fn main() { .into_iter() .map(|x| simplicity_path.join(x)), ); + bitcoin_files.push("depend/bitcoin_env.c".into()); // 3E. Elements base files. elements_files.extend( @@ -70,6 +71,7 @@ fn main() { .into_iter() .map(|x| simplicity_path.join(x)), ); + elements_files.push("depend/env.c".into()); if cfg!(feature = "test-utils") { // 4B. Bitcoin base files. @@ -102,7 +104,6 @@ fn main() { .flag_if_supported("-fno-inline-functions") .opt_level(2) .file(Path::new("depend/wrapper.c")) - .file(Path::new("depend/env.c")) .file(Path::new("depend/jets_wrapper.c")) .include(simplicity_path.join("include")); diff --git a/simplicity-sys/depend/bitcoin_env.c b/simplicity-sys/depend/bitcoin_env.c new file mode 100644 index 00000000..99928e88 --- /dev/null +++ b/simplicity-sys/depend/bitcoin_env.c @@ -0,0 +1,31 @@ +#include +#include +#include "simplicity/bitcoin/env.h" +#include "simplicity/bitcoin/txEnv.h" +#include "simplicity/bitcoin/primitive.h" + +typedef rawBitcoinBuffer rawBuffer; +typedef rawBitcoinBuffer rawBuffer; +typedef rawBitcoinOutput rawOutput; +typedef rawBitcoinInput rawInput; +typedef rawBitcoinTransaction rawTransaction; +typedef rawBitcoinTapEnv rawTapEnv; + +const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinBuffer = sizeof(rawBitcoinBuffer); +const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinOutput = sizeof(rawBitcoinOutput); +const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinInput = sizeof(rawBitcoinInput); +const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinTransaction = sizeof(rawBitcoinTransaction); +const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinTapEnv = sizeof(rawBitcoinTapEnv); +const size_t rustsimplicity_0_8_c_sizeof_bitcoinTxEnv = sizeof(txEnv); + +const size_t rustsimplicity_0_8_c_alignof_rawBitcoinBuffer = alignof(rawBitcoinBuffer); +const size_t rustsimplicity_0_8_c_alignof_rawBitcoinOutput = alignof(rawBitcoinOutput); +const size_t rustsimplicity_0_8_c_alignof_rawBitcoinInput = alignof(rawBitcoinInput); +const size_t rustsimplicity_0_8_c_alignof_rawBitcoinTransaction = alignof(rawBitcoinTransaction); +const size_t rustsimplicity_0_8_c_alignof_rawBitcoinTapEnv = alignof(rawBitcoinTapEnv); +const size_t rustsimplicity_0_8_c_alignof_bitcoinTxEnv = alignof(txEnv); + +void rustsimplicity_0_8_c_bitcoin_set_txEnv(txEnv *result, const bitcoinTransaction *tx, const bitcoinTapEnv *taproot, unsigned int ix) +{ + *result = rustsimplicity_0_8_bitcoin_build_txEnv(tx, taproot, ix); +} From 0182d01e859af2a8fec3b5e859338cc342657b0e Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 19:56:00 +0000 Subject: [PATCH 03/10] simplicity-sys: define bitcoin transaction environment --- simplicity-sys/src/c_jets/c_env/bitcoin.rs | 176 +++++++++++++++++++++ simplicity-sys/src/c_jets/c_env/mod.rs | 1 + simplicity-sys/src/c_jets/mod.rs | 2 +- simplicity-sys/src/lib.rs | 1 + 4 files changed, 179 insertions(+), 1 deletion(-) create mode 100644 simplicity-sys/src/c_jets/c_env/bitcoin.rs diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs new file mode 100644 index 00000000..dfb3e8a8 --- /dev/null +++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs @@ -0,0 +1,176 @@ +// SPDX-License-Identifier: CC0-1.0 + +use hashes::sha256; + +use crate::ffi::sha256::CSha256Midstate; +use crate::ffi::{c_size_t, c_uchar, c_uint, c_uint_fast32_t}; + +#[derive(Debug)] +#[repr(C)] +pub struct CRawBuffer { + pub ptr: *const c_uchar, + pub len: u32, +} + +#[derive(Debug)] +#[repr(C)] +pub struct CRawOutput { + pub value: u64, + pub script_pubkey: CRawBuffer, +} + +#[repr(C)] +pub struct CRawInput<'raw> { + pub annex: *const CRawBuffer, + pub prev_txid: &'raw [c_uchar; 32], + pub txo: CRawOutput, + pub script_sig: CRawBuffer, + pub prev_txout_index: u32, + pub sequence: u32, +} + +#[derive(Debug)] +#[repr(C)] +pub struct CRawTransaction<'raw> { + pub txid: &'raw [c_uchar; 32], + pub inputs: *const CRawInput<'raw>, + pub outputs: *const CRawOutput, + pub n_inputs: u32, + pub n_outputs: u32, + pub version: u32, + pub locktime: u32, +} + +#[derive(Debug)] +#[repr(C)] +pub struct CRawTapEnv { + pub control_block: *const c_uchar, + pub script_cmr: *const c_uchar, + pub branch_len: u8, +} + +#[repr(C)] +pub struct CTransaction { + _data: (), +} + +#[derive(Debug)] +#[repr(C)] +pub struct CTxEnv { + tx: *const CTransaction, + taproot: *const CTapEnv, + sighash_all: CSha256Midstate, + ix: c_uint_fast32_t, +} + +#[repr(C)] +pub struct CTapEnv { + _data: (), +} + +/* +// Will uncomment in a later commit; need to update libsimplicity first so these +// symbols have something to link against. +extern "C" { + #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinBuffer"] + pub static c_sizeof_rawBuffer: c_size_t; + #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinOutput"] + pub static c_sizeof_rawOutput: c_size_t; + #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinInput"] + pub static c_sizeof_rawInput: c_size_t; + #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinTransaction"] + pub static c_sizeof_rawTransaction: c_size_t; + #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinTapEnv"] + pub static c_sizeof_rawTapEnv: c_size_t; + #[link_name = "rustsimplicity_0_8_c_sizeof_bitcoinTxEnv"] + pub static c_sizeof_txEnv: c_size_t; + + #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinBuffer"] + pub static c_alignof_rawBuffer: c_size_t; + #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinOutput"] + pub static c_alignof_rawOutput: c_size_t; + #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinInput"] + pub static c_alignof_rawInput: c_size_t; + #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinTransaction"] + pub static c_alignof_rawTransaction: c_size_t; + #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinTapEnv"] + pub static c_alignof_rawTapEnv: c_size_t; + #[link_name = "rustsimplicity_0_8_c_alignof_bitcoinTxEnv"] + pub static c_alignof_txEnv: c_size_t; + + #[link_name = "rustsimplicity_0_8_c_bitcoin_set_txEnv"] + pub fn c_set_txEnv( + result: *mut CTxEnv, + tx: *const CTransaction, + taproot: *const CTapEnv, + ix: c_uint, + ); + #[link_name = "rustsimplicity_0_8_bitcoin_mallocTapEnv"] + pub fn simplicity_mallocTapEnv(rawEnv: *const CRawTapEnv) -> *mut CTapEnv; + #[link_name = "rustsimplicity_0_8_bitcoin_mallocTransaction"] + pub fn simplicity_mallocTransaction(rawTx: *const CRawTransaction) -> *mut CTransaction; +} +*/ +impl CTxEnv { + pub fn sighash_all(&self) -> sha256::Hash { + let midstate: sha256::Midstate = self.sighash_all.into(); + sha256::Hash::from_byte_array(midstate.to_parts().0) + } +} + +// Pointer must be manually free after dropping +impl Drop for CTxEnv { + fn drop(&mut self) { + unsafe { + crate::alloc::rust_0_8_free(self.tx as *mut u8); + crate::alloc::rust_0_8_free(self.taproot as *mut u8); + } + } +} + +impl CRawBuffer { + pub fn new(buf: &[c_uchar]) -> Self { + Self { + ptr: buf.as_ptr(), + len: buf.len().try_into().expect("sane buffer lengths"), + } + } +} + +/* +// Will uncomment in a later commit; need to update libsimplicity first. +#[cfg(test)] +mod tests { + use core::mem::{align_of, size_of}; + + use crate::c_jets::frame_ffi::{c_alignof_frameItem, c_sizeof_frameItem, CFrameItem}; + + use super::*; + + #[test] + fn test_sizes() { + unsafe { + assert_eq!(size_of::(), c_sizeof_frameItem); + assert_eq!(size_of::(), c_sizeof_rawBuffer); + assert_eq!(size_of::(), c_sizeof_rawInput); + assert_eq!(size_of::(), c_sizeof_rawOutput); + assert_eq!(size_of::(), c_sizeof_rawTransaction); + assert_eq!(size_of::(), c_sizeof_rawTapEnv); + assert_eq!(size_of::(), c_sizeof_txEnv); + } + } + + #[test] + fn test_aligns() { + unsafe { + assert_eq!(align_of::(), c_alignof_frameItem); + assert_eq!(align_of::(), c_alignof_rawBuffer); + assert_eq!(align_of::(), c_alignof_rawInput); + assert_eq!(align_of::(), c_alignof_rawOutput); + assert_eq!(align_of::(), c_alignof_rawTransaction); + assert_eq!(align_of::(), c_alignof_rawTapEnv); + assert_eq!(align_of::(), c_alignof_txEnv); + } + } +} +*/ diff --git a/simplicity-sys/src/c_jets/c_env/mod.rs b/simplicity-sys/src/c_jets/c_env/mod.rs index fcca587c..6136d485 100644 --- a/simplicity-sys/src/c_jets/c_env/mod.rs +++ b/simplicity-sys/src/c_jets/c_env/mod.rs @@ -1,3 +1,4 @@ // SPDX-License-Identifier: CC0-1.0 +pub mod bitcoin; pub mod elements; diff --git a/simplicity-sys/src/c_jets/mod.rs b/simplicity-sys/src/c_jets/mod.rs index ae2fc852..a163cf57 100644 --- a/simplicity-sys/src/c_jets/mod.rs +++ b/simplicity-sys/src/c_jets/mod.rs @@ -12,7 +12,7 @@ pub mod frame_ffi; #[rustfmt::skip] pub mod jets_ffi; #[rustfmt::skip] pub mod jets_wrapper; -pub use c_env::elements; +pub use c_env::{bitcoin, elements}; pub use c_frame::{byte_width, uword_width}; pub use frame_ffi::CFrameItem; diff --git a/simplicity-sys/src/lib.rs b/simplicity-sys/src/lib.rs index f032d902..b35f3541 100644 --- a/simplicity-sys/src/lib.rs +++ b/simplicity-sys/src/lib.rs @@ -1,6 +1,7 @@ // SPDX-License-Identifier: CC0-1.0 pub mod c_jets; +pub use c_jets::bitcoin; pub use c_jets::elements; pub use c_jets::CFrameItem; From 87549f61737ba96f070fd9641ac2f77b353cdd62 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 18 Dec 2025 16:49:05 +0000 Subject: [PATCH 04/10] jet: switch from Deref to Borrow for transaction environments This is the more correct trait. When we update the Jet trait we will be forced to pick one, and we will pick Borrow. --- src/jet/bitcoin/environment.rs | 26 +++++++++++--------------- src/jet/elements/environment.rs | 10 +++++----- src/policy/sighash.rs | 2 +- 3 files changed, 17 insertions(+), 21 deletions(-) diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs index c530cec6..22c9f85a 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -1,26 +1,22 @@ // SPDX-License-Identifier: CC0-1.0 -use bitcoin::absolute; +use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; /// Environment for Bitcoin Simplicity -pub struct BitcoinEnv { - pub tx: bitcoin::Transaction, +// In later commit, when we update Jet trait, will remove default type. +pub struct BitcoinEnv { + pub tx: T, } -impl BitcoinEnv { - pub fn new(tx: bitcoin::Transaction) -> Self { +impl BitcoinEnv +where + T: core::borrow::Borrow, +{ + pub fn new(tx: T) -> Self { BitcoinEnv { tx } } -} -impl Default for BitcoinEnv { - fn default() -> Self { - // FIXME: Review and check if the defaults make sense - BitcoinEnv::new(bitcoin::Transaction { - version: bitcoin::transaction::Version::TWO, - lock_time: absolute::LockTime::ZERO, - input: vec![], - output: vec![], - }) + pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv { + unimplemented!() } } diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs index 202582c4..812bf388 100644 --- a/src/jet/elements/environment.rs +++ b/src/jet/elements/environment.rs @@ -4,7 +4,7 @@ use crate::merkle::cmr::Cmr; use elements::confidential; use elements::taproot::ControlBlock; use simplicity_sys::c_jets::c_env::elements as c_elements; -use std::ops::Deref; +use std::borrow::Borrow; use super::c_env; @@ -37,7 +37,7 @@ impl From for ElementsUtxo { /// The order of `utxos` must be same as of the order of inputs in the /// transaction. #[derive(Debug)] -pub struct ElementsEnv> { +pub struct ElementsEnv> { /// The CTxEnv struct c_tx_env: c_elements::CTxEnv, /// The elements transaction @@ -54,7 +54,7 @@ pub struct ElementsEnv> { impl ElementsEnv where - T: Deref, + T: Borrow, { pub fn new( tx: T, @@ -65,7 +65,7 @@ where annex: Option>, genesis_hash: elements::BlockHash, ) -> Self { - let c_tx = c_env::new_tx(&tx, &utxos); + let c_tx = c_env::new_tx(tx.borrow(), &utxos); let c_tap_env = c_env::new_tap_env(&control_block, script_cmr); let c_tx_env = c_env::new_tx_env(c_tx, c_tap_env, genesis_hash, ix); ElementsEnv { @@ -85,7 +85,7 @@ where /// Returns the transaction of this environment pub fn tx(&self) -> &elements::Transaction { - &self.tx + self.tx.borrow() } /// Returns the input index of this environment diff --git a/src/policy/sighash.rs b/src/policy/sighash.rs index 2766c454..d65ca7aa 100644 --- a/src/policy/sighash.rs +++ b/src/policy/sighash.rs @@ -81,7 +81,7 @@ impl + Clone> SighashCache { .collect(); let simplicity_env = crate::jet::elements::ElementsEnv::new( - self.tx.clone(), + (*self.tx).borrow(), utxos, input_index as u32, script_cmr, From 528243ad84a0d8cbb29392c1ef938cfd17b5774b Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 18:47:15 +0000 Subject: [PATCH 05/10] simplicity-sys: update libsimplicity to bitcoin branch Updates to https://github.com/BlockstreamResearch/simplicity/pull/324 This PR does a couple things simultaneously: * Runs vendor-simplicity.sh and update-jets.sh * Updates the `Jet` trait to have associated transaction and environment types, and for the environment to be paramterized by the transaction type. * Changes the Core environment from () to CoreEnv:: * Updates some fixed Core CMR/IHR vectors (this update to libsimplicity changes the benchmarks for the Core jets and thus changes these vectors) * Uncomments the commented-out symbols in simplicity-sys/src/c_jets/c_env/bitcoin.rs * Adds the "build bitcoin" lines to simplicity-sys/build.rs The update to the `Jet` trait is a bit noisy but ultimately mechanical: everywhere that we're generic over all J: Jet, we now also have to be generic over all T: Borrow, which leads to some extra line noise especially in unit tests where we have assert_* helper functions. The last four points are tiny diffs, thanks to the previous preparatory commits. The use of CoreEnv:: as the core environment type is kinda fun. It means that it is impossible to execute any code which attempts to access the transaction in the environment. (No such code exists, since it would be nonsensical, but now we have some assurance that it won't exist by accident in the future.) Unfortunately this mixes mechanical and non-mechanical things in one commit. But the mechanical changes are exclusively in simplicity-sys/depend/ and src/jet/init/ and the non-mechanical changes are exclusively outside of those files, so it should be possible to review this. --- simplicity-sys/build.rs | 32 +- simplicity-sys/depend/jets_wrapper.c | 61 + .../depend/simplicity-HEAD-revision.txt | 2 +- .../depend/simplicity/CMakeLists.txt | 38 + simplicity-sys/depend/simplicity/Makefile | 4 +- .../depend/simplicity/bitcoin/cmr.c | 22 + .../depend/simplicity/bitcoin/exec.c | 136 ++ simplicity-sys/depend/simplicity/cmr.c | 41 + simplicity-sys/depend/simplicity/cmr.h | 24 + .../depend/simplicity/deserialize.c | 5 + .../depend/simplicity/elements/cmr.c | 25 +- .../include/simplicity/bitcoin/cmr.h | 23 + .../include/simplicity/bitcoin/exec.h | 40 + simplicity-sys/depend/simplicity/test.c | 31 + simplicity-sys/src/c_jets/c_env/bitcoin.rs | 5 +- simplicity-sys/src/c_jets/jets_ffi.rs | 330 ++-- simplicity-sys/src/c_jets/jets_wrapper.rs | 1394 ++++++++++------- simplicity-sys/src/lib.rs | 1 + src/jet/bitcoin/environment.rs | 3 +- src/jet/bitcoin/mod.rs | 7 +- src/jet/init/bitcoin.rs | 436 +++++- src/jet/init/core.rs | 2 +- src/jet/init/elements.rs | 2 +- 23 files changed, 1937 insertions(+), 727 deletions(-) create mode 100644 simplicity-sys/depend/simplicity/CMakeLists.txt create mode 100644 simplicity-sys/depend/simplicity/bitcoin/cmr.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/exec.c create mode 100644 simplicity-sys/depend/simplicity/cmr.c create mode 100644 simplicity-sys/depend/simplicity/cmr.h create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index 4643be4a..7873473d 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -43,11 +43,17 @@ fn main() { ); } - // Split into Bitcoin and Elements. - let mut elements_files = files.clone(); - let mut bitcoin_files = files; + // Common files are compiled once into their own static library; Bitcoin + // and Elements each get their own library with only the chain-specific + // files. Duplicating the common files into both the Bitcoin and Elements + // libraries (as before) builds fine on stable (the linker only pulls the + // archive members it needs), but MSRV (1.74.0) forces `--whole-archive` + // on every native static lib, which pulls every object from both copies + // and fails with "multiple definition of" for every common symbol. + let common_files = files; // 3B. Bitcoin base files. + let mut bitcoin_files = vec![]; bitcoin_files.extend( [ "bitcoin/env.c", @@ -61,6 +67,7 @@ fn main() { bitcoin_files.push("depend/bitcoin_env.c".into()); // 3E. Elements base files. + let mut elements_files = vec![]; elements_files.extend( [ "elements/env.c", @@ -103,8 +110,6 @@ fn main() { .std("c11") .flag_if_supported("-fno-inline-functions") .opt_level(2) - .file(Path::new("depend/wrapper.c")) - .file(Path::new("depend/jets_wrapper.c")) .include(simplicity_path.join("include")); if cfg!(not(fuzzing)) { @@ -116,11 +121,24 @@ fn main() { build.include("wasm-sysroot"); } - let mut _bitcoin_build = build.clone(); + let mut common_build = build.clone(); + let mut bitcoin_build = build.clone(); let mut elements_build = build; + // Common build: files shared between Bitcoin and Elements, including the + // wrapper files. Compiled once into its own static library so neither + // the Bitcoin nor the Elements library contains these object files -- + // see the comment above `common_files` for why that matters. + common_build + .file(Path::new("depend/wrapper.c")) + .file(Path::new("depend/jets_wrapper.c")) + .files(common_files) + .compile("RustSimplicityCommon"); + // Bitcoin build - // TODO + bitcoin_build + .files(bitcoin_files) + .compile("BitcoinSimplicity"); // Elements build elements_build diff --git a/simplicity-sys/depend/jets_wrapper.c b/simplicity-sys/depend/jets_wrapper.c index bbc84bcd..0912dd84 100644 --- a/simplicity-sys/depend/jets_wrapper.c +++ b/simplicity-sys/depend/jets_wrapper.c @@ -1,5 +1,6 @@ /* This file has been automatically generated. */ +#include "simplicity/bitcoin/bitcoinJets.h" #include "simplicity/elements/elementsJets.h" #include "simplicity/simplicity_assert.h" #include "wrapper.h" @@ -17,6 +18,7 @@ WRAP_(and_16) WRAP_(and_32) WRAP_(and_64) WRAP_(and_8) +WRAP_(bitcoin_annex_hash) WRAP_(annex_hash) WRAP_(asset_amount_hash) WRAP_(bip_0340_verify) @@ -24,8 +26,11 @@ WRAP_(broken_do_not_use_check_lock_distance) WRAP_(broken_do_not_use_check_lock_duration) WRAP_(broken_do_not_use_tx_lock_distance) WRAP_(broken_do_not_use_tx_lock_duration) +WRAP_(bitcoin_build_tapbranch) WRAP_(build_tapbranch) +WRAP_(bitcoin_build_tapleaf_simplicity) WRAP_(build_tapleaf_simplicity) +WRAP_(bitcoin_build_taptweak) WRAP_(build_taptweak) WRAP_(calculate_asset) WRAP_(calculate_confidential_token) @@ -36,7 +41,11 @@ WRAP_(ch_16) WRAP_(ch_32) WRAP_(ch_64) WRAP_(ch_8) +WRAP_(bitcoin_check_lock_distance) +WRAP_(bitcoin_check_lock_duration) +WRAP_(bitcoin_check_lock_height) WRAP_(check_lock_height) +WRAP_(bitcoin_check_lock_time) WRAP_(check_lock_time) WRAP_(check_sig_verify) WRAP_(complement_1) @@ -45,8 +54,10 @@ WRAP_(complement_32) WRAP_(complement_64) WRAP_(complement_8) WRAP_(current_amount) +WRAP_(bitcoin_current_annex_hash) WRAP_(current_annex_hash) WRAP_(current_asset) +WRAP_(bitcoin_current_index) WRAP_(current_index) WRAP_(current_issuance_asset_amount) WRAP_(current_issuance_asset_proof) @@ -54,12 +65,17 @@ WRAP_(current_issuance_token_amount) WRAP_(current_issuance_token_proof) WRAP_(current_new_issuance_contract) WRAP_(current_pegin) +WRAP_(bitcoin_current_prev_outpoint) WRAP_(current_prev_outpoint) WRAP_(current_reissuance_blinding) WRAP_(current_reissuance_entropy) +WRAP_(bitcoin_current_script_hash) WRAP_(current_script_hash) +WRAP_(bitcoin_current_script_sig_hash) WRAP_(current_script_sig_hash) +WRAP_(bitcoin_current_sequence) WRAP_(current_sequence) +WRAP_(bitcoin_current_value) WRAP_(decompress) WRAP_(decrement_16) WRAP_(decrement_32) @@ -94,6 +110,7 @@ WRAP_(fe_negate) WRAP_(fe_normalize) WRAP_(fe_square) WRAP_(fe_square_root) +WRAP_(bitcoin_fee) WRAP_(full_add_16) WRAP_(full_add_32) WRAP_(full_add_64) @@ -180,22 +197,39 @@ WRAP_(increment_64) WRAP_(increment_8) WRAP_(input_amount) WRAP_(input_amounts_hash) +WRAP_(bitcoin_input_annex_hash) WRAP_(input_annex_hash) +WRAP_(bitcoin_input_annexes_hash) WRAP_(input_annexes_hash) WRAP_(input_asset) +WRAP_(bitcoin_input_hash) WRAP_(input_hash) +WRAP_(bitcoin_input_outpoints_hash) WRAP_(input_outpoints_hash) WRAP_(input_pegin) +WRAP_(bitcoin_input_prev_outpoint) WRAP_(input_prev_outpoint) +WRAP_(bitcoin_input_script_hash) WRAP_(input_script_hash) +WRAP_(bitcoin_input_script_sig_hash) WRAP_(input_script_sig_hash) +WRAP_(bitcoin_input_script_sigs_hash) WRAP_(input_script_sigs_hash) +WRAP_(bitcoin_input_scripts_hash) WRAP_(input_scripts_hash) +WRAP_(bitcoin_input_sequence) WRAP_(input_sequence) +WRAP_(bitcoin_input_sequences_hash) WRAP_(input_sequences_hash) +WRAP_(bitcoin_input_utxo_hash) WRAP_(input_utxo_hash) +WRAP_(bitcoin_input_utxos_hash) WRAP_(input_utxos_hash) +WRAP_(bitcoin_input_value) +WRAP_(bitcoin_input_values_hash) +WRAP_(bitcoin_inputs_hash) WRAP_(inputs_hash) +WRAP_(bitcoin_internal_key) WRAP_(internal_key) WRAP_(is_one_16) WRAP_(is_one_32) @@ -286,6 +320,7 @@ WRAP_(leftmost_8_2) WRAP_(leftmost_8_4) WRAP_(linear_combination_1) WRAP_(linear_verify_1) +WRAP_(bitcoin_lock_time) WRAP_(lock_time) WRAP_(low_1) WRAP_(low_16) @@ -327,7 +362,9 @@ WRAP_(negate_64) WRAP_(negate_8) WRAP_(new_issuance_contract) WRAP_(nonce_hash) +WRAP_(bitcoin_num_inputs) WRAP_(num_inputs) +WRAP_(bitcoin_num_outputs) WRAP_(num_outputs) WRAP_(one_16) WRAP_(one_32) @@ -338,10 +375,12 @@ WRAP_(or_16) WRAP_(or_32) WRAP_(or_64) WRAP_(or_8) +WRAP_(bitcoin_outpoint_hash) WRAP_(outpoint_hash) WRAP_(output_amount) WRAP_(output_amounts_hash) WRAP_(output_asset) +WRAP_(bitcoin_output_hash) WRAP_(output_hash) WRAP_(output_is_fee) WRAP_(output_nonce) @@ -349,10 +388,15 @@ WRAP_(output_nonces_hash) WRAP_(output_null_datum) WRAP_(output_range_proof) WRAP_(output_range_proofs_hash) +WRAP_(bitcoin_output_script_hash) WRAP_(output_script_hash) +WRAP_(bitcoin_output_scripts_hash) WRAP_(output_scripts_hash) WRAP_(output_surjection_proof) WRAP_(output_surjection_proofs_hash) +WRAP_(bitcoin_output_value) +WRAP_(bitcoin_output_values_hash) +WRAP_(bitcoin_outputs_hash) WRAP_(outputs_hash) WRAP_(parse_lock) WRAP_(parse_sequence) @@ -424,6 +468,7 @@ WRAP_(scalar_negate) WRAP_(scalar_normalize) WRAP_(scalar_square) WRAP_(scale) +WRAP_(bitcoin_script_cmr) WRAP_(script_cmr) WRAP_(sha_256_block) WRAP_(sha_256_ctx_8_add_1) @@ -440,6 +485,7 @@ WRAP_(sha_256_ctx_8_add_buffer_511) WRAP_(sha_256_ctx_8_finalize) WRAP_(sha_256_ctx_8_init) WRAP_(sha_256_iv) +WRAP_(bitcoin_sig_all_hash) WRAP_(sig_all_hash) WRAP_(some_1) WRAP_(some_16) @@ -451,19 +497,34 @@ WRAP_(subtract_32) WRAP_(subtract_64) WRAP_(subtract_8) WRAP_(swu) +WRAP_(bitcoin_tap_env_hash) WRAP_(tap_env_hash) WRAP_(tapdata_init) +WRAP_(bitcoin_tapleaf_hash) WRAP_(tapleaf_hash) +WRAP_(bitcoin_tapleaf_version) WRAP_(tapleaf_version) +WRAP_(bitcoin_tappath) WRAP_(tappath) +WRAP_(bitcoin_tappath_hash) WRAP_(tappath_hash) WRAP_(total_fee) +WRAP_(bitcoin_total_input_value) +WRAP_(bitcoin_total_output_value) +WRAP_(bitcoin_transaction_id) WRAP_(transaction_id) +WRAP_(bitcoin_tx_hash) WRAP_(tx_hash) +WRAP_(bitcoin_tx_is_final) WRAP_(tx_is_final) +WRAP_(bitcoin_tx_lock_distance) +WRAP_(bitcoin_tx_lock_duration) +WRAP_(bitcoin_tx_lock_height) WRAP_(tx_lock_height) +WRAP_(bitcoin_tx_lock_time) WRAP_(tx_lock_time) WRAP_(verify) +WRAP_(bitcoin_version) WRAP_(version) WRAP_(xor_1) WRAP_(xor_16) diff --git a/simplicity-sys/depend/simplicity-HEAD-revision.txt b/simplicity-sys/depend/simplicity-HEAD-revision.txt index a64fdbc4..ed553f1a 100644 --- a/simplicity-sys/depend/simplicity-HEAD-revision.txt +++ b/simplicity-sys/depend/simplicity-HEAD-revision.txt @@ -1,2 +1,2 @@ # This file has been automatically generated. -ba967b1a0d57e069c37cd4041b8bae53f12fd456 +aaeda4645fbc2be631f92d1a08c87066940d6ae0 diff --git a/simplicity-sys/depend/simplicity/CMakeLists.txt b/simplicity-sys/depend/simplicity/CMakeLists.txt new file mode 100644 index 00000000..e1d146c2 --- /dev/null +++ b/simplicity-sys/depend/simplicity/CMakeLists.txt @@ -0,0 +1,38 @@ +cmake_minimum_required(VERSION 3.16) + +project(BitcoinSimplicity) + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_EXTENSIONS OFF) + +add_library(BitcoinSimplicity STATIC + bitstream.c + cmr.c + dag.c + deserialize.c + eval.c + frame.c + jets-secp256k1.c + jets.c + rsort.c + sha256.c + type.c + typeInference.c + bitcoin/env.c + bitcoin/exec.c + bitcoin/bitcoinJets.c + bitcoin/cmr.c + bitcoin/ops.c + bitcoin/primitive.c + bitcoin/txEnv.c +) + +option(PRODUCTION "Enable production build" ON) +if (PRODUCTION) + target_compile_definitions(BitcoinSimplicity PRIVATE "PRODUCTION") +endif() + +target_include_directories(BitcoinSimplicity PUBLIC + $ + $ + ) diff --git a/simplicity-sys/depend/simplicity/Makefile b/simplicity-sys/depend/simplicity/Makefile index dcc9a4f7..e3d90ac5 100644 --- a/simplicity-sys/depend/simplicity/Makefile +++ b/simplicity-sys/depend/simplicity/Makefile @@ -1,5 +1,5 @@ -CORE_OBJS := bitstream.o dag.o deserialize.o eval.o frame.o jets.o jets-secp256k1.o rsort.o sha256.o type.o typeInference.o -BITCOIN_OBJS := bitcoin/env.o bitcoin/ops.o bitcoin/bitcoinJets.o bitcoin/primitive.o bitcoin/txEnv.o +CORE_OBJS := bitstream.o cmr.o dag.o deserialize.o eval.o frame.o jets.o jets-secp256k1.o rsort.o sha256.o type.o typeInference.o +BITCOIN_OBJS := bitcoin/env.o bitcoin/exec.o bitcoin/ops.o bitcoin/bitcoinJets.o bitcoin/primitive.o bitcoin/cmr.o bitcoin/txEnv.o ELEMENTS_OBJS := elements/env.o elements/exec.o elements/ops.o elements/elementsJets.o elements/primitive.o elements/cmr.o elements/txEnv.o TEST_OBJS := test.o ctx8Pruned.o ctx8Unpruned.o hashBlock.o regression4.o schnorr0.o schnorr6.o typeSkipTest.o elements/checkSigHashAllTx1.o diff --git a/simplicity-sys/depend/simplicity/bitcoin/cmr.c b/simplicity-sys/depend/simplicity/bitcoin/cmr.c new file mode 100644 index 00000000..e230cd93 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/cmr.c @@ -0,0 +1,22 @@ +#include + +#include "../cmr.h" +#include "primitive.h" + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +bool rustsimplicity_0_8_bitcoin_computeCmr( simplicity_err* error, unsigned char* cmr + , const unsigned char* program, size_t program_len) { + return rustsimplicity_0_8_computeCmr(error, cmr, rustsimplicity_0_8_bitcoin_decodeJet, program, program_len); +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/exec.c b/simplicity-sys/depend/simplicity/bitcoin/exec.c new file mode 100644 index 00000000..6c695bc2 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/exec.c @@ -0,0 +1,136 @@ +#include + +#include +#include +#include "primitive.h" +#include "txEnv.h" +#include "../deserialize.h" +#include "../eval.h" +#include "../limitations.h" +#include "../simplicity_alloc.h" +#include "../simplicity_assert.h" +#include "../typeInference.h" + +/* Deserialize a Simplicity 'program' with its 'witness' data and execute it in the environment of the 'ix'th input of 'tx' with `taproot`. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * meaning we were unable to determine the result of the simplicity program. + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If deserialization, analysis, or execution fails, then '*error' is set to some simplicity_err. + * In particular, if the cost analysis exceeds the budget, or exceeds BUDGET_MAX, then '*error' is set to 'SIMPLICITY_ERR_EXEC_BUDGET'. + * On the other hand, if the cost analysis is less than or equal to minCost, then '*error' is set to 'SIMPLICITY_ERR_OVERWEIGHT'. + * + * Note that minCost and budget parameters are in WU, while the cost analysis will be performed in milliWU. + * Thus the minCost and budget specify a half open interval (minCost, budget] of acceptable cost values in milliWU. + * Setting minCost to 0 effectively disables the minCost check as every Simplicity program has a non-zero cost analysis. + * + * If 'amr != NULL' and the annotated Merkle root of the decoded expression doesn't match 'amr' then '*error' is set to 'SIMPLICITY_ERR_AMR'. + * + * Otherwise '*error' is set to 'SIMPLICITY_NO_ERROR'. + * + * If 'ihr != NULL' and '*error' is set to 'SIMPLICITY_NO_ERROR', then the identity hash of the root of the decoded expression is written to 'ihr'. + * Otherwise if 'ihr != NULL' and '*error' is not set to 'SIMPLICITY_NO_ERROR', then 'ihr' may or may not be written to. + * + * Precondition: NULL != error; + * NULL != ihr implies unsigned char ihr[32] + * NULL != tx; + * NULL != taproot; + * 0 <= minCost <= budget; + * NULL != amr implies unsigned char amr[32] + * unsigned char program[program_len] + * unsigned char witness[witness_len] + */ +extern bool rustsimplicity_0_8_bitcoin_execSimplicity( simplicity_err* error, unsigned char* ihr + , const bitcoinTransaction* tx, uint_fast32_t ix, const bitcoinTapEnv* taproot + , int64_t minCost, int64_t budget + , const unsigned char* amr + , const unsigned char* program, size_t program_len + , const unsigned char* witness, size_t witness_len) { + rustsimplicity_0_8_assert(NULL != error); + rustsimplicity_0_8_assert(NULL != tx); + rustsimplicity_0_8_assert(NULL != taproot); + rustsimplicity_0_8_assert(0 <= minCost); + rustsimplicity_0_8_assert(minCost <= budget); + rustsimplicity_0_8_assert(NULL != program || 0 == program_len); + rustsimplicity_0_8_assert(NULL != witness || 0 == witness_len); + + combinator_counters census; + dag_node* dag = NULL; + int_fast32_t dag_len; + sha256_midstate amr_hash; + + if (amr) sha256_toMidstate(amr_hash.s, amr); + + { + bitstream stream = initializeBitstream(program, program_len); + dag_len = rustsimplicity_0_8_decodeMallocDag(&dag, rustsimplicity_0_8_bitcoin_decodeJet, &census, &stream); + if (dag_len <= 0) { + rustsimplicity_0_8_assert(dag_len < 0); + *error = (simplicity_err)dag_len; + return IS_PERMANENT(*error); + } + rustsimplicity_0_8_assert(NULL != dag); + rustsimplicity_0_8_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX); + *error = rustsimplicity_0_8_closeBitstream(&stream); + } + + if (IS_OK(*error)) { + if (0 != memcmp(taproot->scriptCMR.s, dag[dag_len-1].cmr.s, sizeof(uint32_t[8]))) { + *error = SIMPLICITY_ERR_CMR; + } + } + + if (IS_OK(*error)) { + type* type_dag = NULL; + *error = rustsimplicity_0_8_mallocTypeInference(&type_dag, rustsimplicity_0_8_bitcoin_mallocBoundVars, dag, (uint_fast32_t)dag_len, &census); + if (IS_OK(*error)) { + rustsimplicity_0_8_assert(NULL != type_dag); + if (0 != dag[dag_len-1].sourceType || 0 != dag[dag_len-1].targetType) { + *error = SIMPLICITY_ERR_TYPE_INFERENCE_NOT_PROGRAM; + } + } + if (IS_OK(*error)) { + bitstream witness_stream = initializeBitstream(witness, witness_len); + *error = rustsimplicity_0_8_fillWitnessData(dag, type_dag, (uint_fast32_t)dag_len, &witness_stream); + if (IS_OK(*error)) { + *error = rustsimplicity_0_8_closeBitstream(&witness_stream); + if (SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES == *error) *error = SIMPLICITY_ERR_WITNESS_TRAILING_BYTES; + if (SIMPLICITY_ERR_BITSTREAM_ILLEGAL_PADDING == *error) *error = SIMPLICITY_ERR_WITNESS_ILLEGAL_PADDING; + } + } + if (IS_OK(*error)) { + sha256_midstate ihr_buf; + *error = rustsimplicity_0_8_verifyNoDuplicateIdentityHashes(&ihr_buf, dag, type_dag, (uint_fast32_t)dag_len); + if (IS_OK(*error) && ihr) sha256_fromMidstate(ihr, ihr_buf.s); + } + if (IS_OK(*error) && amr) { + static_assert(DAG_LEN_MAX <= SIZE_MAX / sizeof(analyses), "analysis array too large."); + static_assert(1 <= DAG_LEN_MAX, "DAG_LEN_MAX is zero."); + static_assert(DAG_LEN_MAX - 1 <= UINT32_MAX, "analysis array index does not fit in uint32_t."); + analyses *analysis = rustsimplicity_0_8_malloc((size_t)dag_len * sizeof(analyses)); + if (analysis) { + rustsimplicity_0_8_computeAnnotatedMerkleRoot(analysis, dag, type_dag, (uint_fast32_t)dag_len); + if (0 != memcmp(amr_hash.s, analysis[dag_len-1].annotatedMerkleRoot.s, sizeof(uint32_t[8]))) { + *error = SIMPLICITY_ERR_AMR; + } + } else { + /* malloc failed which counts as a transient error. */ + *error = SIMPLICITY_ERR_MALLOC; + } + rustsimplicity_0_8_free(analysis); + } + if (IS_OK(*error)) { + txEnv env = rustsimplicity_0_8_bitcoin_build_txEnv(tx, taproot, ix); + static_assert(BUDGET_MAX <= UBOUNDED_MAX, "BUDGET_MAX doesn't fit in ubounded."); + *error = evalTCOProgram( dag, type_dag, (size_t)dag_len + , minCost <= BUDGET_MAX ? (ubounded)minCost : BUDGET_MAX + , &(ubounded){budget <= BUDGET_MAX ? (ubounded)budget : BUDGET_MAX} + , &env); + } + rustsimplicity_0_8_free(type_dag); + } + + rustsimplicity_0_8_free(dag); + return IS_PERMANENT(*error); +} diff --git a/simplicity-sys/depend/simplicity/cmr.c b/simplicity-sys/depend/simplicity/cmr.c new file mode 100644 index 00000000..7a1fad91 --- /dev/null +++ b/simplicity-sys/depend/simplicity/cmr.c @@ -0,0 +1,41 @@ +#include "cmr.h" + +#include "limitations.h" +#include "simplicity_alloc.h" +#include "simplicity_assert.h" + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +bool rustsimplicity_0_8_computeCmr( simplicity_err* error, unsigned char* cmr, rustsimplicity_0_8_callback_decodeJet decodeJet + , const unsigned char* program, size_t program_len) { + rustsimplicity_0_8_assert(NULL != error); + rustsimplicity_0_8_assert(NULL != cmr); + rustsimplicity_0_8_assert(NULL != program || 0 == program_len); + + bitstream stream = initializeBitstream(program, program_len); + dag_node* dag = NULL; + int_fast32_t dag_len = rustsimplicity_0_8_decodeMallocDag(&dag, decodeJet, NULL, &stream); + if (dag_len <= 0) { + rustsimplicity_0_8_assert(dag_len < 0); + *error = (simplicity_err)dag_len; + } else { + rustsimplicity_0_8_assert(NULL != dag); + rustsimplicity_0_8_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX); + *error = rustsimplicity_0_8_closeBitstream(&stream); + sha256_fromMidstate(cmr, dag[dag_len-1].cmr.s); + } + + rustsimplicity_0_8_free(dag); + return IS_PERMANENT(*error); +} diff --git a/simplicity-sys/depend/simplicity/cmr.h b/simplicity-sys/depend/simplicity/cmr.h new file mode 100644 index 00000000..13fcc309 --- /dev/null +++ b/simplicity-sys/depend/simplicity/cmr.h @@ -0,0 +1,24 @@ +#ifndef SIMPLICITY_CMR_H +#define SIMPLICITY_CMR_H + +#include +#include +#include +#include "deserialize.h" + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +extern bool rustsimplicity_0_8_computeCmr( simplicity_err* error, unsigned char* cmr, rustsimplicity_0_8_callback_decodeJet decodeJet + , const unsigned char* program, size_t program_len); +#endif diff --git a/simplicity-sys/depend/simplicity/deserialize.c b/simplicity-sys/depend/simplicity/deserialize.c index b033618c..e8a21296 100644 --- a/simplicity-sys/depend/simplicity/deserialize.c +++ b/simplicity-sys/depend/simplicity/deserialize.c @@ -191,6 +191,11 @@ int_fast32_t rustsimplicity_0_8_decodeMallocDag(dag_node** dag, rustsimplicity_0 if (dagLen <= 0) return dagLen; static_assert(DAG_LEN_MAX <= (uint32_t)INT32_MAX, "DAG_LEN_MAX exceeds supported parsing range."); if (DAG_LEN_MAX < (uint32_t)dagLen) return SIMPLICITY_ERR_DATA_OUT_OF_RANGE; + /* Every node's encoding is at least 2 bits long ('decodeNode' reads at least 2 bits before any call to 'decodeJet'), + * so a 'stream' too short to hold 'dagLen' nodes is bound to fail with 'SIMPLICITY_ERR_BITSTREAM_EOF'. + * Fail before allocating, so that the size of the allocation is proportional to the length of the 'stream'. + */ + if (stream->len < ((size_t)dagLen * 2 + stream->offset + CHAR_BIT - 1) / CHAR_BIT) return SIMPLICITY_ERR_BITSTREAM_EOF; static_assert(DAG_LEN_MAX <= SIZE_MAX / sizeof(dag_node), "dag array too large."); static_assert(1 <= DAG_LEN_MAX, "DAG_LEN_MAX is zero."); static_assert(DAG_LEN_MAX - 1 <= UINT32_MAX, "dag array index does not fit in uint32_t."); diff --git a/simplicity-sys/depend/simplicity/elements/cmr.c b/simplicity-sys/depend/simplicity/elements/cmr.c index 372b4283..7f523591 100644 --- a/simplicity-sys/depend/simplicity/elements/cmr.c +++ b/simplicity-sys/depend/simplicity/elements/cmr.c @@ -1,9 +1,6 @@ #include -#include "../deserialize.h" -#include "../limitations.h" -#include "../simplicity_alloc.h" -#include "../simplicity_assert.h" +#include "../cmr.h" #include "primitive.h" /* Deserialize a Simplicity 'program' and compute its CMR. @@ -21,23 +18,5 @@ */ bool rustsimplicity_0_8_elements_computeCmr( simplicity_err* error, unsigned char* cmr , const unsigned char* program, size_t program_len) { - rustsimplicity_0_8_assert(NULL != error); - rustsimplicity_0_8_assert(NULL != cmr); - rustsimplicity_0_8_assert(NULL != program || 0 == program_len); - - bitstream stream = initializeBitstream(program, program_len); - dag_node* dag = NULL; - int_fast32_t dag_len = rustsimplicity_0_8_decodeMallocDag(&dag, rustsimplicity_0_8_elements_decodeJet, NULL, &stream); - if (dag_len <= 0) { - rustsimplicity_0_8_assert(dag_len < 0); - *error = (simplicity_err)dag_len; - } else { - rustsimplicity_0_8_assert(NULL != dag); - rustsimplicity_0_8_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX); - *error = rustsimplicity_0_8_closeBitstream(&stream); - sha256_fromMidstate(cmr, dag[dag_len-1].cmr.s); - } - - rustsimplicity_0_8_free(dag); - return IS_PERMANENT(*error); + return rustsimplicity_0_8_computeCmr(error, cmr, rustsimplicity_0_8_elements_decodeJet, program, program_len); } diff --git a/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h new file mode 100644 index 00000000..317098fc --- /dev/null +++ b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h @@ -0,0 +1,23 @@ +#ifndef SIMPLICITY_BITCOIN_CMR_H +#define SIMPLICITY_BITCOIN_CMR_H + +#include +#include +#include + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +extern bool rustsimplicity_0_8_bitcoin_computeCmr( simplicity_err* error, unsigned char* cmr + , const unsigned char* program, size_t program_len); +#endif diff --git a/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h new file mode 100644 index 00000000..2208a48c --- /dev/null +++ b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h @@ -0,0 +1,40 @@ +#ifndef SIMPLICITY_BITCOIN_EXEC_H +#define SIMPLICITY_BITCOIN_EXEC_H + +#include +#include +#include +#include +#include + +/* Deserialize a Simplicity 'program' with its 'witness' data and execute it in the environment of the 'ix'th input of 'tx' with `taproot`. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * meaning we were unable to determine the result of the simplicity program. + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If deserialization, analysis, or execution fails, then '*error' is set to some simplicity_err. + * + * If 'amr != NULL' and the annotated Merkle root of the decoded expression doesn't match 'amr' then '*error' is set to 'SIMPLICITY_ERR_AMR'. + * + * Otherwise '*error' is set to 'SIMPLICITY_NO_ERROR'. + * + * If 'ihr != NULL' and '*error' is set to 'SIMPLICITY_NO_ERROR', then the identity hash of the root of the decoded expression is written to 'ihr'. + * Otherwise if 'ihr != NULL' and '*error' is not set to 'SIMPLICITY_NO_ERROR', then 'ihr' may or may not be written to. + * + * Precondition: NULL != error; + * NULL != ihr implies unsigned char ihr[32] + * NULL != tx; + * NULL != taproot; + * 0 <= minCost <= budget; + * NULL != amr implies unsigned char amr[32] + * unsigned char program[program_len] + * unsigned char witness[witness_len] + */ +extern bool rustsimplicity_0_8_bitcoin_execSimplicity( simplicity_err* error, unsigned char* ihr + , const bitcoinTransaction* tx, uint_fast32_t ix, const bitcoinTapEnv* taproot + , int64_t minCost, int64_t budget + , const unsigned char* amr + , const unsigned char* program, size_t program_len + , const unsigned char* witness, size_t witness_len); +#endif diff --git a/simplicity-sys/depend/simplicity/test.c b/simplicity-sys/depend/simplicity/test.c index fbb40449..3774e641 100644 --- a/simplicity-sys/depend/simplicity/test.c +++ b/simplicity-sys/depend/simplicity/test.c @@ -71,6 +71,36 @@ static void test_decodeUptoMaxInt(void) { } } +static void test_decodeMallocDag_length(void) { + printf("Test decodeMallocDag length prefix\n"); + static const struct { + const char* name; + unsigned char buf[5]; + size_t len; + int_fast32_t expected; + } cases[] = + /* A length prefix of 8,000,000 in a 5 byte stream must be rejected before allocating the dag. */ + { { "8000000 nodes in 5 bytes", { 0xf0, 0x6e, 0x84, 0x80, 0x00 }, 5, SIMPLICITY_ERR_BITSTREAM_EOF } + /* A length prefix of 4 needs at least 6 + 2*4 bits, i.e. 2 bytes. */ + , { "4 nodes in 1 byte", { 0xc0 }, 1, SIMPLICITY_ERR_BITSTREAM_EOF } + /* With 2 bytes the stream is long enough to start decoding, which then finds the first node referencing a non-existent child. */ + , { "4 nodes in 2 bytes", { 0xc0, 0x00 }, 2, SIMPLICITY_ERR_DATA_OUT_OF_RANGE } + }; + + for (size_t i = 0; i < sizeof(cases)/sizeof(cases[0]); ++i) { + dag_node* dag; + bitstream stream = initializeBitstream(cases[i].buf, cases[i].len); + int_fast32_t result = rustsimplicity_0_8_decodeMallocDag(&dag, rustsimplicity_0_8_elements_decodeJet, NULL, &stream); + if (cases[i].expected == result && NULL == dag) { + successes++; + } else { + failures++; + printf("Unexpected result for %s. Expected %d and received %d\n", cases[i].name, (int)cases[i].expected, (int)result); + } + rustsimplicity_0_8_free(dag); + } +} + static void test_hashBlock(void) { printf("Test hashBlock\n"); dag_node* dag; @@ -745,6 +775,7 @@ int main(int argc, char **argv) { timing_flag = 0; } test_decodeUptoMaxInt(); + test_decodeMallocDag_length(); test_hashBlock(); test_occursCheck(); diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs index dfb3e8a8..b1517268 100644 --- a/simplicity-sys/src/c_jets/c_env/bitcoin.rs +++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs @@ -68,7 +68,6 @@ pub struct CTapEnv { _data: (), } -/* // Will uncomment in a later commit; need to update libsimplicity first so these // symbols have something to link against. extern "C" { @@ -110,7 +109,7 @@ extern "C" { #[link_name = "rustsimplicity_0_8_bitcoin_mallocTransaction"] pub fn simplicity_mallocTransaction(rawTx: *const CRawTransaction) -> *mut CTransaction; } -*/ + impl CTxEnv { pub fn sighash_all(&self) -> sha256::Hash { let midstate: sha256::Midstate = self.sighash_all.into(); @@ -137,7 +136,6 @@ impl CRawBuffer { } } -/* // Will uncomment in a later commit; need to update libsimplicity first. #[cfg(test)] mod tests { @@ -173,4 +171,3 @@ mod tests { } } } -*/ diff --git a/simplicity-sys/src/c_jets/jets_ffi.rs b/simplicity-sys/src/c_jets/jets_ffi.rs index caf87658..8cc75aff 100644 --- a/simplicity-sys/src/c_jets/jets_ffi.rs +++ b/simplicity-sys/src/c_jets/jets_ffi.rs @@ -1,7 +1,9 @@ /* This file has been automatically generated. */ use crate::ffi::c_void; -use crate::{CElementsTxEnv, CFrameItem}; +use crate::bitcoin; +use crate::elements; +use crate::CFrameItem; extern "C" { #[link_name = "rustsimplicity_0_8_c_add_16"] @@ -30,34 +32,42 @@ extern "C" { pub fn and_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_and_8"] pub fn and_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_annex_hash"] + pub fn bitcoin_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_annex_hash"] - pub fn annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_asset_amount_hash"] - pub fn asset_amount_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn asset_amount_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_bip_0340_verify"] pub fn bip_0340_verify(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_broken_do_not_use_check_lock_distance"] - pub fn broken_do_not_use_check_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn broken_do_not_use_check_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_broken_do_not_use_check_lock_duration"] - pub fn broken_do_not_use_check_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn broken_do_not_use_check_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_broken_do_not_use_tx_lock_distance"] - pub fn broken_do_not_use_tx_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn broken_do_not_use_tx_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_broken_do_not_use_tx_lock_duration"] - pub fn broken_do_not_use_tx_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn broken_do_not_use_tx_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_build_tapbranch"] + pub fn bitcoin_build_tapbranch(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_build_tapbranch"] - pub fn build_tapbranch(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn build_tapbranch(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_build_tapleaf_simplicity"] + pub fn bitcoin_build_tapleaf_simplicity(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_build_tapleaf_simplicity"] - pub fn build_tapleaf_simplicity(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn build_tapleaf_simplicity(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_build_taptweak"] + pub fn bitcoin_build_taptweak(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_build_taptweak"] - pub fn build_taptweak(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn build_taptweak(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_calculate_asset"] - pub fn calculate_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_calculate_confidential_token"] - pub fn calculate_confidential_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_confidential_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_calculate_explicit_token"] - pub fn calculate_explicit_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_explicit_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_calculate_issuance_entropy"] - pub fn calculate_issuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_issuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_ch_1"] pub fn ch_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_ch_16"] @@ -68,10 +78,18 @@ extern "C" { pub fn ch_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_ch_8"] pub fn ch_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_check_lock_distance"] + pub fn bitcoin_check_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_check_lock_duration"] + pub fn bitcoin_check_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_check_lock_height"] + pub fn bitcoin_check_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_check_lock_height"] - pub fn check_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn check_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_check_lock_time"] + pub fn bitcoin_check_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_check_lock_time"] - pub fn check_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn check_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_check_sig_verify"] pub fn check_sig_verify(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_complement_1"] @@ -85,37 +103,51 @@ extern "C" { #[link_name = "rustsimplicity_0_8_c_complement_8"] pub fn complement_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_current_amount"] - pub fn current_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_annex_hash"] + pub fn bitcoin_current_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_annex_hash"] - pub fn current_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_asset"] - pub fn current_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_index"] + pub fn bitcoin_current_index(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_index"] - pub fn current_index(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_index(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_issuance_asset_amount"] - pub fn current_issuance_asset_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_asset_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_issuance_asset_proof"] - pub fn current_issuance_asset_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_asset_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_issuance_token_amount"] - pub fn current_issuance_token_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_token_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_issuance_token_proof"] - pub fn current_issuance_token_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_token_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_new_issuance_contract"] - pub fn current_new_issuance_contract(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_new_issuance_contract(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_pegin"] - pub fn current_pegin(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_pegin(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_prev_outpoint"] + pub fn bitcoin_current_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_prev_outpoint"] - pub fn current_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_reissuance_blinding"] - pub fn current_reissuance_blinding(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_reissuance_blinding(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_reissuance_entropy"] - pub fn current_reissuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_reissuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_script_hash"] + pub fn bitcoin_current_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_script_hash"] - pub fn current_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_script_sig_hash"] + pub fn bitcoin_current_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_script_sig_hash"] - pub fn current_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_sequence"] + pub fn bitcoin_current_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_current_sequence"] - pub fn current_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_current_value"] + pub fn bitcoin_current_value(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_decompress"] pub fn decompress(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_decrement_16"] @@ -184,6 +216,8 @@ extern "C" { pub fn fe_square(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_fe_square_root"] pub fn fe_square_root(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_fee"] + pub fn bitcoin_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_full_add_16"] pub fn full_add_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_full_add_32"] @@ -331,7 +365,7 @@ extern "C" { #[link_name = "rustsimplicity_0_8_c_generate"] pub fn generate(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_genesis_block_hash"] - pub fn genesis_block_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn genesis_block_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_hash_to_curve"] pub fn hash_to_curve(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_high_1"] @@ -353,43 +387,77 @@ extern "C" { #[link_name = "rustsimplicity_0_8_c_increment_8"] pub fn increment_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_input_amount"] - pub fn input_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_amounts_hash"] - pub fn input_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_annex_hash"] + pub fn bitcoin_input_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_annex_hash"] - pub fn input_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_annexes_hash"] + pub fn bitcoin_input_annexes_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_annexes_hash"] - pub fn input_annexes_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_annexes_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_asset"] - pub fn input_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_hash"] + pub fn bitcoin_input_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_hash"] - pub fn input_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_outpoints_hash"] + pub fn bitcoin_input_outpoints_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_outpoints_hash"] - pub fn input_outpoints_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_outpoints_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_pegin"] - pub fn input_pegin(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_pegin(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_prev_outpoint"] + pub fn bitcoin_input_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_prev_outpoint"] - pub fn input_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_script_hash"] + pub fn bitcoin_input_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_script_hash"] - pub fn input_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_script_sig_hash"] + pub fn bitcoin_input_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_script_sig_hash"] - pub fn input_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_script_sigs_hash"] + pub fn bitcoin_input_script_sigs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_script_sigs_hash"] - pub fn input_script_sigs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_script_sigs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_scripts_hash"] + pub fn bitcoin_input_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_scripts_hash"] - pub fn input_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_sequence"] + pub fn bitcoin_input_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_sequence"] - pub fn input_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_sequences_hash"] + pub fn bitcoin_input_sequences_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_sequences_hash"] - pub fn input_sequences_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_sequences_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_utxo_hash"] + pub fn bitcoin_input_utxo_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_utxo_hash"] - pub fn input_utxo_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_utxo_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_utxos_hash"] + pub fn bitcoin_input_utxos_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_input_utxos_hash"] - pub fn input_utxos_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_utxos_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_value"] + pub fn bitcoin_input_value(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_input_values_hash"] + pub fn bitcoin_input_values_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_inputs_hash"] + pub fn bitcoin_inputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_inputs_hash"] - pub fn inputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn inputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_internal_key"] + pub fn bitcoin_internal_key(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_internal_key"] - pub fn internal_key(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn internal_key(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_is_one_16"] pub fn is_one_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_is_one_32"] @@ -407,35 +475,35 @@ extern "C" { #[link_name = "rustsimplicity_0_8_c_is_zero_8"] pub fn is_zero_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance"] - pub fn issuance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_asset"] - pub fn issuance_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_asset_amount"] - pub fn issuance_asset_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_asset_amounts_hash"] - pub fn issuance_asset_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_asset_proof"] - pub fn issuance_asset_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_blinding_entropy_hash"] - pub fn issuance_blinding_entropy_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_blinding_entropy_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_entropy"] - pub fn issuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_hash"] - pub fn issuance_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_range_proofs_hash"] - pub fn issuance_range_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_range_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_token"] - pub fn issuance_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_token_amount"] - pub fn issuance_token_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_token_amounts_hash"] - pub fn issuance_token_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuance_token_proof"] - pub fn issuance_token_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_issuances_hash"] - pub fn issuances_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuances_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_lbtc_asset"] - pub fn lbtc_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn lbtc_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_le_16"] pub fn le_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_le_32"] @@ -568,8 +636,10 @@ extern "C" { pub fn linear_combination_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_linear_verify_1"] pub fn linear_verify_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_lock_time"] + pub fn bitcoin_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_lock_time"] - pub fn lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_low_1"] pub fn low_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_low_16"] @@ -647,13 +717,17 @@ extern "C" { #[link_name = "rustsimplicity_0_8_c_negate_8"] pub fn negate_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_new_issuance_contract"] - pub fn new_issuance_contract(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn new_issuance_contract(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_nonce_hash"] - pub fn nonce_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn nonce_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_num_inputs"] + pub fn bitcoin_num_inputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_num_inputs"] - pub fn num_inputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn num_inputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_num_outputs"] + pub fn bitcoin_num_outputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_num_outputs"] - pub fn num_outputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn num_outputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_one_16"] pub fn one_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_one_32"] @@ -672,38 +746,52 @@ extern "C" { pub fn or_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_or_8"] pub fn or_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_outpoint_hash"] + pub fn bitcoin_outpoint_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_outpoint_hash"] - pub fn outpoint_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn outpoint_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_amount"] - pub fn output_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_amounts_hash"] - pub fn output_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_asset"] - pub fn output_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_output_hash"] + pub fn bitcoin_output_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_hash"] - pub fn output_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_is_fee"] - pub fn output_is_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_is_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_nonce"] - pub fn output_nonce(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_nonce(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_nonces_hash"] - pub fn output_nonces_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_nonces_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_null_datum"] - pub fn output_null_datum(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_null_datum(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_range_proof"] - pub fn output_range_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_range_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_range_proofs_hash"] - pub fn output_range_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_range_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_output_script_hash"] + pub fn bitcoin_output_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_script_hash"] - pub fn output_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_output_scripts_hash"] + pub fn bitcoin_output_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_scripts_hash"] - pub fn output_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_surjection_proof"] - pub fn output_surjection_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_surjection_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_output_surjection_proofs_hash"] - pub fn output_surjection_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_surjection_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_output_value"] + pub fn bitcoin_output_value(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_output_values_hash"] + pub fn bitcoin_output_values_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_outputs_hash"] + pub fn bitcoin_outputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_outputs_hash"] - pub fn outputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn outputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_parse_lock"] pub fn parse_lock(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_parse_sequence"] @@ -711,9 +799,9 @@ extern "C" { #[link_name = "rustsimplicity_0_8_c_point_verify_1"] pub fn point_verify_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_reissuance_blinding"] - pub fn reissuance_blinding(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn reissuance_blinding(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_reissuance_entropy"] - pub fn reissuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn reissuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_right_extend_16_32"] pub fn right_extend_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_right_extend_16_64"] @@ -844,8 +932,10 @@ extern "C" { pub fn scalar_square(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_scale"] pub fn scale(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_script_cmr"] + pub fn bitcoin_script_cmr(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_script_cmr"] - pub fn script_cmr(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn script_cmr(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_sha_256_block"] pub fn sha_256_block(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_sha_256_ctx_8_add_1"] @@ -876,8 +966,10 @@ extern "C" { pub fn sha_256_ctx_8_init(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_sha_256_iv"] pub fn sha_256_iv(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_sig_all_hash"] + pub fn bitcoin_sig_all_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_sig_all_hash"] - pub fn sig_all_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn sig_all_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_some_1"] pub fn some_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_some_16"] @@ -898,34 +990,64 @@ extern "C" { pub fn subtract_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_swu"] pub fn swu(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tap_env_hash"] + pub fn bitcoin_tap_env_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tap_env_hash"] - pub fn tap_env_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tap_env_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tapdata_init"] pub fn tapdata_init(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tapleaf_hash"] + pub fn bitcoin_tapleaf_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tapleaf_hash"] - pub fn tapleaf_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tapleaf_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tapleaf_version"] + pub fn bitcoin_tapleaf_version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tapleaf_version"] - pub fn tapleaf_version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tapleaf_version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tappath"] + pub fn bitcoin_tappath(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tappath"] - pub fn tappath(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tappath(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tappath_hash"] + pub fn bitcoin_tappath_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tappath_hash"] - pub fn tappath_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tappath_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_total_fee"] - pub fn total_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn total_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_total_input_value"] + pub fn bitcoin_total_input_value(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_total_output_value"] + pub fn bitcoin_total_output_value(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_transaction_id"] + pub fn bitcoin_transaction_id(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_transaction_id"] - pub fn transaction_id(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn transaction_id(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tx_hash"] + pub fn bitcoin_tx_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tx_hash"] - pub fn tx_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tx_is_final"] + pub fn bitcoin_tx_is_final(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tx_is_final"] - pub fn tx_is_final(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_is_final(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tx_lock_distance"] + pub fn bitcoin_tx_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tx_lock_duration"] + pub fn bitcoin_tx_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tx_lock_height"] + pub fn bitcoin_tx_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tx_lock_height"] - pub fn tx_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_tx_lock_time"] + pub fn bitcoin_tx_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_tx_lock_time"] - pub fn tx_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_verify"] pub fn verify(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_8_c_bitcoin_version"] + pub fn bitcoin_version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const bitcoin::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_version"] - pub fn version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const elements::CTxEnv) -> bool; #[link_name = "rustsimplicity_0_8_c_xor_1"] pub fn xor_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_8_c_xor_16"] diff --git a/simplicity-sys/src/c_jets/jets_wrapper.rs b/simplicity-sys/src/c_jets/jets_wrapper.rs index ed8fe1b8..a2bee3fe 100644 --- a/simplicity-sys/src/c_jets/jets_wrapper.rs +++ b/simplicity-sys/src/c_jets/jets_wrapper.rs @@ -1,1889 +1,2131 @@ /* This file has been automatically generated. */ -use crate::{CElementsTxEnv, CFrameItem}; -use super::elements_ffi; +use crate::bitcoin; +use crate::elements; +use crate::CFrameItem; +use super::jets_ffi; pub fn add_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_16(dst, &src, std::ptr::null()) } } pub fn add_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_32(dst, &src, std::ptr::null()) } } pub fn add_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_64(dst, &src, std::ptr::null()) } } pub fn add_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_8(dst, &src, std::ptr::null()) } } pub fn all_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_16(dst, &src, std::ptr::null()) } } pub fn all_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_32(dst, &src, std::ptr::null()) } } pub fn all_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_64(dst, &src, std::ptr::null()) } } pub fn all_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_8(dst, &src, std::ptr::null()) } } pub fn and_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_1(dst, &src, std::ptr::null()) } } pub fn and_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_16(dst, &src, std::ptr::null()) } } pub fn and_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_32(dst, &src, std::ptr::null()) } } pub fn and_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_64(dst, &src, std::ptr::null()) } } pub fn and_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_8(dst, &src, std::ptr::null()) } } -pub fn annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::annex_hash(dst, &src, env) } +pub fn bitcoin_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_annex_hash(dst, &src, env) } } -pub fn asset_amount_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::asset_amount_hash(dst, &src, env) } +pub fn annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::annex_hash(dst, &src, env) } +} + +pub fn asset_amount_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::asset_amount_hash(dst, &src, env) } } pub fn bip_0340_verify(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::bip_0340_verify(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::bip_0340_verify(dst, &src, std::ptr::null()) } +} + +pub fn broken_do_not_use_check_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::broken_do_not_use_check_lock_distance(dst, &src, env) } +} + +pub fn broken_do_not_use_check_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::broken_do_not_use_check_lock_duration(dst, &src, env) } +} + +pub fn broken_do_not_use_tx_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::broken_do_not_use_tx_lock_distance(dst, &src, env) } } -pub fn broken_do_not_use_check_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::broken_do_not_use_check_lock_distance(dst, &src, env) } +pub fn broken_do_not_use_tx_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::broken_do_not_use_tx_lock_duration(dst, &src, env) } } -pub fn broken_do_not_use_check_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::broken_do_not_use_check_lock_duration(dst, &src, env) } +pub fn bitcoin_build_tapbranch(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_build_tapbranch(dst, &src, env) } } -pub fn broken_do_not_use_tx_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::broken_do_not_use_tx_lock_distance(dst, &src, env) } +pub fn build_tapbranch(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::build_tapbranch(dst, &src, env) } } -pub fn broken_do_not_use_tx_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::broken_do_not_use_tx_lock_duration(dst, &src, env) } +pub fn bitcoin_build_tapleaf_simplicity(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_build_tapleaf_simplicity(dst, &src, env) } } -pub fn build_tapbranch(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::build_tapbranch(dst, &src, env) } +pub fn build_tapleaf_simplicity(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::build_tapleaf_simplicity(dst, &src, env) } } -pub fn build_tapleaf_simplicity(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::build_tapleaf_simplicity(dst, &src, env) } +pub fn bitcoin_build_taptweak(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_build_taptweak(dst, &src, env) } } -pub fn build_taptweak(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::build_taptweak(dst, &src, env) } +pub fn build_taptweak(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::build_taptweak(dst, &src, env) } } -pub fn calculate_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_asset(dst, &src, env) } +pub fn calculate_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::calculate_asset(dst, &src, env) } } -pub fn calculate_confidential_token(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_confidential_token(dst, &src, env) } +pub fn calculate_confidential_token(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::calculate_confidential_token(dst, &src, env) } } -pub fn calculate_explicit_token(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_explicit_token(dst, &src, env) } +pub fn calculate_explicit_token(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::calculate_explicit_token(dst, &src, env) } } -pub fn calculate_issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_issuance_entropy(dst, &src, env) } +pub fn calculate_issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::calculate_issuance_entropy(dst, &src, env) } } pub fn ch_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_1(dst, &src, std::ptr::null()) } } pub fn ch_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_16(dst, &src, std::ptr::null()) } } pub fn ch_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_32(dst, &src, std::ptr::null()) } } pub fn ch_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_64(dst, &src, std::ptr::null()) } } pub fn ch_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_8(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_check_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_distance(dst, &src, env) } +} + +pub fn bitcoin_check_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_duration(dst, &src, env) } +} + +pub fn bitcoin_check_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_height(dst, &src, env) } +} + +pub fn check_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::check_lock_height(dst, &src, env) } } -pub fn check_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::check_lock_height(dst, &src, env) } +pub fn bitcoin_check_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_time(dst, &src, env) } } -pub fn check_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::check_lock_time(dst, &src, env) } +pub fn check_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::check_lock_time(dst, &src, env) } } pub fn check_sig_verify(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::check_sig_verify(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::check_sig_verify(dst, &src, std::ptr::null()) } } pub fn complement_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_1(dst, &src, std::ptr::null()) } } pub fn complement_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_16(dst, &src, std::ptr::null()) } } pub fn complement_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_32(dst, &src, std::ptr::null()) } } pub fn complement_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_64(dst, &src, std::ptr::null()) } } pub fn complement_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_8(dst, &src, std::ptr::null()) } +} + +pub fn current_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_amount(dst, &src, env) } +} + +pub fn bitcoin_current_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_annex_hash(dst, &src, env) } +} + +pub fn current_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_annex_hash(dst, &src, env) } +} + +pub fn current_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_asset(dst, &src, env) } +} + +pub fn bitcoin_current_index(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_index(dst, &src, env) } +} + +pub fn current_index(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_index(dst, &src, env) } +} + +pub fn current_issuance_asset_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_issuance_asset_amount(dst, &src, env) } } -pub fn current_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_amount(dst, &src, env) } +pub fn current_issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_issuance_asset_proof(dst, &src, env) } } -pub fn current_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_annex_hash(dst, &src, env) } +pub fn current_issuance_token_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_issuance_token_amount(dst, &src, env) } } -pub fn current_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_asset(dst, &src, env) } +pub fn current_issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_issuance_token_proof(dst, &src, env) } } -pub fn current_index(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_index(dst, &src, env) } +pub fn current_new_issuance_contract(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_new_issuance_contract(dst, &src, env) } } -pub fn current_issuance_asset_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_asset_amount(dst, &src, env) } +pub fn current_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_pegin(dst, &src, env) } } -pub fn current_issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_asset_proof(dst, &src, env) } +pub fn bitcoin_current_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_prev_outpoint(dst, &src, env) } } -pub fn current_issuance_token_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_token_amount(dst, &src, env) } +pub fn current_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_prev_outpoint(dst, &src, env) } } -pub fn current_issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_token_proof(dst, &src, env) } +pub fn current_reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_reissuance_blinding(dst, &src, env) } } -pub fn current_new_issuance_contract(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_new_issuance_contract(dst, &src, env) } +pub fn current_reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_reissuance_entropy(dst, &src, env) } } -pub fn current_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_pegin(dst, &src, env) } +pub fn bitcoin_current_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_script_hash(dst, &src, env) } } -pub fn current_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_prev_outpoint(dst, &src, env) } +pub fn current_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_script_hash(dst, &src, env) } } -pub fn current_reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_reissuance_blinding(dst, &src, env) } +pub fn bitcoin_current_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_script_sig_hash(dst, &src, env) } } -pub fn current_reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_reissuance_entropy(dst, &src, env) } +pub fn current_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_script_sig_hash(dst, &src, env) } } -pub fn current_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_script_hash(dst, &src, env) } +pub fn bitcoin_current_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_sequence(dst, &src, env) } } -pub fn current_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_script_sig_hash(dst, &src, env) } +pub fn current_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_sequence(dst, &src, env) } } -pub fn current_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_sequence(dst, &src, env) } +pub fn bitcoin_current_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_value(dst, &src, env) } } pub fn decompress(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decompress(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decompress(dst, &src, std::ptr::null()) } } pub fn decrement_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_16(dst, &src, std::ptr::null()) } } pub fn decrement_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_32(dst, &src, std::ptr::null()) } } pub fn decrement_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_64(dst, &src, std::ptr::null()) } } pub fn decrement_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_8(dst, &src, std::ptr::null()) } } pub fn div_mod_128_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_128_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_128_64(dst, &src, std::ptr::null()) } } pub fn div_mod_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_16(dst, &src, std::ptr::null()) } } pub fn div_mod_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_32(dst, &src, std::ptr::null()) } } pub fn div_mod_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_64(dst, &src, std::ptr::null()) } } pub fn div_mod_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_8(dst, &src, std::ptr::null()) } } pub fn divide_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_16(dst, &src, std::ptr::null()) } } pub fn divide_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_32(dst, &src, std::ptr::null()) } } pub fn divide_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_64(dst, &src, std::ptr::null()) } } pub fn divide_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_8(dst, &src, std::ptr::null()) } } pub fn divides_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_16(dst, &src, std::ptr::null()) } } pub fn divides_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_32(dst, &src, std::ptr::null()) } } pub fn divides_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_64(dst, &src, std::ptr::null()) } } pub fn divides_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_8(dst, &src, std::ptr::null()) } } pub fn eq_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_1(dst, &src, std::ptr::null()) } } pub fn eq_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_16(dst, &src, std::ptr::null()) } } pub fn eq_256(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_256(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_256(dst, &src, std::ptr::null()) } } pub fn eq_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_32(dst, &src, std::ptr::null()) } } pub fn eq_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_64(dst, &src, std::ptr::null()) } } pub fn eq_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_8(dst, &src, std::ptr::null()) } } pub fn fe_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_add(dst, &src, std::ptr::null()) } } pub fn fe_invert(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_invert(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_invert(dst, &src, std::ptr::null()) } } pub fn fe_is_odd(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_is_odd(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_is_odd(dst, &src, std::ptr::null()) } } pub fn fe_is_zero(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_is_zero(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_is_zero(dst, &src, std::ptr::null()) } } pub fn fe_multiply(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_multiply(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_multiply(dst, &src, std::ptr::null()) } } pub fn fe_multiply_beta(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_multiply_beta(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_multiply_beta(dst, &src, std::ptr::null()) } } pub fn fe_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_negate(dst, &src, std::ptr::null()) } } pub fn fe_normalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_normalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_normalize(dst, &src, std::ptr::null()) } } pub fn fe_square(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_square(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_square(dst, &src, std::ptr::null()) } } pub fn fe_square_root(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_square_root(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_square_root(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_fee(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_fee(dst, &src, env) } } pub fn full_add_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_16(dst, &src, std::ptr::null()) } } pub fn full_add_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_32(dst, &src, std::ptr::null()) } } pub fn full_add_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_64(dst, &src, std::ptr::null()) } } pub fn full_add_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_8(dst, &src, std::ptr::null()) } } pub fn full_decrement_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_16(dst, &src, std::ptr::null()) } } pub fn full_decrement_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_32(dst, &src, std::ptr::null()) } } pub fn full_decrement_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_64(dst, &src, std::ptr::null()) } } pub fn full_decrement_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_8(dst, &src, std::ptr::null()) } } pub fn full_increment_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_16(dst, &src, std::ptr::null()) } } pub fn full_increment_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_32(dst, &src, std::ptr::null()) } } pub fn full_increment_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_64(dst, &src, std::ptr::null()) } } pub fn full_increment_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_4(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_16(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_4(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_16(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_32(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_4(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_8_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_8_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_8_4(dst, &src, std::ptr::null()) } } pub fn full_multiply_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_16(dst, &src, std::ptr::null()) } } pub fn full_multiply_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_32(dst, &src, std::ptr::null()) } } pub fn full_multiply_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_64(dst, &src, std::ptr::null()) } } pub fn full_multiply_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_4(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_16(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_4(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_16(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_32(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_4(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_8_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_8_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_8_4(dst, &src, std::ptr::null()) } } pub fn full_subtract_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_16(dst, &src, std::ptr::null()) } } pub fn full_subtract_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_32(dst, &src, std::ptr::null()) } } pub fn full_subtract_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_64(dst, &src, std::ptr::null()) } } pub fn full_subtract_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_8(dst, &src, std::ptr::null()) } } pub fn ge_is_on_curve(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ge_is_on_curve(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ge_is_on_curve(dst, &src, std::ptr::null()) } } pub fn ge_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ge_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ge_negate(dst, &src, std::ptr::null()) } } pub fn gej_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_add(dst, &src, std::ptr::null()) } } pub fn gej_double(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_double(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_double(dst, &src, std::ptr::null()) } } pub fn gej_equiv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_equiv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_equiv(dst, &src, std::ptr::null()) } } pub fn gej_ge_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_ge_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_ge_add(dst, &src, std::ptr::null()) } } pub fn gej_ge_add_ex(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_ge_add_ex(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_ge_add_ex(dst, &src, std::ptr::null()) } } pub fn gej_ge_equiv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_ge_equiv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_ge_equiv(dst, &src, std::ptr::null()) } } pub fn gej_infinity(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_infinity(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_infinity(dst, &src, std::ptr::null()) } } pub fn gej_is_infinity(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_is_infinity(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_is_infinity(dst, &src, std::ptr::null()) } } pub fn gej_is_on_curve(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_is_on_curve(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_is_on_curve(dst, &src, std::ptr::null()) } } pub fn gej_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_negate(dst, &src, std::ptr::null()) } } pub fn gej_normalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_normalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_normalize(dst, &src, std::ptr::null()) } } pub fn gej_rescale(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_rescale(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_rescale(dst, &src, std::ptr::null()) } } pub fn gej_x_equiv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_x_equiv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_x_equiv(dst, &src, std::ptr::null()) } } pub fn gej_y_is_odd(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_y_is_odd(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_y_is_odd(dst, &src, std::ptr::null()) } } pub fn generate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::generate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::generate(dst, &src, std::ptr::null()) } } -pub fn genesis_block_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::genesis_block_hash(dst, &src, env) } +pub fn genesis_block_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::genesis_block_hash(dst, &src, env) } } pub fn hash_to_curve(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::hash_to_curve(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::hash_to_curve(dst, &src, std::ptr::null()) } } pub fn high_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_1(dst, &src, std::ptr::null()) } } pub fn high_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_16(dst, &src, std::ptr::null()) } } pub fn high_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_32(dst, &src, std::ptr::null()) } } pub fn high_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_64(dst, &src, std::ptr::null()) } } pub fn high_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_8(dst, &src, std::ptr::null()) } } pub fn increment_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_16(dst, &src, std::ptr::null()) } } pub fn increment_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_32(dst, &src, std::ptr::null()) } } pub fn increment_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_64(dst, &src, std::ptr::null()) } } pub fn increment_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_8(dst, &src, std::ptr::null()) } +} + +pub fn input_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_amount(dst, &src, env) } +} + +pub fn input_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_amounts_hash(dst, &src, env) } +} + +pub fn bitcoin_input_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_annex_hash(dst, &src, env) } +} + +pub fn input_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_annex_hash(dst, &src, env) } +} + +pub fn bitcoin_input_annexes_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_annexes_hash(dst, &src, env) } +} + +pub fn input_annexes_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_annexes_hash(dst, &src, env) } +} + +pub fn input_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_asset(dst, &src, env) } +} + +pub fn bitcoin_input_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_hash(dst, &src, env) } +} + +pub fn input_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_hash(dst, &src, env) } +} + +pub fn bitcoin_input_outpoints_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_outpoints_hash(dst, &src, env) } +} + +pub fn input_outpoints_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_outpoints_hash(dst, &src, env) } +} + +pub fn input_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_pegin(dst, &src, env) } +} + +pub fn bitcoin_input_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_prev_outpoint(dst, &src, env) } +} + +pub fn input_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_prev_outpoint(dst, &src, env) } } -pub fn input_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_amount(dst, &src, env) } +pub fn bitcoin_input_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_script_hash(dst, &src, env) } } -pub fn input_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_amounts_hash(dst, &src, env) } +pub fn input_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_script_hash(dst, &src, env) } } -pub fn input_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_annex_hash(dst, &src, env) } +pub fn bitcoin_input_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_script_sig_hash(dst, &src, env) } } -pub fn input_annexes_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_annexes_hash(dst, &src, env) } +pub fn input_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_script_sig_hash(dst, &src, env) } } -pub fn input_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_asset(dst, &src, env) } +pub fn bitcoin_input_script_sigs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_script_sigs_hash(dst, &src, env) } } -pub fn input_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_hash(dst, &src, env) } +pub fn input_script_sigs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_script_sigs_hash(dst, &src, env) } } -pub fn input_outpoints_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_outpoints_hash(dst, &src, env) } +pub fn bitcoin_input_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_scripts_hash(dst, &src, env) } } -pub fn input_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_pegin(dst, &src, env) } +pub fn input_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_scripts_hash(dst, &src, env) } } -pub fn input_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_prev_outpoint(dst, &src, env) } +pub fn bitcoin_input_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_sequence(dst, &src, env) } } -pub fn input_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_script_hash(dst, &src, env) } +pub fn input_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_sequence(dst, &src, env) } } -pub fn input_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_script_sig_hash(dst, &src, env) } +pub fn bitcoin_input_sequences_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_sequences_hash(dst, &src, env) } } -pub fn input_script_sigs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_script_sigs_hash(dst, &src, env) } +pub fn input_sequences_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_sequences_hash(dst, &src, env) } } -pub fn input_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_scripts_hash(dst, &src, env) } +pub fn bitcoin_input_utxo_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_utxo_hash(dst, &src, env) } } -pub fn input_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_sequence(dst, &src, env) } +pub fn input_utxo_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_utxo_hash(dst, &src, env) } } -pub fn input_sequences_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_sequences_hash(dst, &src, env) } +pub fn bitcoin_input_utxos_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_utxos_hash(dst, &src, env) } } -pub fn input_utxo_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_utxo_hash(dst, &src, env) } +pub fn input_utxos_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_utxos_hash(dst, &src, env) } } -pub fn input_utxos_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_utxos_hash(dst, &src, env) } +pub fn bitcoin_input_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_value(dst, &src, env) } } -pub fn inputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::inputs_hash(dst, &src, env) } +pub fn bitcoin_input_values_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_values_hash(dst, &src, env) } } -pub fn internal_key(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::internal_key(dst, &src, env) } +pub fn bitcoin_inputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_inputs_hash(dst, &src, env) } +} + +pub fn inputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::inputs_hash(dst, &src, env) } +} + +pub fn bitcoin_internal_key(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_internal_key(dst, &src, env) } +} + +pub fn internal_key(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::internal_key(dst, &src, env) } } pub fn is_one_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_16(dst, &src, std::ptr::null()) } } pub fn is_one_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_32(dst, &src, std::ptr::null()) } } pub fn is_one_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_64(dst, &src, std::ptr::null()) } } pub fn is_one_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_8(dst, &src, std::ptr::null()) } } pub fn is_zero_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_16(dst, &src, std::ptr::null()) } } pub fn is_zero_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_32(dst, &src, std::ptr::null()) } } pub fn is_zero_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_64(dst, &src, std::ptr::null()) } } pub fn is_zero_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_8(dst, &src, std::ptr::null()) } } -pub fn issuance(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance(dst, &src, env) } +pub fn issuance(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance(dst, &src, env) } } -pub fn issuance_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset(dst, &src, env) } +pub fn issuance_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_asset(dst, &src, env) } } -pub fn issuance_asset_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset_amount(dst, &src, env) } +pub fn issuance_asset_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_asset_amount(dst, &src, env) } } -pub fn issuance_asset_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset_amounts_hash(dst, &src, env) } +pub fn issuance_asset_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_asset_amounts_hash(dst, &src, env) } } -pub fn issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset_proof(dst, &src, env) } +pub fn issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_asset_proof(dst, &src, env) } } -pub fn issuance_blinding_entropy_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_blinding_entropy_hash(dst, &src, env) } +pub fn issuance_blinding_entropy_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_blinding_entropy_hash(dst, &src, env) } } -pub fn issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_entropy(dst, &src, env) } +pub fn issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_entropy(dst, &src, env) } } -pub fn issuance_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_hash(dst, &src, env) } +pub fn issuance_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_hash(dst, &src, env) } } -pub fn issuance_range_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_range_proofs_hash(dst, &src, env) } +pub fn issuance_range_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_range_proofs_hash(dst, &src, env) } } -pub fn issuance_token(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token(dst, &src, env) } +pub fn issuance_token(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_token(dst, &src, env) } } -pub fn issuance_token_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token_amount(dst, &src, env) } +pub fn issuance_token_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_token_amount(dst, &src, env) } } -pub fn issuance_token_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token_amounts_hash(dst, &src, env) } +pub fn issuance_token_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_token_amounts_hash(dst, &src, env) } } -pub fn issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token_proof(dst, &src, env) } +pub fn issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_token_proof(dst, &src, env) } } -pub fn issuances_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuances_hash(dst, &src, env) } +pub fn issuances_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuances_hash(dst, &src, env) } } -pub fn lbtc_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::lbtc_asset(dst, &src, env) } +pub fn lbtc_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::lbtc_asset(dst, &src, env) } } pub fn le_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_16(dst, &src, std::ptr::null()) } } pub fn le_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_32(dst, &src, std::ptr::null()) } } pub fn le_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_64(dst, &src, std::ptr::null()) } } pub fn le_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_8(dst, &src, std::ptr::null()) } } pub fn left_extend_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_16_32(dst, &src, std::ptr::null()) } } pub fn left_extend_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_16_64(dst, &src, std::ptr::null()) } } pub fn left_extend_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_16(dst, &src, std::ptr::null()) } } pub fn left_extend_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_32(dst, &src, std::ptr::null()) } } pub fn left_extend_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_64(dst, &src, std::ptr::null()) } } pub fn left_extend_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_8(dst, &src, std::ptr::null()) } } pub fn left_extend_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_32_64(dst, &src, std::ptr::null()) } } pub fn left_extend_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_8_16(dst, &src, std::ptr::null()) } } pub fn left_extend_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_8_32(dst, &src, std::ptr::null()) } } pub fn left_extend_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_8_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_16_32(dst, &src, std::ptr::null()) } } pub fn left_pad_high_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_16_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_16(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_32(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_8(dst, &src, std::ptr::null()) } } pub fn left_pad_high_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_32_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_8_16(dst, &src, std::ptr::null()) } } pub fn left_pad_high_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_8_32(dst, &src, std::ptr::null()) } } pub fn left_pad_high_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_8_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_16_32(dst, &src, std::ptr::null()) } } pub fn left_pad_low_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_16_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_16(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_32(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_8(dst, &src, std::ptr::null()) } } pub fn left_pad_low_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_32_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_8_16(dst, &src, std::ptr::null()) } } pub fn left_pad_low_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_8_32(dst, &src, std::ptr::null()) } } pub fn left_pad_low_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_8_64(dst, &src, std::ptr::null()) } } pub fn left_rotate_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_16(dst, &src, std::ptr::null()) } } pub fn left_rotate_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_32(dst, &src, std::ptr::null()) } } pub fn left_rotate_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_64(dst, &src, std::ptr::null()) } } pub fn left_rotate_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_8(dst, &src, std::ptr::null()) } } pub fn left_shift_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_16(dst, &src, std::ptr::null()) } } pub fn left_shift_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_32(dst, &src, std::ptr::null()) } } pub fn left_shift_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_64(dst, &src, std::ptr::null()) } } pub fn left_shift_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_8(dst, &src, std::ptr::null()) } } pub fn left_shift_with_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_16(dst, &src, std::ptr::null()) } } pub fn left_shift_with_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_32(dst, &src, std::ptr::null()) } } pub fn left_shift_with_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_64(dst, &src, std::ptr::null()) } } pub fn left_shift_with_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_8(dst, &src, std::ptr::null()) } } pub fn leftmost_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_1(dst, &src, std::ptr::null()) } } pub fn leftmost_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_2(dst, &src, std::ptr::null()) } } pub fn leftmost_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_4(dst, &src, std::ptr::null()) } } pub fn leftmost_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_8(dst, &src, std::ptr::null()) } } pub fn leftmost_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_1(dst, &src, std::ptr::null()) } } pub fn leftmost_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_16(dst, &src, std::ptr::null()) } } pub fn leftmost_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_2(dst, &src, std::ptr::null()) } } pub fn leftmost_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_4(dst, &src, std::ptr::null()) } } pub fn leftmost_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_8(dst, &src, std::ptr::null()) } } pub fn leftmost_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_1(dst, &src, std::ptr::null()) } } pub fn leftmost_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_16(dst, &src, std::ptr::null()) } } pub fn leftmost_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_2(dst, &src, std::ptr::null()) } } pub fn leftmost_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_32(dst, &src, std::ptr::null()) } } pub fn leftmost_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_4(dst, &src, std::ptr::null()) } } pub fn leftmost_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_8(dst, &src, std::ptr::null()) } } pub fn leftmost_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_8_1(dst, &src, std::ptr::null()) } } pub fn leftmost_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_8_2(dst, &src, std::ptr::null()) } } pub fn leftmost_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_8_4(dst, &src, std::ptr::null()) } } pub fn linear_combination_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::linear_combination_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::linear_combination_1(dst, &src, std::ptr::null()) } } pub fn linear_verify_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::linear_verify_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::linear_verify_1(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_lock_time(dst, &src, env) } } -pub fn lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::lock_time(dst, &src, env) } +pub fn lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::lock_time(dst, &src, env) } } pub fn low_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_1(dst, &src, std::ptr::null()) } } pub fn low_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_16(dst, &src, std::ptr::null()) } } pub fn low_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_32(dst, &src, std::ptr::null()) } } pub fn low_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_64(dst, &src, std::ptr::null()) } } pub fn low_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_8(dst, &src, std::ptr::null()) } } pub fn lt_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_16(dst, &src, std::ptr::null()) } } pub fn lt_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_32(dst, &src, std::ptr::null()) } } pub fn lt_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_64(dst, &src, std::ptr::null()) } } pub fn lt_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_8(dst, &src, std::ptr::null()) } } pub fn maj_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_1(dst, &src, std::ptr::null()) } } pub fn maj_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_16(dst, &src, std::ptr::null()) } } pub fn maj_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_32(dst, &src, std::ptr::null()) } } pub fn maj_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_64(dst, &src, std::ptr::null()) } } pub fn maj_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_8(dst, &src, std::ptr::null()) } } pub fn max_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_16(dst, &src, std::ptr::null()) } } pub fn max_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_32(dst, &src, std::ptr::null()) } } pub fn max_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_64(dst, &src, std::ptr::null()) } } pub fn max_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_8(dst, &src, std::ptr::null()) } } pub fn median_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_16(dst, &src, std::ptr::null()) } } pub fn median_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_32(dst, &src, std::ptr::null()) } } pub fn median_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_64(dst, &src, std::ptr::null()) } } pub fn median_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_8(dst, &src, std::ptr::null()) } } pub fn min_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_16(dst, &src, std::ptr::null()) } } pub fn min_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_32(dst, &src, std::ptr::null()) } } pub fn min_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_64(dst, &src, std::ptr::null()) } } pub fn min_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_8(dst, &src, std::ptr::null()) } } pub fn modulo_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_16(dst, &src, std::ptr::null()) } } pub fn modulo_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_32(dst, &src, std::ptr::null()) } } pub fn modulo_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_64(dst, &src, std::ptr::null()) } } pub fn modulo_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_8(dst, &src, std::ptr::null()) } } pub fn multiply_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_16(dst, &src, std::ptr::null()) } } pub fn multiply_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_32(dst, &src, std::ptr::null()) } } pub fn multiply_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_64(dst, &src, std::ptr::null()) } } pub fn multiply_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_8(dst, &src, std::ptr::null()) } } pub fn negate_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_16(dst, &src, std::ptr::null()) } } pub fn negate_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_32(dst, &src, std::ptr::null()) } } pub fn negate_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_64(dst, &src, std::ptr::null()) } } pub fn negate_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_8(dst, &src, std::ptr::null()) } } -pub fn new_issuance_contract(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::new_issuance_contract(dst, &src, env) } +pub fn new_issuance_contract(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::new_issuance_contract(dst, &src, env) } } -pub fn nonce_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::nonce_hash(dst, &src, env) } +pub fn nonce_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::nonce_hash(dst, &src, env) } } -pub fn num_inputs(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::num_inputs(dst, &src, env) } +pub fn bitcoin_num_inputs(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_num_inputs(dst, &src, env) } } -pub fn num_outputs(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::num_outputs(dst, &src, env) } +pub fn num_inputs(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::num_inputs(dst, &src, env) } +} + +pub fn bitcoin_num_outputs(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_num_outputs(dst, &src, env) } +} + +pub fn num_outputs(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::num_outputs(dst, &src, env) } } pub fn one_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_16(dst, &src, std::ptr::null()) } } pub fn one_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_32(dst, &src, std::ptr::null()) } } pub fn one_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_64(dst, &src, std::ptr::null()) } } pub fn one_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_8(dst, &src, std::ptr::null()) } } pub fn or_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_1(dst, &src, std::ptr::null()) } } pub fn or_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_16(dst, &src, std::ptr::null()) } } pub fn or_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_32(dst, &src, std::ptr::null()) } } pub fn or_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_64(dst, &src, std::ptr::null()) } } pub fn or_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_8(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_outpoint_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_outpoint_hash(dst, &src, env) } +} + +pub fn outpoint_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::outpoint_hash(dst, &src, env) } +} + +pub fn output_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_amount(dst, &src, env) } +} + +pub fn output_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_amounts_hash(dst, &src, env) } +} + +pub fn output_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_asset(dst, &src, env) } } -pub fn outpoint_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::outpoint_hash(dst, &src, env) } +pub fn bitcoin_output_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_hash(dst, &src, env) } } -pub fn output_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_amount(dst, &src, env) } +pub fn output_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_hash(dst, &src, env) } } -pub fn output_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_amounts_hash(dst, &src, env) } +pub fn output_is_fee(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_is_fee(dst, &src, env) } } -pub fn output_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_asset(dst, &src, env) } +pub fn output_nonce(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_nonce(dst, &src, env) } } -pub fn output_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_hash(dst, &src, env) } +pub fn output_nonces_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_nonces_hash(dst, &src, env) } } -pub fn output_is_fee(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_is_fee(dst, &src, env) } +pub fn output_null_datum(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_null_datum(dst, &src, env) } } -pub fn output_nonce(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_nonce(dst, &src, env) } +pub fn output_range_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_range_proof(dst, &src, env) } } -pub fn output_nonces_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_nonces_hash(dst, &src, env) } +pub fn output_range_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_range_proofs_hash(dst, &src, env) } } -pub fn output_null_datum(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_null_datum(dst, &src, env) } +pub fn bitcoin_output_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_script_hash(dst, &src, env) } } -pub fn output_range_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_range_proof(dst, &src, env) } +pub fn output_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_script_hash(dst, &src, env) } } -pub fn output_range_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_range_proofs_hash(dst, &src, env) } +pub fn bitcoin_output_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_scripts_hash(dst, &src, env) } } -pub fn output_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_script_hash(dst, &src, env) } +pub fn output_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_scripts_hash(dst, &src, env) } } -pub fn output_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_scripts_hash(dst, &src, env) } +pub fn output_surjection_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_surjection_proof(dst, &src, env) } } -pub fn output_surjection_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_surjection_proof(dst, &src, env) } +pub fn output_surjection_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_surjection_proofs_hash(dst, &src, env) } } -pub fn output_surjection_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_surjection_proofs_hash(dst, &src, env) } +pub fn bitcoin_output_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_value(dst, &src, env) } } -pub fn outputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::outputs_hash(dst, &src, env) } +pub fn bitcoin_output_values_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_values_hash(dst, &src, env) } +} + +pub fn bitcoin_outputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_outputs_hash(dst, &src, env) } +} + +pub fn outputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::outputs_hash(dst, &src, env) } } pub fn parse_lock(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::parse_lock(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::parse_lock(dst, &src, std::ptr::null()) } } pub fn parse_sequence(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::parse_sequence(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::parse_sequence(dst, &src, std::ptr::null()) } } pub fn point_verify_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::point_verify_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::point_verify_1(dst, &src, std::ptr::null()) } } -pub fn reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::reissuance_blinding(dst, &src, env) } +pub fn reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::reissuance_blinding(dst, &src, env) } } -pub fn reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::reissuance_entropy(dst, &src, env) } +pub fn reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::reissuance_entropy(dst, &src, env) } } pub fn right_extend_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_16_32(dst, &src, std::ptr::null()) } } pub fn right_extend_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_16_64(dst, &src, std::ptr::null()) } } pub fn right_extend_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_32_64(dst, &src, std::ptr::null()) } } pub fn right_extend_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_8_16(dst, &src, std::ptr::null()) } } pub fn right_extend_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_8_32(dst, &src, std::ptr::null()) } } pub fn right_extend_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_8_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_16_32(dst, &src, std::ptr::null()) } } pub fn right_pad_high_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_16_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_16(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_32(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_8(dst, &src, std::ptr::null()) } } pub fn right_pad_high_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_32_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_8_16(dst, &src, std::ptr::null()) } } pub fn right_pad_high_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_8_32(dst, &src, std::ptr::null()) } } pub fn right_pad_high_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_8_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_16_32(dst, &src, std::ptr::null()) } } pub fn right_pad_low_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_16_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_16(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_32(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_8(dst, &src, std::ptr::null()) } } pub fn right_pad_low_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_32_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_8_16(dst, &src, std::ptr::null()) } } pub fn right_pad_low_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_8_32(dst, &src, std::ptr::null()) } } pub fn right_pad_low_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_8_64(dst, &src, std::ptr::null()) } } pub fn right_rotate_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_16(dst, &src, std::ptr::null()) } } pub fn right_rotate_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_32(dst, &src, std::ptr::null()) } } pub fn right_rotate_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_64(dst, &src, std::ptr::null()) } } pub fn right_rotate_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_8(dst, &src, std::ptr::null()) } } pub fn right_shift_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_16(dst, &src, std::ptr::null()) } } pub fn right_shift_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_32(dst, &src, std::ptr::null()) } } pub fn right_shift_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_64(dst, &src, std::ptr::null()) } } pub fn right_shift_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_8(dst, &src, std::ptr::null()) } } pub fn right_shift_with_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_16(dst, &src, std::ptr::null()) } } pub fn right_shift_with_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_32(dst, &src, std::ptr::null()) } } pub fn right_shift_with_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_64(dst, &src, std::ptr::null()) } } pub fn right_shift_with_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_8(dst, &src, std::ptr::null()) } } pub fn rightmost_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_1(dst, &src, std::ptr::null()) } } pub fn rightmost_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_2(dst, &src, std::ptr::null()) } } pub fn rightmost_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_4(dst, &src, std::ptr::null()) } } pub fn rightmost_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_8(dst, &src, std::ptr::null()) } } pub fn rightmost_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_1(dst, &src, std::ptr::null()) } } pub fn rightmost_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_16(dst, &src, std::ptr::null()) } } pub fn rightmost_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_2(dst, &src, std::ptr::null()) } } pub fn rightmost_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_4(dst, &src, std::ptr::null()) } } pub fn rightmost_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_8(dst, &src, std::ptr::null()) } } pub fn rightmost_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_1(dst, &src, std::ptr::null()) } } pub fn rightmost_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_16(dst, &src, std::ptr::null()) } } pub fn rightmost_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_2(dst, &src, std::ptr::null()) } } pub fn rightmost_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_32(dst, &src, std::ptr::null()) } } pub fn rightmost_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_4(dst, &src, std::ptr::null()) } } pub fn rightmost_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_8(dst, &src, std::ptr::null()) } } pub fn rightmost_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_8_1(dst, &src, std::ptr::null()) } } pub fn rightmost_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_8_2(dst, &src, std::ptr::null()) } } pub fn rightmost_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_8_4(dst, &src, std::ptr::null()) } } pub fn scalar_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_add(dst, &src, std::ptr::null()) } } pub fn scalar_invert(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_invert(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_invert(dst, &src, std::ptr::null()) } } pub fn scalar_is_zero(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_is_zero(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_is_zero(dst, &src, std::ptr::null()) } } pub fn scalar_multiply(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_multiply(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_multiply(dst, &src, std::ptr::null()) } } pub fn scalar_multiply_lambda(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_multiply_lambda(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_multiply_lambda(dst, &src, std::ptr::null()) } } pub fn scalar_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_negate(dst, &src, std::ptr::null()) } } pub fn scalar_normalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_normalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_normalize(dst, &src, std::ptr::null()) } } pub fn scalar_square(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_square(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_square(dst, &src, std::ptr::null()) } } pub fn scale(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scale(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scale(dst, &src, std::ptr::null()) } } -pub fn script_cmr(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::script_cmr(dst, &src, env) } +pub fn bitcoin_script_cmr(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_script_cmr(dst, &src, env) } +} + +pub fn script_cmr(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::script_cmr(dst, &src, env) } } pub fn sha_256_block(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_block(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_block(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_1(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_128(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_128(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_128(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_16(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_2(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_256(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_256(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_256(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_32(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_4(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_512(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_512(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_512(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_64(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_8(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_buffer_511(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_buffer_511(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_buffer_511(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_finalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_finalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_finalize(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_init(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_init(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_init(dst, &src, std::ptr::null()) } } pub fn sha_256_iv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_iv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_iv(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_sig_all_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_sig_all_hash(dst, &src, env) } } -pub fn sig_all_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::sig_all_hash(dst, &src, env) } +pub fn sig_all_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::sig_all_hash(dst, &src, env) } } pub fn some_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_1(dst, &src, std::ptr::null()) } } pub fn some_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_16(dst, &src, std::ptr::null()) } } pub fn some_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_32(dst, &src, std::ptr::null()) } } pub fn some_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_64(dst, &src, std::ptr::null()) } } pub fn some_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_8(dst, &src, std::ptr::null()) } } pub fn subtract_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_16(dst, &src, std::ptr::null()) } } pub fn subtract_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_32(dst, &src, std::ptr::null()) } } pub fn subtract_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_64(dst, &src, std::ptr::null()) } } pub fn subtract_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_8(dst, &src, std::ptr::null()) } } pub fn swu(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::swu(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::swu(dst, &src, std::ptr::null()) } } -pub fn tap_env_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tap_env_hash(dst, &src, env) } +pub fn bitcoin_tap_env_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tap_env_hash(dst, &src, env) } +} + +pub fn tap_env_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tap_env_hash(dst, &src, env) } } pub fn tapdata_init(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::tapdata_init(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::tapdata_init(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_tapleaf_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tapleaf_hash(dst, &src, env) } +} + +pub fn tapleaf_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tapleaf_hash(dst, &src, env) } +} + +pub fn bitcoin_tapleaf_version(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tapleaf_version(dst, &src, env) } +} + +pub fn tapleaf_version(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tapleaf_version(dst, &src, env) } +} + +pub fn bitcoin_tappath(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tappath(dst, &src, env) } +} + +pub fn tappath(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tappath(dst, &src, env) } +} + +pub fn bitcoin_tappath_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tappath_hash(dst, &src, env) } +} + +pub fn tappath_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tappath_hash(dst, &src, env) } +} + +pub fn total_fee(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::total_fee(dst, &src, env) } +} + +pub fn bitcoin_total_input_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_total_input_value(dst, &src, env) } } -pub fn tapleaf_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tapleaf_hash(dst, &src, env) } +pub fn bitcoin_total_output_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_total_output_value(dst, &src, env) } } -pub fn tapleaf_version(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tapleaf_version(dst, &src, env) } +pub fn bitcoin_transaction_id(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_transaction_id(dst, &src, env) } } -pub fn tappath(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tappath(dst, &src, env) } +pub fn transaction_id(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::transaction_id(dst, &src, env) } } -pub fn tappath_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tappath_hash(dst, &src, env) } +pub fn bitcoin_tx_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_hash(dst, &src, env) } } -pub fn total_fee(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::total_fee(dst, &src, env) } +pub fn tx_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_hash(dst, &src, env) } } -pub fn transaction_id(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::transaction_id(dst, &src, env) } +pub fn bitcoin_tx_is_final(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_is_final(dst, &src, env) } } -pub fn tx_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_hash(dst, &src, env) } +pub fn tx_is_final(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_is_final(dst, &src, env) } } -pub fn tx_is_final(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_is_final(dst, &src, env) } +pub fn bitcoin_tx_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_distance(dst, &src, env) } } -pub fn tx_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_lock_height(dst, &src, env) } +pub fn bitcoin_tx_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_duration(dst, &src, env) } } -pub fn tx_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_lock_time(dst, &src, env) } +pub fn bitcoin_tx_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_height(dst, &src, env) } +} + +pub fn tx_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_lock_height(dst, &src, env) } +} + +pub fn bitcoin_tx_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_time(dst, &src, env) } +} + +pub fn tx_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_lock_time(dst, &src, env) } } pub fn verify(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::verify(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::verify(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_version(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_version(dst, &src, env) } } -pub fn version(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::version(dst, &src, env) } +pub fn version(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::version(dst, &src, env) } } pub fn xor_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_1(dst, &src, std::ptr::null()) } } pub fn xor_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_16(dst, &src, std::ptr::null()) } } pub fn xor_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_32(dst, &src, std::ptr::null()) } } pub fn xor_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_64(dst, &src, std::ptr::null()) } } pub fn xor_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_8(dst, &src, std::ptr::null()) } } pub fn xor_xor_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_1(dst, &src, std::ptr::null()) } } pub fn xor_xor_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_16(dst, &src, std::ptr::null()) } } pub fn xor_xor_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_32(dst, &src, std::ptr::null()) } } pub fn xor_xor_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_64(dst, &src, std::ptr::null()) } } pub fn xor_xor_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_8(dst, &src, std::ptr::null()) } } diff --git a/simplicity-sys/src/lib.rs b/simplicity-sys/src/lib.rs index b35f3541..b3155128 100644 --- a/simplicity-sys/src/lib.rs +++ b/simplicity-sys/src/lib.rs @@ -6,6 +6,7 @@ pub use c_jets::elements; pub use c_jets::CFrameItem; // Temporary to keep the Haskell-generated code compiling +pub use c_jets::bitcoin::CTxEnv as CBitcoinTxEnv; pub use c_jets::elements::CTxEnv as CElementsTxEnv; pub use hashes; diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs index 22c9f85a..ba0eae40 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -3,8 +3,7 @@ use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; /// Environment for Bitcoin Simplicity -// In later commit, when we update Jet trait, will remove default type. -pub struct BitcoinEnv { +pub struct BitcoinEnv { pub tx: T, } diff --git a/src/jet/bitcoin/mod.rs b/src/jet/bitcoin/mod.rs index d4faa7ae..fa51421c 100644 --- a/src/jet/bitcoin/mod.rs +++ b/src/jet/bitcoin/mod.rs @@ -7,13 +7,14 @@ pub use environment::BitcoinEnv; use super::init::bitcoin::Bitcoin; use super::JetEnvironment; use simplicity_sys::c_jets::frame_ffi::CFrameItem; +use simplicity_sys::CBitcoinTxEnv; -impl JetEnvironment for BitcoinEnv { +impl> JetEnvironment for BitcoinEnv { type Jet = Bitcoin; - type CJetEnvironment = (); + type CJetEnvironment = CBitcoinTxEnv; fn c_jet_env(&self) -> &Self::CJetEnvironment { - &() + self.c_tx_env() } fn c_jet_ptr( diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs index c93f7cfb..1c4fb162 100644 --- a/src/jet/init/bitcoin.rs +++ b/src/jet/init/bitcoin.rs @@ -8,7 +8,8 @@ use crate::{decode, BitIter, BitWriter}; use crate::analysis::Cost; use simplicity_sys::CFrameItem; use std::io::Write; -use std::{fmt, str}; +use std::{borrow::Borrow, fmt, str}; +use simplicity_sys::CBitcoinTxEnv; /// The Bitcoin jet family. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] @@ -5579,6 +5580,435 @@ impl str::FromStr for Bitcoin { } } -pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &()) -> bool { - unimplemented!("Bitcoin jets have not yet been implemented.") +pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &CBitcoinTxEnv) -> bool { + match jet { + Bitcoin::Add16 => simplicity_sys::c_jets::jets_wrapper::add_16, + Bitcoin::Add32 => simplicity_sys::c_jets::jets_wrapper::add_32, + Bitcoin::Add64 => simplicity_sys::c_jets::jets_wrapper::add_64, + Bitcoin::Add8 => simplicity_sys::c_jets::jets_wrapper::add_8, + Bitcoin::All16 => simplicity_sys::c_jets::jets_wrapper::all_16, + Bitcoin::All32 => simplicity_sys::c_jets::jets_wrapper::all_32, + Bitcoin::All64 => simplicity_sys::c_jets::jets_wrapper::all_64, + Bitcoin::All8 => simplicity_sys::c_jets::jets_wrapper::all_8, + Bitcoin::And1 => simplicity_sys::c_jets::jets_wrapper::and_1, + Bitcoin::And16 => simplicity_sys::c_jets::jets_wrapper::and_16, + Bitcoin::And32 => simplicity_sys::c_jets::jets_wrapper::and_32, + Bitcoin::And64 => simplicity_sys::c_jets::jets_wrapper::and_64, + Bitcoin::And8 => simplicity_sys::c_jets::jets_wrapper::and_8, + Bitcoin::AnnexHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_annex_hash, + Bitcoin::Bip0340Verify => simplicity_sys::c_jets::jets_wrapper::bip_0340_verify, + Bitcoin::BuildTapbranch => simplicity_sys::c_jets::jets_wrapper::bitcoin_build_tapbranch, + Bitcoin::BuildTapleafSimplicity => simplicity_sys::c_jets::jets_wrapper::bitcoin_build_tapleaf_simplicity, + Bitcoin::BuildTaptweak => simplicity_sys::c_jets::jets_wrapper::bitcoin_build_taptweak, + Bitcoin::Ch1 => simplicity_sys::c_jets::jets_wrapper::ch_1, + Bitcoin::Ch16 => simplicity_sys::c_jets::jets_wrapper::ch_16, + Bitcoin::Ch32 => simplicity_sys::c_jets::jets_wrapper::ch_32, + Bitcoin::Ch64 => simplicity_sys::c_jets::jets_wrapper::ch_64, + Bitcoin::Ch8 => simplicity_sys::c_jets::jets_wrapper::ch_8, + Bitcoin::CheckLockDistance => simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_distance, + Bitcoin::CheckLockDuration => simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_duration, + Bitcoin::CheckLockHeight => simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_height, + Bitcoin::CheckLockTime => simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_time, + Bitcoin::CheckSigVerify => simplicity_sys::c_jets::jets_wrapper::check_sig_verify, + Bitcoin::Complement1 => simplicity_sys::c_jets::jets_wrapper::complement_1, + Bitcoin::Complement16 => simplicity_sys::c_jets::jets_wrapper::complement_16, + Bitcoin::Complement32 => simplicity_sys::c_jets::jets_wrapper::complement_32, + Bitcoin::Complement64 => simplicity_sys::c_jets::jets_wrapper::complement_64, + Bitcoin::Complement8 => simplicity_sys::c_jets::jets_wrapper::complement_8, + Bitcoin::CurrentAnnexHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_annex_hash, + Bitcoin::CurrentIndex => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_index, + Bitcoin::CurrentPrevOutpoint => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_prev_outpoint, + Bitcoin::CurrentScriptHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_script_hash, + Bitcoin::CurrentScriptSigHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_script_sig_hash, + Bitcoin::CurrentSequence => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_sequence, + Bitcoin::CurrentValue => simplicity_sys::c_jets::jets_wrapper::bitcoin_current_value, + Bitcoin::Decompress => simplicity_sys::c_jets::jets_wrapper::decompress, + Bitcoin::Decrement16 => simplicity_sys::c_jets::jets_wrapper::decrement_16, + Bitcoin::Decrement32 => simplicity_sys::c_jets::jets_wrapper::decrement_32, + Bitcoin::Decrement64 => simplicity_sys::c_jets::jets_wrapper::decrement_64, + Bitcoin::Decrement8 => simplicity_sys::c_jets::jets_wrapper::decrement_8, + Bitcoin::DivMod128_64 => simplicity_sys::c_jets::jets_wrapper::div_mod_128_64, + Bitcoin::DivMod16 => simplicity_sys::c_jets::jets_wrapper::div_mod_16, + Bitcoin::DivMod32 => simplicity_sys::c_jets::jets_wrapper::div_mod_32, + Bitcoin::DivMod64 => simplicity_sys::c_jets::jets_wrapper::div_mod_64, + Bitcoin::DivMod8 => simplicity_sys::c_jets::jets_wrapper::div_mod_8, + Bitcoin::Divide16 => simplicity_sys::c_jets::jets_wrapper::divide_16, + Bitcoin::Divide32 => simplicity_sys::c_jets::jets_wrapper::divide_32, + Bitcoin::Divide64 => simplicity_sys::c_jets::jets_wrapper::divide_64, + Bitcoin::Divide8 => simplicity_sys::c_jets::jets_wrapper::divide_8, + Bitcoin::Divides16 => simplicity_sys::c_jets::jets_wrapper::divides_16, + Bitcoin::Divides32 => simplicity_sys::c_jets::jets_wrapper::divides_32, + Bitcoin::Divides64 => simplicity_sys::c_jets::jets_wrapper::divides_64, + Bitcoin::Divides8 => simplicity_sys::c_jets::jets_wrapper::divides_8, + Bitcoin::Eq1 => simplicity_sys::c_jets::jets_wrapper::eq_1, + Bitcoin::Eq16 => simplicity_sys::c_jets::jets_wrapper::eq_16, + Bitcoin::Eq256 => simplicity_sys::c_jets::jets_wrapper::eq_256, + Bitcoin::Eq32 => simplicity_sys::c_jets::jets_wrapper::eq_32, + Bitcoin::Eq64 => simplicity_sys::c_jets::jets_wrapper::eq_64, + Bitcoin::Eq8 => simplicity_sys::c_jets::jets_wrapper::eq_8, + Bitcoin::FeAdd => simplicity_sys::c_jets::jets_wrapper::fe_add, + Bitcoin::FeInvert => simplicity_sys::c_jets::jets_wrapper::fe_invert, + Bitcoin::FeIsOdd => simplicity_sys::c_jets::jets_wrapper::fe_is_odd, + Bitcoin::FeIsZero => simplicity_sys::c_jets::jets_wrapper::fe_is_zero, + Bitcoin::FeMultiply => simplicity_sys::c_jets::jets_wrapper::fe_multiply, + Bitcoin::FeMultiplyBeta => simplicity_sys::c_jets::jets_wrapper::fe_multiply_beta, + Bitcoin::FeNegate => simplicity_sys::c_jets::jets_wrapper::fe_negate, + Bitcoin::FeNormalize => simplicity_sys::c_jets::jets_wrapper::fe_normalize, + Bitcoin::FeSquare => simplicity_sys::c_jets::jets_wrapper::fe_square, + Bitcoin::FeSquareRoot => simplicity_sys::c_jets::jets_wrapper::fe_square_root, + Bitcoin::Fee => simplicity_sys::c_jets::jets_wrapper::bitcoin_fee, + Bitcoin::FullAdd16 => simplicity_sys::c_jets::jets_wrapper::full_add_16, + Bitcoin::FullAdd32 => simplicity_sys::c_jets::jets_wrapper::full_add_32, + Bitcoin::FullAdd64 => simplicity_sys::c_jets::jets_wrapper::full_add_64, + Bitcoin::FullAdd8 => simplicity_sys::c_jets::jets_wrapper::full_add_8, + Bitcoin::FullDecrement16 => simplicity_sys::c_jets::jets_wrapper::full_decrement_16, + Bitcoin::FullDecrement32 => simplicity_sys::c_jets::jets_wrapper::full_decrement_32, + Bitcoin::FullDecrement64 => simplicity_sys::c_jets::jets_wrapper::full_decrement_64, + Bitcoin::FullDecrement8 => simplicity_sys::c_jets::jets_wrapper::full_decrement_8, + Bitcoin::FullIncrement16 => simplicity_sys::c_jets::jets_wrapper::full_increment_16, + Bitcoin::FullIncrement32 => simplicity_sys::c_jets::jets_wrapper::full_increment_32, + Bitcoin::FullIncrement64 => simplicity_sys::c_jets::jets_wrapper::full_increment_64, + Bitcoin::FullIncrement8 => simplicity_sys::c_jets::jets_wrapper::full_increment_8, + Bitcoin::FullLeftShift16_1 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_1, + Bitcoin::FullLeftShift16_2 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_2, + Bitcoin::FullLeftShift16_4 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_4, + Bitcoin::FullLeftShift16_8 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_8, + Bitcoin::FullLeftShift32_1 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_1, + Bitcoin::FullLeftShift32_16 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_16, + Bitcoin::FullLeftShift32_2 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_2, + Bitcoin::FullLeftShift32_4 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_4, + Bitcoin::FullLeftShift32_8 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_8, + Bitcoin::FullLeftShift64_1 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_1, + Bitcoin::FullLeftShift64_16 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_16, + Bitcoin::FullLeftShift64_2 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_2, + Bitcoin::FullLeftShift64_32 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_32, + Bitcoin::FullLeftShift64_4 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_4, + Bitcoin::FullLeftShift64_8 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_8, + Bitcoin::FullLeftShift8_1 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_1, + Bitcoin::FullLeftShift8_2 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_2, + Bitcoin::FullLeftShift8_4 => simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_4, + Bitcoin::FullMultiply16 => simplicity_sys::c_jets::jets_wrapper::full_multiply_16, + Bitcoin::FullMultiply32 => simplicity_sys::c_jets::jets_wrapper::full_multiply_32, + Bitcoin::FullMultiply64 => simplicity_sys::c_jets::jets_wrapper::full_multiply_64, + Bitcoin::FullMultiply8 => simplicity_sys::c_jets::jets_wrapper::full_multiply_8, + Bitcoin::FullRightShift16_1 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_1, + Bitcoin::FullRightShift16_2 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_2, + Bitcoin::FullRightShift16_4 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_4, + Bitcoin::FullRightShift16_8 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_8, + Bitcoin::FullRightShift32_1 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_1, + Bitcoin::FullRightShift32_16 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_16, + Bitcoin::FullRightShift32_2 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_2, + Bitcoin::FullRightShift32_4 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_4, + Bitcoin::FullRightShift32_8 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_8, + Bitcoin::FullRightShift64_1 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_1, + Bitcoin::FullRightShift64_16 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_16, + Bitcoin::FullRightShift64_2 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_2, + Bitcoin::FullRightShift64_32 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_32, + Bitcoin::FullRightShift64_4 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_4, + Bitcoin::FullRightShift64_8 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_8, + Bitcoin::FullRightShift8_1 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_1, + Bitcoin::FullRightShift8_2 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_2, + Bitcoin::FullRightShift8_4 => simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_4, + Bitcoin::FullSubtract16 => simplicity_sys::c_jets::jets_wrapper::full_subtract_16, + Bitcoin::FullSubtract32 => simplicity_sys::c_jets::jets_wrapper::full_subtract_32, + Bitcoin::FullSubtract64 => simplicity_sys::c_jets::jets_wrapper::full_subtract_64, + Bitcoin::FullSubtract8 => simplicity_sys::c_jets::jets_wrapper::full_subtract_8, + Bitcoin::GeIsOnCurve => simplicity_sys::c_jets::jets_wrapper::ge_is_on_curve, + Bitcoin::GeNegate => simplicity_sys::c_jets::jets_wrapper::ge_negate, + Bitcoin::GejAdd => simplicity_sys::c_jets::jets_wrapper::gej_add, + Bitcoin::GejDouble => simplicity_sys::c_jets::jets_wrapper::gej_double, + Bitcoin::GejEquiv => simplicity_sys::c_jets::jets_wrapper::gej_equiv, + Bitcoin::GejGeAdd => simplicity_sys::c_jets::jets_wrapper::gej_ge_add, + Bitcoin::GejGeAddEx => simplicity_sys::c_jets::jets_wrapper::gej_ge_add_ex, + Bitcoin::GejGeEquiv => simplicity_sys::c_jets::jets_wrapper::gej_ge_equiv, + Bitcoin::GejInfinity => simplicity_sys::c_jets::jets_wrapper::gej_infinity, + Bitcoin::GejIsInfinity => simplicity_sys::c_jets::jets_wrapper::gej_is_infinity, + Bitcoin::GejIsOnCurve => simplicity_sys::c_jets::jets_wrapper::gej_is_on_curve, + Bitcoin::GejNegate => simplicity_sys::c_jets::jets_wrapper::gej_negate, + Bitcoin::GejNormalize => simplicity_sys::c_jets::jets_wrapper::gej_normalize, + Bitcoin::GejRescale => simplicity_sys::c_jets::jets_wrapper::gej_rescale, + Bitcoin::GejXEquiv => simplicity_sys::c_jets::jets_wrapper::gej_x_equiv, + Bitcoin::GejYIsOdd => simplicity_sys::c_jets::jets_wrapper::gej_y_is_odd, + Bitcoin::Generate => simplicity_sys::c_jets::jets_wrapper::generate, + Bitcoin::HashToCurve => simplicity_sys::c_jets::jets_wrapper::hash_to_curve, + Bitcoin::High1 => simplicity_sys::c_jets::jets_wrapper::high_1, + Bitcoin::High16 => simplicity_sys::c_jets::jets_wrapper::high_16, + Bitcoin::High32 => simplicity_sys::c_jets::jets_wrapper::high_32, + Bitcoin::High64 => simplicity_sys::c_jets::jets_wrapper::high_64, + Bitcoin::High8 => simplicity_sys::c_jets::jets_wrapper::high_8, + Bitcoin::Increment16 => simplicity_sys::c_jets::jets_wrapper::increment_16, + Bitcoin::Increment32 => simplicity_sys::c_jets::jets_wrapper::increment_32, + Bitcoin::Increment64 => simplicity_sys::c_jets::jets_wrapper::increment_64, + Bitcoin::Increment8 => simplicity_sys::c_jets::jets_wrapper::increment_8, + Bitcoin::InputAnnexHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_annex_hash, + Bitcoin::InputAnnexesHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_annexes_hash, + Bitcoin::InputHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_hash, + Bitcoin::InputOutpointsHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_outpoints_hash, + Bitcoin::InputPrevOutpoint => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_prev_outpoint, + Bitcoin::InputScriptHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_script_hash, + Bitcoin::InputScriptSigHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_script_sig_hash, + Bitcoin::InputScriptSigsHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_script_sigs_hash, + Bitcoin::InputScriptsHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_scripts_hash, + Bitcoin::InputSequence => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_sequence, + Bitcoin::InputSequencesHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_sequences_hash, + Bitcoin::InputUtxoHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_utxo_hash, + Bitcoin::InputUtxosHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_utxos_hash, + Bitcoin::InputValue => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_value, + Bitcoin::InputValuesHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_input_values_hash, + Bitcoin::InputsHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_inputs_hash, + Bitcoin::InternalKey => simplicity_sys::c_jets::jets_wrapper::bitcoin_internal_key, + Bitcoin::IsOne16 => simplicity_sys::c_jets::jets_wrapper::is_one_16, + Bitcoin::IsOne32 => simplicity_sys::c_jets::jets_wrapper::is_one_32, + Bitcoin::IsOne64 => simplicity_sys::c_jets::jets_wrapper::is_one_64, + Bitcoin::IsOne8 => simplicity_sys::c_jets::jets_wrapper::is_one_8, + Bitcoin::IsZero16 => simplicity_sys::c_jets::jets_wrapper::is_zero_16, + Bitcoin::IsZero32 => simplicity_sys::c_jets::jets_wrapper::is_zero_32, + Bitcoin::IsZero64 => simplicity_sys::c_jets::jets_wrapper::is_zero_64, + Bitcoin::IsZero8 => simplicity_sys::c_jets::jets_wrapper::is_zero_8, + Bitcoin::Le16 => simplicity_sys::c_jets::jets_wrapper::le_16, + Bitcoin::Le32 => simplicity_sys::c_jets::jets_wrapper::le_32, + Bitcoin::Le64 => simplicity_sys::c_jets::jets_wrapper::le_64, + Bitcoin::Le8 => simplicity_sys::c_jets::jets_wrapper::le_8, + Bitcoin::LeftExtend16_32 => simplicity_sys::c_jets::jets_wrapper::left_extend_16_32, + Bitcoin::LeftExtend16_64 => simplicity_sys::c_jets::jets_wrapper::left_extend_16_64, + Bitcoin::LeftExtend1_16 => simplicity_sys::c_jets::jets_wrapper::left_extend_1_16, + Bitcoin::LeftExtend1_32 => simplicity_sys::c_jets::jets_wrapper::left_extend_1_32, + Bitcoin::LeftExtend1_64 => simplicity_sys::c_jets::jets_wrapper::left_extend_1_64, + Bitcoin::LeftExtend1_8 => simplicity_sys::c_jets::jets_wrapper::left_extend_1_8, + Bitcoin::LeftExtend32_64 => simplicity_sys::c_jets::jets_wrapper::left_extend_32_64, + Bitcoin::LeftExtend8_16 => simplicity_sys::c_jets::jets_wrapper::left_extend_8_16, + Bitcoin::LeftExtend8_32 => simplicity_sys::c_jets::jets_wrapper::left_extend_8_32, + Bitcoin::LeftExtend8_64 => simplicity_sys::c_jets::jets_wrapper::left_extend_8_64, + Bitcoin::LeftPadHigh16_32 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_32, + Bitcoin::LeftPadHigh16_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_64, + Bitcoin::LeftPadHigh1_16 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_16, + Bitcoin::LeftPadHigh1_32 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_32, + Bitcoin::LeftPadHigh1_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_64, + Bitcoin::LeftPadHigh1_8 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_8, + Bitcoin::LeftPadHigh32_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_32_64, + Bitcoin::LeftPadHigh8_16 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_16, + Bitcoin::LeftPadHigh8_32 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_32, + Bitcoin::LeftPadHigh8_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_64, + Bitcoin::LeftPadLow16_32 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_16_32, + Bitcoin::LeftPadLow16_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_16_64, + Bitcoin::LeftPadLow1_16 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_16, + Bitcoin::LeftPadLow1_32 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_32, + Bitcoin::LeftPadLow1_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_64, + Bitcoin::LeftPadLow1_8 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_8, + Bitcoin::LeftPadLow32_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_32_64, + Bitcoin::LeftPadLow8_16 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_8_16, + Bitcoin::LeftPadLow8_32 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_8_32, + Bitcoin::LeftPadLow8_64 => simplicity_sys::c_jets::jets_wrapper::left_pad_low_8_64, + Bitcoin::LeftRotate16 => simplicity_sys::c_jets::jets_wrapper::left_rotate_16, + Bitcoin::LeftRotate32 => simplicity_sys::c_jets::jets_wrapper::left_rotate_32, + Bitcoin::LeftRotate64 => simplicity_sys::c_jets::jets_wrapper::left_rotate_64, + Bitcoin::LeftRotate8 => simplicity_sys::c_jets::jets_wrapper::left_rotate_8, + Bitcoin::LeftShift16 => simplicity_sys::c_jets::jets_wrapper::left_shift_16, + Bitcoin::LeftShift32 => simplicity_sys::c_jets::jets_wrapper::left_shift_32, + Bitcoin::LeftShift64 => simplicity_sys::c_jets::jets_wrapper::left_shift_64, + Bitcoin::LeftShift8 => simplicity_sys::c_jets::jets_wrapper::left_shift_8, + Bitcoin::LeftShiftWith16 => simplicity_sys::c_jets::jets_wrapper::left_shift_with_16, + Bitcoin::LeftShiftWith32 => simplicity_sys::c_jets::jets_wrapper::left_shift_with_32, + Bitcoin::LeftShiftWith64 => simplicity_sys::c_jets::jets_wrapper::left_shift_with_64, + Bitcoin::LeftShiftWith8 => simplicity_sys::c_jets::jets_wrapper::left_shift_with_8, + Bitcoin::Leftmost16_1 => simplicity_sys::c_jets::jets_wrapper::leftmost_16_1, + Bitcoin::Leftmost16_2 => simplicity_sys::c_jets::jets_wrapper::leftmost_16_2, + Bitcoin::Leftmost16_4 => simplicity_sys::c_jets::jets_wrapper::leftmost_16_4, + Bitcoin::Leftmost16_8 => simplicity_sys::c_jets::jets_wrapper::leftmost_16_8, + Bitcoin::Leftmost32_1 => simplicity_sys::c_jets::jets_wrapper::leftmost_32_1, + Bitcoin::Leftmost32_16 => simplicity_sys::c_jets::jets_wrapper::leftmost_32_16, + Bitcoin::Leftmost32_2 => simplicity_sys::c_jets::jets_wrapper::leftmost_32_2, + Bitcoin::Leftmost32_4 => simplicity_sys::c_jets::jets_wrapper::leftmost_32_4, + Bitcoin::Leftmost32_8 => simplicity_sys::c_jets::jets_wrapper::leftmost_32_8, + Bitcoin::Leftmost64_1 => simplicity_sys::c_jets::jets_wrapper::leftmost_64_1, + Bitcoin::Leftmost64_16 => simplicity_sys::c_jets::jets_wrapper::leftmost_64_16, + Bitcoin::Leftmost64_2 => simplicity_sys::c_jets::jets_wrapper::leftmost_64_2, + Bitcoin::Leftmost64_32 => simplicity_sys::c_jets::jets_wrapper::leftmost_64_32, + Bitcoin::Leftmost64_4 => simplicity_sys::c_jets::jets_wrapper::leftmost_64_4, + Bitcoin::Leftmost64_8 => simplicity_sys::c_jets::jets_wrapper::leftmost_64_8, + Bitcoin::Leftmost8_1 => simplicity_sys::c_jets::jets_wrapper::leftmost_8_1, + Bitcoin::Leftmost8_2 => simplicity_sys::c_jets::jets_wrapper::leftmost_8_2, + Bitcoin::Leftmost8_4 => simplicity_sys::c_jets::jets_wrapper::leftmost_8_4, + Bitcoin::LinearCombination1 => simplicity_sys::c_jets::jets_wrapper::linear_combination_1, + Bitcoin::LinearVerify1 => simplicity_sys::c_jets::jets_wrapper::linear_verify_1, + Bitcoin::LockTime => simplicity_sys::c_jets::jets_wrapper::bitcoin_lock_time, + Bitcoin::Low1 => simplicity_sys::c_jets::jets_wrapper::low_1, + Bitcoin::Low16 => simplicity_sys::c_jets::jets_wrapper::low_16, + Bitcoin::Low32 => simplicity_sys::c_jets::jets_wrapper::low_32, + Bitcoin::Low64 => simplicity_sys::c_jets::jets_wrapper::low_64, + Bitcoin::Low8 => simplicity_sys::c_jets::jets_wrapper::low_8, + Bitcoin::Lt16 => simplicity_sys::c_jets::jets_wrapper::lt_16, + Bitcoin::Lt32 => simplicity_sys::c_jets::jets_wrapper::lt_32, + Bitcoin::Lt64 => simplicity_sys::c_jets::jets_wrapper::lt_64, + Bitcoin::Lt8 => simplicity_sys::c_jets::jets_wrapper::lt_8, + Bitcoin::Maj1 => simplicity_sys::c_jets::jets_wrapper::maj_1, + Bitcoin::Maj16 => simplicity_sys::c_jets::jets_wrapper::maj_16, + Bitcoin::Maj32 => simplicity_sys::c_jets::jets_wrapper::maj_32, + Bitcoin::Maj64 => simplicity_sys::c_jets::jets_wrapper::maj_64, + Bitcoin::Maj8 => simplicity_sys::c_jets::jets_wrapper::maj_8, + Bitcoin::Max16 => simplicity_sys::c_jets::jets_wrapper::max_16, + Bitcoin::Max32 => simplicity_sys::c_jets::jets_wrapper::max_32, + Bitcoin::Max64 => simplicity_sys::c_jets::jets_wrapper::max_64, + Bitcoin::Max8 => simplicity_sys::c_jets::jets_wrapper::max_8, + Bitcoin::Median16 => simplicity_sys::c_jets::jets_wrapper::median_16, + Bitcoin::Median32 => simplicity_sys::c_jets::jets_wrapper::median_32, + Bitcoin::Median64 => simplicity_sys::c_jets::jets_wrapper::median_64, + Bitcoin::Median8 => simplicity_sys::c_jets::jets_wrapper::median_8, + Bitcoin::Min16 => simplicity_sys::c_jets::jets_wrapper::min_16, + Bitcoin::Min32 => simplicity_sys::c_jets::jets_wrapper::min_32, + Bitcoin::Min64 => simplicity_sys::c_jets::jets_wrapper::min_64, + Bitcoin::Min8 => simplicity_sys::c_jets::jets_wrapper::min_8, + Bitcoin::Modulo16 => simplicity_sys::c_jets::jets_wrapper::modulo_16, + Bitcoin::Modulo32 => simplicity_sys::c_jets::jets_wrapper::modulo_32, + Bitcoin::Modulo64 => simplicity_sys::c_jets::jets_wrapper::modulo_64, + Bitcoin::Modulo8 => simplicity_sys::c_jets::jets_wrapper::modulo_8, + Bitcoin::Multiply16 => simplicity_sys::c_jets::jets_wrapper::multiply_16, + Bitcoin::Multiply32 => simplicity_sys::c_jets::jets_wrapper::multiply_32, + Bitcoin::Multiply64 => simplicity_sys::c_jets::jets_wrapper::multiply_64, + Bitcoin::Multiply8 => simplicity_sys::c_jets::jets_wrapper::multiply_8, + Bitcoin::Negate16 => simplicity_sys::c_jets::jets_wrapper::negate_16, + Bitcoin::Negate32 => simplicity_sys::c_jets::jets_wrapper::negate_32, + Bitcoin::Negate64 => simplicity_sys::c_jets::jets_wrapper::negate_64, + Bitcoin::Negate8 => simplicity_sys::c_jets::jets_wrapper::negate_8, + Bitcoin::NumInputs => simplicity_sys::c_jets::jets_wrapper::bitcoin_num_inputs, + Bitcoin::NumOutputs => simplicity_sys::c_jets::jets_wrapper::bitcoin_num_outputs, + Bitcoin::One16 => simplicity_sys::c_jets::jets_wrapper::one_16, + Bitcoin::One32 => simplicity_sys::c_jets::jets_wrapper::one_32, + Bitcoin::One64 => simplicity_sys::c_jets::jets_wrapper::one_64, + Bitcoin::One8 => simplicity_sys::c_jets::jets_wrapper::one_8, + Bitcoin::Or1 => simplicity_sys::c_jets::jets_wrapper::or_1, + Bitcoin::Or16 => simplicity_sys::c_jets::jets_wrapper::or_16, + Bitcoin::Or32 => simplicity_sys::c_jets::jets_wrapper::or_32, + Bitcoin::Or64 => simplicity_sys::c_jets::jets_wrapper::or_64, + Bitcoin::Or8 => simplicity_sys::c_jets::jets_wrapper::or_8, + Bitcoin::OutpointHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_outpoint_hash, + Bitcoin::OutputHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_output_hash, + Bitcoin::OutputScriptHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_output_script_hash, + Bitcoin::OutputScriptsHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_output_scripts_hash, + Bitcoin::OutputValue => simplicity_sys::c_jets::jets_wrapper::bitcoin_output_value, + Bitcoin::OutputValuesHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_output_values_hash, + Bitcoin::OutputsHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_outputs_hash, + Bitcoin::ParseLock => simplicity_sys::c_jets::jets_wrapper::parse_lock, + Bitcoin::ParseSequence => simplicity_sys::c_jets::jets_wrapper::parse_sequence, + Bitcoin::PointVerify1 => simplicity_sys::c_jets::jets_wrapper::point_verify_1, + Bitcoin::RightExtend16_32 => simplicity_sys::c_jets::jets_wrapper::right_extend_16_32, + Bitcoin::RightExtend16_64 => simplicity_sys::c_jets::jets_wrapper::right_extend_16_64, + Bitcoin::RightExtend32_64 => simplicity_sys::c_jets::jets_wrapper::right_extend_32_64, + Bitcoin::RightExtend8_16 => simplicity_sys::c_jets::jets_wrapper::right_extend_8_16, + Bitcoin::RightExtend8_32 => simplicity_sys::c_jets::jets_wrapper::right_extend_8_32, + Bitcoin::RightExtend8_64 => simplicity_sys::c_jets::jets_wrapper::right_extend_8_64, + Bitcoin::RightPadHigh16_32 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_32, + Bitcoin::RightPadHigh16_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_64, + Bitcoin::RightPadHigh1_16 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_16, + Bitcoin::RightPadHigh1_32 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_32, + Bitcoin::RightPadHigh1_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_64, + Bitcoin::RightPadHigh1_8 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_8, + Bitcoin::RightPadHigh32_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_32_64, + Bitcoin::RightPadHigh8_16 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_16, + Bitcoin::RightPadHigh8_32 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_32, + Bitcoin::RightPadHigh8_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_64, + Bitcoin::RightPadLow16_32 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_32, + Bitcoin::RightPadLow16_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_64, + Bitcoin::RightPadLow1_16 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_16, + Bitcoin::RightPadLow1_32 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_32, + Bitcoin::RightPadLow1_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_64, + Bitcoin::RightPadLow1_8 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_8, + Bitcoin::RightPadLow32_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_32_64, + Bitcoin::RightPadLow8_16 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_16, + Bitcoin::RightPadLow8_32 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_32, + Bitcoin::RightPadLow8_64 => simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_64, + Bitcoin::RightRotate16 => simplicity_sys::c_jets::jets_wrapper::right_rotate_16, + Bitcoin::RightRotate32 => simplicity_sys::c_jets::jets_wrapper::right_rotate_32, + Bitcoin::RightRotate64 => simplicity_sys::c_jets::jets_wrapper::right_rotate_64, + Bitcoin::RightRotate8 => simplicity_sys::c_jets::jets_wrapper::right_rotate_8, + Bitcoin::RightShift16 => simplicity_sys::c_jets::jets_wrapper::right_shift_16, + Bitcoin::RightShift32 => simplicity_sys::c_jets::jets_wrapper::right_shift_32, + Bitcoin::RightShift64 => simplicity_sys::c_jets::jets_wrapper::right_shift_64, + Bitcoin::RightShift8 => simplicity_sys::c_jets::jets_wrapper::right_shift_8, + Bitcoin::RightShiftWith16 => simplicity_sys::c_jets::jets_wrapper::right_shift_with_16, + Bitcoin::RightShiftWith32 => simplicity_sys::c_jets::jets_wrapper::right_shift_with_32, + Bitcoin::RightShiftWith64 => simplicity_sys::c_jets::jets_wrapper::right_shift_with_64, + Bitcoin::RightShiftWith8 => simplicity_sys::c_jets::jets_wrapper::right_shift_with_8, + Bitcoin::Rightmost16_1 => simplicity_sys::c_jets::jets_wrapper::rightmost_16_1, + Bitcoin::Rightmost16_2 => simplicity_sys::c_jets::jets_wrapper::rightmost_16_2, + Bitcoin::Rightmost16_4 => simplicity_sys::c_jets::jets_wrapper::rightmost_16_4, + Bitcoin::Rightmost16_8 => simplicity_sys::c_jets::jets_wrapper::rightmost_16_8, + Bitcoin::Rightmost32_1 => simplicity_sys::c_jets::jets_wrapper::rightmost_32_1, + Bitcoin::Rightmost32_16 => simplicity_sys::c_jets::jets_wrapper::rightmost_32_16, + Bitcoin::Rightmost32_2 => simplicity_sys::c_jets::jets_wrapper::rightmost_32_2, + Bitcoin::Rightmost32_4 => simplicity_sys::c_jets::jets_wrapper::rightmost_32_4, + Bitcoin::Rightmost32_8 => simplicity_sys::c_jets::jets_wrapper::rightmost_32_8, + Bitcoin::Rightmost64_1 => simplicity_sys::c_jets::jets_wrapper::rightmost_64_1, + Bitcoin::Rightmost64_16 => simplicity_sys::c_jets::jets_wrapper::rightmost_64_16, + Bitcoin::Rightmost64_2 => simplicity_sys::c_jets::jets_wrapper::rightmost_64_2, + Bitcoin::Rightmost64_32 => simplicity_sys::c_jets::jets_wrapper::rightmost_64_32, + Bitcoin::Rightmost64_4 => simplicity_sys::c_jets::jets_wrapper::rightmost_64_4, + Bitcoin::Rightmost64_8 => simplicity_sys::c_jets::jets_wrapper::rightmost_64_8, + Bitcoin::Rightmost8_1 => simplicity_sys::c_jets::jets_wrapper::rightmost_8_1, + Bitcoin::Rightmost8_2 => simplicity_sys::c_jets::jets_wrapper::rightmost_8_2, + Bitcoin::Rightmost8_4 => simplicity_sys::c_jets::jets_wrapper::rightmost_8_4, + Bitcoin::ScalarAdd => simplicity_sys::c_jets::jets_wrapper::scalar_add, + Bitcoin::ScalarInvert => simplicity_sys::c_jets::jets_wrapper::scalar_invert, + Bitcoin::ScalarIsZero => simplicity_sys::c_jets::jets_wrapper::scalar_is_zero, + Bitcoin::ScalarMultiply => simplicity_sys::c_jets::jets_wrapper::scalar_multiply, + Bitcoin::ScalarMultiplyLambda => simplicity_sys::c_jets::jets_wrapper::scalar_multiply_lambda, + Bitcoin::ScalarNegate => simplicity_sys::c_jets::jets_wrapper::scalar_negate, + Bitcoin::ScalarNormalize => simplicity_sys::c_jets::jets_wrapper::scalar_normalize, + Bitcoin::ScalarSquare => simplicity_sys::c_jets::jets_wrapper::scalar_square, + Bitcoin::Scale => simplicity_sys::c_jets::jets_wrapper::scale, + Bitcoin::ScriptCMR => simplicity_sys::c_jets::jets_wrapper::bitcoin_script_cmr, + Bitcoin::Sha256Block => simplicity_sys::c_jets::jets_wrapper::sha_256_block, + Bitcoin::Sha256Ctx8Add1 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_1, + Bitcoin::Sha256Ctx8Add128 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_128, + Bitcoin::Sha256Ctx8Add16 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_16, + Bitcoin::Sha256Ctx8Add2 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_2, + Bitcoin::Sha256Ctx8Add256 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_256, + Bitcoin::Sha256Ctx8Add32 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_32, + Bitcoin::Sha256Ctx8Add4 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_4, + Bitcoin::Sha256Ctx8Add512 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_512, + Bitcoin::Sha256Ctx8Add64 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_64, + Bitcoin::Sha256Ctx8Add8 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_8, + Bitcoin::Sha256Ctx8AddBuffer511 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_buffer_511, + Bitcoin::Sha256Ctx8Finalize => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_finalize, + Bitcoin::Sha256Ctx8Init => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_init, + Bitcoin::Sha256Iv => simplicity_sys::c_jets::jets_wrapper::sha_256_iv, + Bitcoin::SigAllHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_sig_all_hash, + Bitcoin::Some1 => simplicity_sys::c_jets::jets_wrapper::some_1, + Bitcoin::Some16 => simplicity_sys::c_jets::jets_wrapper::some_16, + Bitcoin::Some32 => simplicity_sys::c_jets::jets_wrapper::some_32, + Bitcoin::Some64 => simplicity_sys::c_jets::jets_wrapper::some_64, + Bitcoin::Some8 => simplicity_sys::c_jets::jets_wrapper::some_8, + Bitcoin::Subtract16 => simplicity_sys::c_jets::jets_wrapper::subtract_16, + Bitcoin::Subtract32 => simplicity_sys::c_jets::jets_wrapper::subtract_32, + Bitcoin::Subtract64 => simplicity_sys::c_jets::jets_wrapper::subtract_64, + Bitcoin::Subtract8 => simplicity_sys::c_jets::jets_wrapper::subtract_8, + Bitcoin::Swu => simplicity_sys::c_jets::jets_wrapper::swu, + Bitcoin::TapEnvHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_tap_env_hash, + Bitcoin::TapdataInit => simplicity_sys::c_jets::jets_wrapper::tapdata_init, + Bitcoin::TapleafHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_tapleaf_hash, + Bitcoin::TapleafVersion => simplicity_sys::c_jets::jets_wrapper::bitcoin_tapleaf_version, + Bitcoin::Tappath => simplicity_sys::c_jets::jets_wrapper::bitcoin_tappath, + Bitcoin::TappathHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_tappath_hash, + Bitcoin::TotalInputValue => simplicity_sys::c_jets::jets_wrapper::bitcoin_total_input_value, + Bitcoin::TotalOutputValue => simplicity_sys::c_jets::jets_wrapper::bitcoin_total_output_value, + Bitcoin::TransactionId => simplicity_sys::c_jets::jets_wrapper::bitcoin_transaction_id, + Bitcoin::TxHash => simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_hash, + Bitcoin::TxIsFinal => simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_is_final, + Bitcoin::TxLockDistance => simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_distance, + Bitcoin::TxLockDuration => simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_duration, + Bitcoin::TxLockHeight => simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_height, + Bitcoin::TxLockTime => simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_time, + Bitcoin::Verify => simplicity_sys::c_jets::jets_wrapper::verify, + Bitcoin::Version => simplicity_sys::c_jets::jets_wrapper::bitcoin_version, + Bitcoin::Xor1 => simplicity_sys::c_jets::jets_wrapper::xor_1, + Bitcoin::Xor16 => simplicity_sys::c_jets::jets_wrapper::xor_16, + Bitcoin::Xor32 => simplicity_sys::c_jets::jets_wrapper::xor_32, + Bitcoin::Xor64 => simplicity_sys::c_jets::jets_wrapper::xor_64, + Bitcoin::Xor8 => simplicity_sys::c_jets::jets_wrapper::xor_8, + Bitcoin::XorXor1 => simplicity_sys::c_jets::jets_wrapper::xor_xor_1, + Bitcoin::XorXor16 => simplicity_sys::c_jets::jets_wrapper::xor_xor_16, + Bitcoin::XorXor32 => simplicity_sys::c_jets::jets_wrapper::xor_xor_32, + Bitcoin::XorXor64 => simplicity_sys::c_jets::jets_wrapper::xor_xor_64, + Bitcoin::XorXor8 => simplicity_sys::c_jets::jets_wrapper::xor_xor_8, + } } diff --git a/src/jet/init/core.rs b/src/jet/init/core.rs index 06641d54..274c247f 100644 --- a/src/jet/init/core.rs +++ b/src/jet/init/core.rs @@ -8,7 +8,7 @@ use crate::{decode, BitIter, BitWriter}; use crate::analysis::Cost; use simplicity_sys::CFrameItem; use std::io::Write; -use std::{fmt, str}; +use std::{borrow::Borrow, fmt, str}; /// The Core jet family. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] diff --git a/src/jet/init/elements.rs b/src/jet/init/elements.rs index 0b578cff..03e37609 100644 --- a/src/jet/init/elements.rs +++ b/src/jet/init/elements.rs @@ -8,7 +8,7 @@ use crate::{decode, BitIter, BitWriter}; use crate::analysis::Cost; use simplicity_sys::CFrameItem; use std::io::Write; -use std::{fmt, str}; +use std::{borrow::Borrow, fmt, str}; use simplicity_sys::CElementsTxEnv; /// The Elements jet family. From 2f51b6c3d99d2cd227f271cb7120cc419d430727 Mon Sep 17 00:00:00 2001 From: Byron Hambly Date: Mon, 7 Sep 2026 14:40:12 +0200 Subject: [PATCH 06/10] jet: generalize JetEnvironment impls to use Borrow Change the JetEnvironment impl for BitcoinEnv and ElementsEnv to be generic over T: Borrow instead of fixed to Arc. Update Policy::satisfy, get_satisfier, execute_successful, execute_unsuccessful, and serialize test helpers to accept ElementsEnv>. This allows callers to construct environments without Arc overhead (for example, using a plain reference or owned value), and is required so that BitcoinEnv::c_jet_env can return a real CTxEnv from a borrowed transaction. --- src/jet/elements/mod.rs | 2 +- src/policy/satisfy.rs | 16 +++++++++------- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/jet/elements/mod.rs b/src/jet/elements/mod.rs index c36ed73a..35a4ae33 100644 --- a/src/jet/elements/mod.rs +++ b/src/jet/elements/mod.rs @@ -15,7 +15,7 @@ use simplicity_sys::CElementsTxEnv; /// Type alias for the Elements transaction environment. pub type ElementsTxEnv = ElementsEnv>; -impl JetEnvironment for ElementsTxEnv { +impl> JetEnvironment for ElementsEnv { type Jet = Elements; type CJetEnvironment = CElementsTxEnv; diff --git a/src/policy/satisfy.rs b/src/policy/satisfy.rs index 534c5b5a..52c0713e 100644 --- a/src/policy/satisfy.rs +++ b/src/policy/satisfy.rs @@ -268,7 +268,7 @@ impl Policy { pub fn satisfy<'brand, S: Satisfier<'brand, Pk>>( &self, satisfier: &S, - env: &ElementsEnv>, + env: &ElementsEnv>, ) -> Result, SatisfierError> { let result = self.satisfy_internal(satisfier)?; match result.into_node() { @@ -332,10 +332,9 @@ mod tests { } } - fn get_satisfier<'tx, 'brand>( + fn get_satisfier<'tx, 'brand, T: core::borrow::Borrow>( context: types::Context<'brand>, - - env: &'tx ElementsEnv>, + env: &'tx ElementsEnv, ) -> PolicySatisfier<'tx, 'brand, XOnlyPublicKey> { let mut preimages = HashMap::new(); @@ -372,14 +371,17 @@ mod tests { } } - fn execute_successful(program: Arc, env: &ElementsEnv>) { + fn execute_successful>( + program: Arc, + env: &ElementsEnv, + ) { let mut mac = BitMachine::for_program(&program).unwrap(); assert!(mac.exec(&program, env).is_ok()); } - fn execute_unsuccessful( + fn execute_unsuccessful>( program: Arc, - env: &ElementsEnv>, + env: &ElementsEnv, ) { let mut mac = BitMachine::for_program(&program).unwrap(); assert!(mac.exec(&program, env).is_err()); From 00600222c5029cea7c9c7195271ab56d4419e6df Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 11 Sep 2025 16:38:08 +0000 Subject: [PATCH 07/10] jet: drop unnecessary Arcs in environments Now that we've updated the Jet trait to allow the transactions in environments to be arbitrary T: Borrow, we don't need to use Arc everywhere. In many cases we can use normal references. --- src/human_encoding/parse/mod.rs | 5 ++--- src/jet/elements/environment.rs | 6 +++--- src/node/redeem.rs | 10 +++++----- src/policy/serialize.rs | 4 ++-- 4 files changed, 12 insertions(+), 13 deletions(-) diff --git a/src/human_encoding/parse/mod.rs b/src/human_encoding/parse/mod.rs index 64045a77..d42d7647 100644 --- a/src/human_encoding/parse/mod.rs +++ b/src/human_encoding/parse/mod.rs @@ -713,11 +713,10 @@ mod tests { #[cfg(feature = "elements")] fn bip340_program() { use crate::jet::elements::ElementsEnv; - use crate::jet::ElementsTxEnv; let empty = HashMap::new(); let dummy = ElementsEnv::dummy(); - assert_cmr_witness::( + assert_cmr_witness::>( "main := unit", "c40a10263f7436b4160acbef1c36fba4be4d95df181a968afeab5eac247adff7", &empty, @@ -734,7 +733,7 @@ mod tests { ]; let signature = HashMap::from([(Arc::from("wit1"), Value::u512(sig))]); - assert_cmr_witness::( + assert_cmr_witness::>( " -- Witnesses wit1 := witness : 1 -> 2^512 diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs index 812bf388..e022753c 100644 --- a/src/jet/elements/environment.rs +++ b/src/jet/elements/environment.rs @@ -110,7 +110,7 @@ where } #[cfg(test)] -impl ElementsEnv> { +impl ElementsEnv { /// Return a dummy Elements environment pub fn dummy() -> Self { Self::dummy_with(elements::LockTime::ZERO, elements::Sequence::MAX) @@ -127,7 +127,7 @@ impl ElementsEnv> { ]; ElementsEnv::new( - std::sync::Arc::new(elements::Transaction { + elements::Transaction { version: 2, lock_time, // Enable locktime in dummy txin @@ -140,7 +140,7 @@ impl ElementsEnv> { witness: elements::TxInWitness::default(), }], output: Vec::default(), - }), + }, vec![ElementsUtxo { script_pubkey: elements::Script::new(), asset: confidential::Asset::Null, diff --git a/src/node/redeem.rs b/src/node/redeem.rs index c8748217..89202b5d 100644 --- a/src/node/redeem.rs +++ b/src/node/redeem.rs @@ -1050,7 +1050,7 @@ mod tests { #[test] #[cfg(all(feature = "elements", feature = "human_encoding"))] fn prune() { - use crate::jet::ElementsTxEnv; + use crate::jet::elements::ElementsEnv; let env = crate::jet::elements::ElementsEnv::dummy(); @@ -1083,7 +1083,7 @@ main := comp input comp process jet_verify : 1 -> 1"#; Value::product(Value::u64(0), Value::unit()), ), ]); - assert_correct_pruning::( + assert_correct_pruning::>( unpruned_prog, &unpruned_wit, pruned_prog, @@ -1111,7 +1111,7 @@ main := comp input comp process jet_verify : 1 -> 1"#; Value::product(Value::unit(), Value::u64(0)), ), ]); - assert_correct_pruning::( + assert_correct_pruning::>( unpruned_prog, &unpruned_wit, pruned_prog, @@ -1136,7 +1136,7 @@ process := assertl (take jet_is_zero_64) #{take jet_is_zero_64} : (2^64 + 1) * 1 main := comp input comp process jet_verify : 1 -> 1"#; let pruned_wit = HashMap::from([(Arc::from("wit1"), Value::left(Value::u64(0), Final::unit()))]); - assert_correct_pruning::( + assert_correct_pruning::>( prune_sum, &unpruned_wit, pruned_prog, @@ -1157,7 +1157,7 @@ main := comp input comp process jet_verify : 1 -> 1"#; Arc::from("wit1"), Value::right(Final::unit(), Value::u64(0)), )]); - assert_correct_pruning::( + assert_correct_pruning::>( prune_sum, &unpruned_wit, pruned_prog, diff --git a/src/policy/serialize.rs b/src/policy/serialize.rs index b56ca453..ae5c376a 100644 --- a/src/policy/serialize.rs +++ b/src/policy/serialize.rs @@ -257,7 +257,7 @@ mod tests { fn compile( policy: Policy, - ) -> (Arc, ElementsEnv>) { + ) -> (Arc, ElementsEnv) { let commit = policy.commit(); let env = ElementsEnv::dummy(); @@ -267,7 +267,7 @@ mod tests { fn execute_successful( commit: &CommitNode, witness: Vec, - env: &ElementsEnv>, + env: &ElementsEnv, ) -> bool { let finalized = commit .finalize(&mut SimpleFinalizer::new(witness.into_iter())) From 387badf4cc28b56ac1dee2fc9c3efb7994e68ded Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 1 Oct 2025 23:38:11 +0000 Subject: [PATCH 08/10] jet: implement Rust bitcoin environment This is a Rust type which can be used, among other things, to construct the transaction environment needed by C jets. Also provides accessors for the underlying transaction and input index, both of which are used (in the Elements version of this struct) in the policy satisfier. --- src/jet/bitcoin/c_env.rs | 84 ++++++++++++++++++++++++++++++++++ src/jet/bitcoin/environment.rs | 37 +++++++++++++-- src/jet/bitcoin/mod.rs | 1 + 3 files changed, 118 insertions(+), 4 deletions(-) create mode 100644 src/jet/bitcoin/c_env.rs diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs new file mode 100644 index 00000000..5dd27a7c --- /dev/null +++ b/src/jet/bitcoin/c_env.rs @@ -0,0 +1,84 @@ +// SPDX-License-Identifier: CC0-1.0 + +use crate::Cmr; + +use bitcoin::hashes::Hash as _; +use bitcoin::taproot::ControlBlock; +use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; + +pub(super) fn new_tx( + tx: &bitcoin::Transaction, + in_utxos: &[bitcoin::TxOut], +) -> *mut c_bitcoin::CTransaction { + let mut raw_inputs = Vec::with_capacity(tx.input.len()); + let mut raw_outputs = Vec::with_capacity(tx.output.len()); + + for (inp, utxo) in tx.input.iter().zip(in_utxos.iter()) { + raw_inputs.push(c_bitcoin::CRawInput { + // FIXME actually pass the annex in; see https://github.com/BlockstreamResearch/simplicity/issues/311 for some difficulty here. + annex: core::ptr::null(), + prev_txid: inp.previous_output.txid.as_byte_array(), + txo: c_bitcoin::CRawOutput { + value: utxo.value.to_sat(), + script_pubkey: c_bitcoin::CRawBuffer::new(utxo.script_pubkey.as_bytes()), + }, + script_sig: c_bitcoin::CRawBuffer::new(inp.script_sig.as_bytes()), + prev_txout_index: inp.previous_output.vout, + sequence: inp.sequence.to_consensus_u32(), + }); + } + for out in tx.output.iter() { + raw_outputs.push(c_bitcoin::CRawOutput { + value: out.value.to_sat(), + script_pubkey: c_bitcoin::CRawBuffer::new(out.script_pubkey.as_bytes()), + }); + } + let txid = tx.compute_txid(); + + let c_raw_tx = c_bitcoin::CRawTransaction { + txid: txid.as_byte_array(), + inputs: raw_inputs.as_ptr(), + outputs: raw_outputs.as_ptr(), + n_inputs: raw_inputs.len().try_into().expect("sane length"), + n_outputs: raw_outputs.len().try_into().expect("sane length"), + version: tx.version.0 as u32, // in 1.87.0 can use .cast_unsigned + locktime: tx.lock_time.to_consensus_u32(), + }; + unsafe { + // SAFETY: this is a FFI call and we constructed its argument correctly. + c_bitcoin::simplicity_mallocTransaction(&c_raw_tx) + } +} + +pub(super) fn new_tap_env( + control_block: &ControlBlock, + script_cmr: Cmr, +) -> *mut c_bitcoin::CTapEnv { + let cb_ser = control_block.serialize(); + let raw_tap_env = c_bitcoin::CRawTapEnv { + control_block: cb_ser.as_ptr(), + script_cmr: script_cmr.as_ref().as_ptr(), + branch_len: control_block + .merkle_branch + .len() + .try_into() + .expect("sane length"), + }; + + unsafe { + // SAFETY: this is a FFI call and we constructed its argument correctly. + c_bitcoin::simplicity_mallocTapEnv(&raw_tap_env) + } +} + +pub(super) fn new_tx_env( + tx: *const c_bitcoin::CTransaction, + taproot: *const c_bitcoin::CTapEnv, + ix: u32, +) -> c_bitcoin::CTxEnv { + unsafe { + let mut tx_env = std::mem::MaybeUninit::::uninit(); + c_bitcoin::c_set_txEnv(tx_env.as_mut_ptr(), tx, taproot, ix); + tx_env.assume_init() + } +} diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs index ba0eae40..2980ca18 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -1,21 +1,50 @@ // SPDX-License-Identifier: CC0-1.0 +use crate::Cmr; + +use bitcoin::taproot::ControlBlock; use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; +use super::c_env; + /// Environment for Bitcoin Simplicity pub struct BitcoinEnv { - pub tx: T, + /// The CTxEnv struct + c_tx_env: c_bitcoin::CTxEnv, + tx: T, + ix: u32, } impl BitcoinEnv where T: core::borrow::Borrow, { - pub fn new(tx: T) -> Self { - BitcoinEnv { tx } + pub fn new( + tx: T, + utxos: &[bitcoin::TxOut], + ix: u32, + script_cmr: Cmr, + control_block: ControlBlock, + ) -> Self { + let c_tx = c_env::new_tx(tx.borrow(), utxos); + let c_tap_env = c_env::new_tap_env(&control_block, script_cmr); + let c_tx_env = c_env::new_tx_env(c_tx, c_tap_env, ix); + + BitcoinEnv { c_tx_env, tx, ix } + } + + /// The transaction of this environment + pub fn tx(&self) -> &bitcoin::Transaction { + self.tx.borrow() + } + + /// The input index of this environment + pub fn ix(&self) -> u32 { + self.ix } + /// A version of this environment used by the C implementation of the Bit Machine. pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv { - unimplemented!() + &self.c_tx_env } } diff --git a/src/jet/bitcoin/mod.rs b/src/jet/bitcoin/mod.rs index fa51421c..c67dbdef 100644 --- a/src/jet/bitcoin/mod.rs +++ b/src/jet/bitcoin/mod.rs @@ -1,5 +1,6 @@ // SPDX-License-Identifier: CC0-1.0 +mod c_env; mod environment; pub use environment::BitcoinEnv; From d04402d3a9b13eeec7c2c9c9e0467a6b93cec286 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 18 Dec 2025 18:43:48 +0000 Subject: [PATCH 09/10] jet: populate annexes in Bitcoin environment --- src/jet/bitcoin/c_env.rs | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs index 5dd27a7c..1b01d9da 100644 --- a/src/jet/bitcoin/c_env.rs +++ b/src/jet/bitcoin/c_env.rs @@ -12,11 +12,24 @@ pub(super) fn new_tx( ) -> *mut c_bitcoin::CTransaction { let mut raw_inputs = Vec::with_capacity(tx.input.len()); let mut raw_outputs = Vec::with_capacity(tx.output.len()); + // Allocate space for the raw annexes. This dumb `Vec::from_iter` construction is + // equivalent to `vec![None; tx.input.len()]`, but that won't compile because it + // requires Option::::None to be cloneable, which it's not because + // CRawBuffer isn't. - for (inp, utxo) in tx.input.iter().zip(in_utxos.iter()) { + // SAFETY: this allocation *must* live until after the `simplicity_mallocTransaction` + // at the bottom of this function. We convert the vector to a boxed slice to ensure + // it cannot be resized, which would potentially trigger a reallocation. + let mut raw_annexes = Vec::from_iter((0..tx.input.len()).map(|_| None)).into_boxed_slice(); + + for (n, (inp, utxo)) in tx.input.iter().zip(in_utxos.iter()).enumerate() { + raw_annexes[n] = inp.witness.taproot_annex().map(c_bitcoin::CRawBuffer::new); raw_inputs.push(c_bitcoin::CRawInput { - // FIXME actually pass the annex in; see https://github.com/BlockstreamResearch/simplicity/issues/311 for some difficulty here. - annex: core::ptr::null(), + // This `as_ref().map_or()` construction converts an Option<&T> to a nullable *const T. + // In theory it's a no-op. + annex: raw_annexes[n] + .as_ref() + .map_or(core::ptr::null(), |ptr| ptr as *const _), // cast should be changed to ptr::from_ref in rust 1.76 prev_txid: inp.previous_output.txid.as_byte_array(), txo: c_bitcoin::CRawOutput { value: utxo.value.to_sat(), @@ -44,10 +57,16 @@ pub(super) fn new_tx( version: tx.version.0 as u32, // in 1.87.0 can use .cast_unsigned locktime: tx.lock_time.to_consensus_u32(), }; - unsafe { + let ret = unsafe { // SAFETY: this is a FFI call and we constructed its argument correctly. c_bitcoin::simplicity_mallocTransaction(&c_raw_tx) - } + }; + // Explicitly drop raw_annexes so Rust doesn't try any funny business dropping it early. + // Drop raw_inputs first since it contains pointers into raw_annexes and we don't want + // them to dangle. (It'd be safe since they're raw pointers, but still bad mojo.) + drop(raw_inputs); + drop(raw_annexes); + ret } pub(super) fn new_tap_env( From a70b57eea972115b34547af4d6b368e9786fe760 Mon Sep 17 00:00:00 2001 From: Byron Hambly Date: Mon, 7 Sep 2026 14:40:13 +0200 Subject: [PATCH 10/10] bitcoin: extract annex per BIP341 instead of Witness::taproot_annex rust-bitcoin 0.32 removed Witness::taproot_annex. Replace it with an inline BIP341 annex extraction: the last witness element that begins with 0x50 is the annex. This matches the Elements c_env helper and the BIP341 specification. --- src/jet/bitcoin/c_env.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs index 1b01d9da..53494d91 100644 --- a/src/jet/bitcoin/c_env.rs +++ b/src/jet/bitcoin/c_env.rs @@ -3,7 +3,7 @@ use crate::Cmr; use bitcoin::hashes::Hash as _; -use bitcoin::taproot::ControlBlock; +use bitcoin::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX}; use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; pub(super) fn new_tx( @@ -23,7 +23,7 @@ pub(super) fn new_tx( let mut raw_annexes = Vec::from_iter((0..tx.input.len()).map(|_| None)).into_boxed_slice(); for (n, (inp, utxo)) in tx.input.iter().zip(in_utxos.iter()).enumerate() { - raw_annexes[n] = inp.witness.taproot_annex().map(c_bitcoin::CRawBuffer::new); + raw_annexes[n] = get_annex(&inp.witness).map(c_bitcoin::CRawBuffer::new); raw_inputs.push(c_bitcoin::CRawInput { // This `as_ref().map_or()` construction converts an Option<&T> to a nullable *const T. // In theory it's a no-op. @@ -101,3 +101,15 @@ pub(super) fn new_tx_env( tx_env.assume_init() } } + +/// Extracts the annex from a taproot witness stack per BIP341: if there are at +/// least two witness elements and the last one starts with 0x50, it is the annex. +/// (rust-bitcoin 0.32 removed `Witness::taproot_annex`.) +fn get_annex(in_witness: &bitcoin::Witness) -> Option<&[u8]> { + let last_item = in_witness.last()?; + if *last_item.first()? == TAPROOT_ANNEX_PREFIX { + Some(last_item) + } else { + None + } +}