X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Fc_types%2Fmod.rs;h=1cb1eccebd0f0519f5f1a156d29fd90bf7e8b802;hb=f88af9aa921bde9f84d86f11df40b6623ba45fb5;hp=0c46581f20266e5abe23dfab1e1d151de0d2b40d;hpb=0cd1d74453b0d9527e9979c99e61b912b3257e06;p=ldk-c-bindings diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs index 0c46581..1cb1ecc 100644 --- a/lightning-c-bindings/src/c_types/mod.rs +++ b/lightning-c-bindings/src/c_types/mod.rs @@ -4,6 +4,7 @@ pub mod derived; use bitcoin::Transaction as BitcoinTransaction; +use bitcoin::Witness as BitcoinWitness; use bitcoin::hashes::Hash; use bitcoin::secp256k1::PublicKey as SecpPublicKey; use bitcoin::secp256k1::SecretKey as SecpSecretKey; @@ -41,15 +42,44 @@ impl From for NotConstructable { #[derive(PartialEq, Eq, Copy, Clone)] #[allow(non_camel_case_types)] #[repr(C)] -pub struct u5(u8); +pub struct U5(u8); -impl From for u5 { +impl From for U5 { fn from(o: bech32::u5) -> Self { Self(o.to_u8()) } } -impl Into for u5 { +impl Into for U5 { fn into(self) -> bech32::u5 { bech32::u5::try_from_u8(self.0).expect("u5 objects must be in the range 0..32") } } +/// Unsigned, 128-bit integer. +/// +/// Because LLVM implements an incorrect ABI for 128-bit integers, a wrapper type is defined here. +/// See https://github.com/rust-lang/rust/issues/54341 for more details. +#[derive(PartialEq, Eq, Copy, Clone)] +#[allow(non_camel_case_types)] +#[repr(C)] +pub struct U128 { + /// The 128-bit integer, as 16 little-endian bytes + pub le_bytes: [u8; 16], +} + +#[no_mangle] +/// Gets the 128-bit integer, as 16 little-endian bytes +pub extern "C" fn U128_le_bytes(val: U128) -> SixteenBytes { SixteenBytes { data: val.le_bytes } } +#[no_mangle] +/// Constructs a new U128 from 16 little-endian bytes +pub extern "C" fn U128_new(le_bytes: SixteenBytes) -> U128 { U128 { le_bytes: le_bytes.data } } + +impl From for U128 { + fn from(o: u128) -> Self { Self { le_bytes: o.to_le_bytes() } } +} +impl From<&mut u128> for U128 { + fn from(o: &mut u128) -> U128 { Self::from(*o) } +} +impl Into for U128 { + fn into(self) -> u128 { u128::from_le_bytes(self.le_bytes) } +} + /// Integer in the range `0..=16` #[derive(PartialEq, Eq, Copy, Clone)] #[repr(C)] @@ -166,6 +196,12 @@ impl BigEndianScalar { } } +#[no_mangle] +/// Convenience function for constructing a new BigEndianScalar +pub extern "C" fn BigEndianScalar_new(big_endian_bytes: ThirtyTwoBytes) -> BigEndianScalar { + BigEndianScalar { big_endian_bytes: big_endian_bytes.data } +} + #[repr(C)] #[derive(Copy, Clone)] /// Represents an error returned from libsecp256k1 during validation of some secp256k1 data @@ -310,8 +346,8 @@ pub enum IOError { UnexpectedEof, } impl IOError { - pub(crate) fn from_rust(err: io::Error) -> Self { - match err.kind() { + pub(crate) fn from_rust_kind(err: io::ErrorKind) -> Self { + match err { io::ErrorKind::NotFound => IOError::NotFound, io::ErrorKind::PermissionDenied => IOError::PermissionDenied, io::ErrorKind::ConnectionRefused => IOError::ConnectionRefused, @@ -333,8 +369,11 @@ impl IOError { _ => IOError::Other, } } - pub(crate) fn to_rust(&self) -> io::Error { - io::Error::new(match self { + pub(crate) fn from_rust(err: io::Error) -> Self { + Self::from_rust_kind(err.kind()) + } + pub(crate) fn to_rust_kind(&self) -> io::ErrorKind { + match self { IOError::NotFound => io::ErrorKind::NotFound, IOError::PermissionDenied => io::ErrorKind::PermissionDenied, IOError::ConnectionRefused => io::ErrorKind::ConnectionRefused, @@ -353,7 +392,10 @@ impl IOError { IOError::Interrupted => io::ErrorKind::Interrupted, IOError::Other => io::ErrorKind::Other, IOError::UnexpectedEof => io::ErrorKind::UnexpectedEof, - }, "") + } + } + pub(crate) fn to_rust(&self) -> io::Error { + io::Error::new(self.to_rust_kind(), "") } } @@ -419,7 +461,62 @@ impl Clone for Transaction { /// Frees the data buffer, if data_is_owned is set and datalen > 0. pub extern "C" fn Transaction_free(_res: Transaction) { } -pub(crate) fn bitcoin_to_C_outpoint(outpoint: ::bitcoin::blockdata::transaction::OutPoint) -> crate::lightning::chain::transaction::OutPoint { +#[repr(C)] +/// A serialized witness. +pub struct Witness { + /// The serialized transaction data. + /// + /// This is non-const for your convenience, an object passed to Rust is never written to. + pub data: *mut u8, + /// The length of the serialized transaction + pub datalen: usize, + /// Whether the data pointed to by `data` should be freed or not. + pub data_is_owned: bool, +} +impl Witness { + fn from_vec(vec: Vec) -> Self { + let datalen = vec.len(); + let data = Box::into_raw(vec.into_boxed_slice()); + Self { + data: unsafe { (*data).as_mut_ptr() }, + datalen, + data_is_owned: true, + } + } + pub(crate) fn into_bitcoin(&self) -> BitcoinWitness { + ::bitcoin::consensus::encode::deserialize(unsafe { core::slice::from_raw_parts(self.data, self.datalen) }).unwrap() + } + pub(crate) fn from_bitcoin(btc: &BitcoinWitness) -> Self { + let vec = ::bitcoin::consensus::encode::serialize(btc); + Self::from_vec(vec) + } +} + +impl Drop for Witness { + fn drop(&mut self) { + if self.data_is_owned && self.datalen != 0 { + let _ = derived::CVec_u8Z { data: self.data as *mut u8, datalen: self.datalen }; + } + } +} +impl Clone for Witness { + fn clone(&self) -> Self { + let sl = unsafe { core::slice::from_raw_parts(self.data, self.datalen) }; + let mut v = Vec::new(); + v.extend_from_slice(&sl); + Self::from_vec(v) + } +} + +#[no_mangle] +/// Creates a new Witness which has the same data as `orig` but with a new buffer. +pub extern "C" fn Witness_clone(orig: &Witness) -> Witness { orig.clone() } + +#[no_mangle] +/// Frees the data pointed to by data +pub extern "C" fn Witness_free(_res: Witness) { } + +pub(crate) fn bitcoin_to_C_outpoint(outpoint: &::bitcoin::blockdata::transaction::OutPoint) -> crate::lightning::chain::transaction::OutPoint { crate::lightning::chain::transaction::OutPoint_new(ThirtyTwoBytes { data: outpoint.txid.into_inner() }, outpoint.vout.try_into().unwrap()) } pub(crate) fn C_to_bitcoin_outpoint(outpoint: crate::lightning::chain::transaction::OutPoint) -> ::bitcoin::blockdata::transaction::OutPoint { @@ -430,6 +527,49 @@ pub(crate) fn C_to_bitcoin_outpoint(outpoint: crate::lightning::chain::transacti } } +#[repr(C)] +#[derive(Clone)] +/// An input to a transaction. +/// +/// This contains the witness, the scriptSig and the previous outpoint and represents a single +/// input to a transaction +pub struct TxIn { + /// The witness which includes any signatures required to spend a segwit output. + pub witness: Witness, + /// The script_sig which includes signatures requires to spend a pre-segwit output (or a + /// P2SH-wrapped segwit output). + pub script_sig: derived::CVec_u8Z, + /// The sequence number of the transaction input + pub sequence: u32, + /// The txid of the transaction being spent. + pub previous_txid: ThirtyTwoBytes, + /// The output index of the transaction being spent. + pub previous_vout: u32, +} + +impl TxIn { + pub(crate) fn from_rust(txin: &::bitcoin::blockdata::transaction::TxIn) -> Self { + TxIn { + witness: Witness::from_bitcoin(&txin.witness), + script_sig: derived::CVec_u8Z::from(txin.script_sig.clone().into_bytes()), + sequence: txin.sequence.0, + previous_txid: ThirtyTwoBytes { data: txin.previous_output.txid.into_inner() }, + previous_vout: txin.previous_output.vout, + } + } +} + +#[no_mangle] +/// Frees the witness and script_sig in a TxIn +pub extern "C" fn TxIn_free(_res: TxIn) { } + +#[no_mangle] +/// Convenience function for constructing a new TxIn +pub extern "C" fn TxIn_new(witness: Witness, script_sig: derived::CVec_u8Z, sequence: u32, previous_txid: ThirtyTwoBytes, previous_vout: u32) -> TxIn { + TxIn { witness, script_sig, sequence, previous_txid, previous_vout } +} + + #[repr(C)] #[derive(Clone)] /// A transaction output including a scriptPubKey and value. @@ -448,9 +588,9 @@ impl TxOut { value: self.value, } } - pub(crate) fn from_rust(txout: ::bitcoin::blockdata::transaction::TxOut) -> Self { + pub(crate) fn from_rust(txout: &::bitcoin::blockdata::transaction::TxOut) -> Self { Self { - script_pubkey: derived::CVec_u8Z::from(txout.script_pubkey.into_bytes()), + script_pubkey: derived::CVec_u8Z::from(txout.script_pubkey.clone().into_bytes()), value: txout.value } } @@ -510,11 +650,6 @@ pub struct ThirtyTwoBytes { /// The thirty-two bytes pub data: [u8; 32], } -impl ThirtyTwoBytes { - pub(crate) fn null() -> Self { - Self { data: [0; 32] } - } -} #[repr(C)] /// A 3-byte byte array. @@ -536,6 +671,11 @@ pub struct SixteenBytes { /** The sixteen bytes */ pub data: [u8; 16], } /// A 20-byte byte array. pub struct TwentyBytes { /** The twenty bytes */ pub data: [u8; 20], } +#[derive(Clone)] +#[repr(C)] +/// 8 u16s +pub struct EightU16s { /** The eight 16-bit integers */ pub data: [u16; 8], } + pub(crate) struct VecWriter(pub Vec); impl lightning::util::ser::Writer for VecWriter { fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> { @@ -664,10 +804,10 @@ impl Drop for CResultTempl { fn drop(&mut self) { if self.result_ok { if unsafe { !self.contents.result.is_null() } { - unsafe { Box::from_raw(self.contents.result) }; + let _ = unsafe { Box::from_raw(self.contents.result) }; } } else if unsafe { !self.contents.err.is_null() } { - unsafe { Box::from_raw(self.contents.err) }; + let _ = unsafe { Box::from_raw(self.contents.err) }; } } } @@ -768,7 +908,7 @@ impl SmartPtr { impl Drop for SmartPtr { fn drop(&mut self) { if self.ptr != core::ptr::null_mut() { - unsafe { Box::from_raw(self.ptr); } + let _ = unsafe { Box::from_raw(self.ptr) }; } } }