]> git.bitcoin.ninja Git - rust-lightning/blob - lightning-c-bindings/src/chain/transaction.rs
[bindings] Check for a wasm32 target before compiling in genbindings
[rust-lightning] / lightning-c-bindings / src / chain / transaction.rs
1 //! Types describing on-chain transactions.
2
3 use std::ffi::c_void;
4 use bitcoin::hashes::Hash;
5 use crate::c_types::*;
6
7
8 use lightning::chain::transaction::OutPoint as nativeOutPointImport;
9 type nativeOutPoint = nativeOutPointImport;
10
11 /// A reference to a transaction output.
12 ///
13 /// Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32
14 /// due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way.
15 #[must_use]
16 #[repr(C)]
17 pub struct OutPoint {
18         /// Nearly everywhere, inner must be non-null, however in places where
19         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
20         pub inner: *mut nativeOutPoint,
21         pub is_owned: bool,
22 }
23
24 impl Drop for OutPoint {
25         fn drop(&mut self) {
26                 if self.is_owned && !self.inner.is_null() {
27                         let _ = unsafe { Box::from_raw(self.inner) };
28                 }
29         }
30 }
31 #[no_mangle]
32 pub extern "C" fn OutPoint_free(this_ptr: OutPoint) { }
33 #[allow(unused)]
34 /// Used only if an object of this type is returned as a trait impl by a method
35 extern "C" fn OutPoint_free_void(this_ptr: *mut c_void) {
36         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeOutPoint); }
37 }
38 #[allow(unused)]
39 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
40 impl OutPoint {
41         pub(crate) fn take_inner(mut self) -> *mut nativeOutPoint {
42                 assert!(self.is_owned);
43                 let ret = self.inner;
44                 self.inner = std::ptr::null_mut();
45                 ret
46         }
47 }
48 /// The referenced transaction's txid.
49 #[no_mangle]
50 pub extern "C" fn OutPoint_get_txid(this_ptr: &OutPoint) -> *const [u8; 32] {
51         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.txid;
52         (*inner_val).as_inner()
53 }
54 /// The referenced transaction's txid.
55 #[no_mangle]
56 pub extern "C" fn OutPoint_set_txid(this_ptr: &mut OutPoint, mut val: crate::c_types::ThirtyTwoBytes) {
57         unsafe { &mut *this_ptr.inner }.txid = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap();
58 }
59 /// The index of the referenced output in its transaction's vout.
60 #[no_mangle]
61 pub extern "C" fn OutPoint_get_index(this_ptr: &OutPoint) -> u16 {
62         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.index;
63         (*inner_val)
64 }
65 /// The index of the referenced output in its transaction's vout.
66 #[no_mangle]
67 pub extern "C" fn OutPoint_set_index(this_ptr: &mut OutPoint, mut val: u16) {
68         unsafe { &mut *this_ptr.inner }.index = val;
69 }
70 #[must_use]
71 #[no_mangle]
72 pub extern "C" fn OutPoint_new(mut txid_arg: crate::c_types::ThirtyTwoBytes, mut index_arg: u16) -> OutPoint {
73         OutPoint { inner: Box::into_raw(Box::new(nativeOutPoint {
74                 txid: ::bitcoin::hash_types::Txid::from_slice(&txid_arg.data[..]).unwrap(),
75                 index: index_arg,
76         })), is_owned: true }
77 }
78 impl Clone for OutPoint {
79         fn clone(&self) -> Self {
80                 Self {
81                         inner: if self.inner.is_null() { std::ptr::null_mut() } else {
82                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
83                         is_owned: true,
84                 }
85         }
86 }
87 #[allow(unused)]
88 /// Used only if an object of this type is returned as a trait impl by a method
89 pub(crate) extern "C" fn OutPoint_clone_void(this_ptr: *const c_void) -> *mut c_void {
90         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeOutPoint)).clone() })) as *mut c_void
91 }
92 #[no_mangle]
93 pub extern "C" fn OutPoint_clone(orig: &OutPoint) -> OutPoint {
94         orig.clone()
95 }
96 /// Convert an `OutPoint` to a lightning channel id.
97 #[must_use]
98 #[no_mangle]
99 pub extern "C" fn OutPoint_to_channel_id(this_arg: &OutPoint) -> crate::c_types::ThirtyTwoBytes {
100         let mut ret = unsafe { &*this_arg.inner }.to_channel_id();
101         crate::c_types::ThirtyTwoBytes { data: ret }
102 }
103
104 #[no_mangle]
105 pub extern "C" fn OutPoint_write(obj: &OutPoint) -> crate::c_types::derived::CVec_u8Z {
106         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
107 }
108 #[no_mangle]
109 pub(crate) extern "C" fn OutPoint_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
110         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeOutPoint) })
111 }
112 #[no_mangle]
113 pub extern "C" fn OutPoint_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_OutPointDecodeErrorZ {
114         let res = crate::c_types::deserialize_obj(ser);
115         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
116         local_res
117 }