X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Fc_types%2Fmod.rs;h=3fe5eb62eece32b501e415fa22ae8bca1846d088;hb=HEAD;hp=0bd976bac8f1e47ee75ad5995a0bf123ce8f01dd;hpb=3fef735ad0382272f55cce06aefa489bcfaa2eb9;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 0bd976b..858e227 100644 --- a/lightning-c-bindings/src/c_types/mod.rs +++ b/lightning-c-bindings/src/c_types/mod.rs @@ -4,25 +4,34 @@ pub mod derived; use bitcoin::Transaction as BitcoinTransaction; +use bitcoin::Witness as BitcoinWitness; +use bitcoin::address; +use bitcoin::address::WitnessProgram as BitcoinWitnessProgram; +use bitcoin::key::TweakedPublicKey as BitcoinTweakedPublicKey; +use bitcoin::key::XOnlyPublicKey; use bitcoin::hashes::Hash; -use bitcoin::secp256k1::key::PublicKey as SecpPublicKey; -use bitcoin::secp256k1::key::SecretKey as SecpSecretKey; -use bitcoin::secp256k1::Signature as SecpSignature; +use bitcoin::secp256k1::PublicKey as SecpPublicKey; +use bitcoin::secp256k1::SecretKey as SecpSecretKey; +use bitcoin::secp256k1::ecdsa::Signature as ECDSASecpSignature; +use bitcoin::secp256k1::schnorr::Signature as SchnorrSecpSignature; use bitcoin::secp256k1::Error as SecpError; -use bitcoin::secp256k1::recovery::RecoveryId; -use bitcoin::secp256k1::recovery::RecoverableSignature as SecpRecoverableSignature; +use bitcoin::secp256k1::ecdsa::RecoveryId; +use bitcoin::secp256k1::ecdsa::RecoverableSignature as SecpRecoverableSignature; +use bitcoin::secp256k1::Scalar as SecpScalar; use bitcoin::bech32; use core::convert::TryInto; // Bindings need at least rustc 1.34 +use alloc::borrow::ToOwned; use core::ffi::c_void; -#[cfg(feature = "std")] +#[cfg(not(feature = "no-std"))] pub(crate) use std::io::{self, Cursor, Read}; #[cfg(feature = "no-std")] pub(crate) use core2::io::{self, Cursor, Read}; -#[cfg(feature = "no-std")] use alloc::{boxed::Box, vec::Vec, string::String}; +use core::convert::TryFrom; + #[repr(C)] /// A dummy struct of which an instance must never exist. /// This corresponds to the Rust type `Infallible`, or, in unstable rust, `!` @@ -37,15 +46,110 @@ 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)] +pub struct WitnessVersion(u8); + +impl From for WitnessVersion { + fn from(o: address::WitnessVersion) -> Self { Self(o.to_num()) } +} +impl Into for WitnessVersion { + fn into(self) -> address::WitnessVersion { + address::WitnessVersion::try_from(self.0).expect("WitnessVersion objects must be in the range 0..=16") + } +} + +/// A segregated witness version byte and script bytes +#[repr(C)] +#[derive(Clone)] +pub struct WitnessProgram { + version: WitnessVersion, + program: derived::CVec_u8Z, +} +impl WitnessProgram { + pub(crate) fn from_bitcoin(o: BitcoinWitnessProgram) -> Self { + Self { + version: o.version().into(), + program: o.program().as_bytes().to_vec().into(), + } + } + pub(crate) fn into_bitcoin(mut self) -> BitcoinWitnessProgram { + BitcoinWitnessProgram::new( + self.version.into(), + self.program.into_rust(), + ).expect("Program length was previously checked") + } +} + +#[no_mangle] +/// Constructs a new WitnessProgram given a version and program bytes. +/// +/// The program MUST be at least 2 bytes and no longer than 40 bytes long. +/// Further, if the version is 0, the program MUST be either exactly 20 or exactly 32 bytes long. +pub extern "C" fn WitnessProgram_new(version: WitnessVersion, program: derived::CVec_u8Z) -> WitnessProgram { + assert!(program.datalen >= 2, "WitnessProgram program lengths must be at least 2 bytes long"); + assert!(program.datalen <= 40, "WitnessProgram program lengths must be no longer than 40 bytes"); + if version.0 == 0 { + assert!(program.datalen == 20 || program.datalen == 32, "WitnessProgram program length must be 20 or 32 for version-0 programs"); + } + WitnessProgram { version, program } +} +#[no_mangle] +/// Gets the `WitnessVersion` of the given `WitnessProgram` +pub extern "C" fn WitnessProgram_get_version(prog: &WitnessProgram) -> WitnessVersion { + prog.version +} +#[no_mangle] +/// Gets the witness program bytes of the given `WitnessProgram` +pub extern "C" fn WitnessProgram_get_program(prog: &WitnessProgram) -> u8slice { + u8slice::from_vec(&prog.program) +} +#[no_mangle] +/// Creates a new WitnessProgram which has the same data as `orig` +pub extern "C" fn WitnessProgram_clone(orig: &WitnessProgram) -> WitnessProgram { orig.clone() } +#[no_mangle] +/// Releases any memory held by the given `WitnessProgram` (which is currently none) +pub extern "C" fn WitnessProgram_free(o: WitnessProgram) { } + #[derive(Clone)] #[repr(C)] /// Represents a valid secp256k1 public key serialized in "compressed form" as a 33 byte array. @@ -66,7 +170,27 @@ impl PublicKey { pub(crate) fn null() -> Self { Self { compressed_form: [0; 33] } } } +#[derive(Clone)] +#[repr(C)] +/// Represents a tweaked X-only public key as required for BIP 340 (Taproot). +pub struct TweakedPublicKey { + /// The bytes of the public key X coordinate + pub x_coordinate: [u8; 32], +} +impl TweakedPublicKey { + pub(crate) fn from_rust(pk: &BitcoinTweakedPublicKey) -> Self { + Self { + x_coordinate: pk.serialize(), + } + } + pub(crate) fn into_rust(&self) -> BitcoinTweakedPublicKey { + let xonly_key = XOnlyPublicKey::from_slice(&self.x_coordinate).unwrap(); + BitcoinTweakedPublicKey::dangerous_assume_tweaked(xonly_key) + } +} + #[repr(C)] +#[derive(Clone)] /// Represents a valid secp256k1 secret key serialized as a 32 byte array. pub struct SecretKey { /// The bytes of the secret key @@ -86,23 +210,38 @@ impl SecretKey { #[repr(C)] #[derive(Clone)] -/// Represents a secp256k1 signature serialized as two 32-byte numbers -pub struct Signature { +/// Represents a secp256k1 ECDSA signature serialized as two 32-byte numbers +pub struct ECDSASignature { /// The bytes of the signature in "compact" form pub compact_form: [u8; 64], } -impl Signature { - pub(crate) fn from_rust(pk: &SecpSignature) -> Self { +impl ECDSASignature { + pub(crate) fn from_rust(pk: &ECDSASecpSignature) -> Self { Self { compact_form: pk.serialize_compact(), } } - pub(crate) fn into_rust(&self) -> SecpSignature { - SecpSignature::from_compact(&self.compact_form).unwrap() + pub(crate) fn into_rust(&self) -> ECDSASecpSignature { + ECDSASecpSignature::from_compact(&self.compact_form).unwrap() + } +} + +#[repr(C)] +#[derive(Clone)] +/// Represents a secp256k1 Schnorr signature serialized as two 32-byte numbers +pub struct SchnorrSignature { + /// The bytes of the signature as two 32-byte numbers + pub compact_form: [u8; 64], +} +impl SchnorrSignature { + pub(crate) fn from_rust(pk: &SchnorrSecpSignature) -> Self { + Self { + compact_form: pk.as_ref().clone(), + } + } + pub(crate) fn into_rust(&self) -> SchnorrSecpSignature { + SchnorrSecpSignature::from_slice(&self.compact_form).unwrap() } - // The following are used for Option which we support, but don't use anymore - #[allow(unused)] pub(crate) fn is_null(&self) -> bool { self.compact_form[..] == [0; 64][..] } - #[allow(unused)] pub(crate) fn null() -> Self { Self { compact_form: [0; 64] } } } #[repr(C)] @@ -131,6 +270,31 @@ impl RecoverableSignature { } } +#[repr(C)] +#[derive(Clone)] +/// Represents a scalar value between zero and the secp256k1 curve order, in big endian. +pub struct BigEndianScalar { + /// The bytes of the scalar value. + pub big_endian_bytes: [u8; 32], +} +impl BigEndianScalar { + pub(crate) fn from_rust(scalar: &SecpScalar) -> Self { + Self { big_endian_bytes: scalar.to_be_bytes() } + } + pub(crate) fn into_rust(&self) -> SecpScalar { + SecpScalar::from_be_bytes(self.big_endian_bytes).expect("Scalar greater than the curve order") + } +} + +#[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 } +} +#[no_mangle] +/// Creates a new BigEndianScalar which has the same data as `orig` +pub extern "C" fn BigEndianScalar_clone(orig: &BigEndianScalar) -> BigEndianScalar { orig.clone() } + #[repr(C)] #[derive(Copy, Clone)] /// Represents an error returned from libsecp256k1 during validation of some secp256k1 data @@ -145,14 +309,18 @@ pub enum Secp256k1Error { InvalidSignature, /// Bad secret key InvalidSecretKey, + /// Bad shared secret. + InvalidSharedSecret, /// Bad recovery id InvalidRecoveryId, /// Invalid tweak for add_assign or mul_assign InvalidTweak, - /// tweak_add_check failed on an xonly public key - TweakCheckFailed, /// Didn't pass enough memory to context creation with preallocated memory NotEnoughMemory, + /// Bad set of public keys. + InvalidPublicKeySum, + /// The only valid parity values are 0 or 1. + InvalidParityValue, } impl Secp256k1Error { pub(crate) fn from_rust(err: SecpError) -> Self { @@ -162,12 +330,88 @@ impl Secp256k1Error { SecpError::InvalidPublicKey => Secp256k1Error::InvalidPublicKey, SecpError::InvalidSignature => Secp256k1Error::InvalidSignature, SecpError::InvalidSecretKey => Secp256k1Error::InvalidSecretKey, + SecpError::InvalidSharedSecret => Secp256k1Error::InvalidSharedSecret, SecpError::InvalidRecoveryId => Secp256k1Error::InvalidRecoveryId, SecpError::InvalidTweak => Secp256k1Error::InvalidTweak, - SecpError::TweakCheckFailed => Secp256k1Error::TweakCheckFailed, SecpError::NotEnoughMemory => Secp256k1Error::NotEnoughMemory, + SecpError::InvalidPublicKeySum => Secp256k1Error::InvalidPublicKeySum, + SecpError::InvalidParityValue(_) => Secp256k1Error::InvalidParityValue, + } + } + pub(crate) fn into_rust(self) -> SecpError { + let invalid_parity = secp256k1::Parity::from_i32(42).unwrap_err(); + match self { + Secp256k1Error::IncorrectSignature => SecpError::IncorrectSignature, + Secp256k1Error::InvalidMessage => SecpError::InvalidMessage, + Secp256k1Error::InvalidPublicKey => SecpError::InvalidPublicKey, + Secp256k1Error::InvalidSignature => SecpError::InvalidSignature, + Secp256k1Error::InvalidSecretKey => SecpError::InvalidSecretKey, + Secp256k1Error::InvalidSharedSecret => SecpError::InvalidSharedSecret, + Secp256k1Error::InvalidRecoveryId => SecpError::InvalidRecoveryId, + Secp256k1Error::InvalidTweak => SecpError::InvalidTweak, + Secp256k1Error::NotEnoughMemory => SecpError::NotEnoughMemory, + Secp256k1Error::InvalidPublicKeySum => SecpError::InvalidPublicKeySum, + Secp256k1Error::InvalidParityValue => SecpError::InvalidParityValue(invalid_parity), + } + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +/// Represents an error returned from the bech32 library during validation of some bech32 data +pub enum Bech32Error { + /// String does not contain the separator character + MissingSeparator, + /// The checksum does not match the rest of the data + InvalidChecksum, + /// The data or human-readable part is too long or too short + InvalidLength, + /// Some part of the string contains an invalid character + InvalidChar(u32), + /// Some part of the data has an invalid value + InvalidData(u8), + /// The bit conversion failed due to a padding issue + InvalidPadding, + /// The whole string must be of one case + MixedCase, +} +impl Bech32Error { + pub(crate) fn from_rust(err: bech32::Error) -> Self { + match err { + bech32::Error::MissingSeparator => Self::MissingSeparator, + bech32::Error::InvalidChecksum => Self::InvalidChecksum, + bech32::Error::InvalidLength => Self::InvalidLength, + bech32::Error::InvalidChar(c) => Self::InvalidChar(c as u32), + bech32::Error::InvalidData(d) => Self::InvalidData(d), + bech32::Error::InvalidPadding => Self::InvalidPadding, + bech32::Error::MixedCase => Self::MixedCase, } } + pub(crate) fn into_rust(self) -> bech32::Error { + match self { + Self::MissingSeparator => bech32::Error::MissingSeparator, + Self::InvalidChecksum => bech32::Error::InvalidChecksum, + Self::InvalidLength => bech32::Error::InvalidLength, + Self::InvalidChar(c) => bech32::Error::InvalidChar(core::char::from_u32(c).expect("Invalid UTF-8 character in Bech32Error::InvalidChar")), + Self::InvalidData(d) => bech32::Error::InvalidData(d), + Self::InvalidPadding => bech32::Error::InvalidPadding, + Self::MixedCase => bech32::Error::MixedCase, + } + } +} +#[no_mangle] +/// Creates a new Bech32Error which has the same data as `orig` +pub extern "C" fn Bech32Error_clone(orig: &Bech32Error) -> Bech32Error { orig.clone() } +#[no_mangle] +/// Releases any memory held by the given `Bech32Error` (which is currently none) +pub extern "C" fn Bech32Error_free(o: Bech32Error) { } + +#[repr(C)] +#[derive(Clone, Copy, PartialEq)] +/// Sub-errors which don't have specific information in them use this type. +pub struct Error { + /// Zero-Sized_types aren't consistent across Rust/C/C++, so we add some size here + pub _dummy: u8, } #[repr(C)] @@ -194,52 +438,57 @@ pub enum IOError { Other, UnexpectedEof, } -#[cfg(feature = "std")] impl IOError { - pub(crate) fn from_rust(err: std::io::Error) -> Self { - match err.kind() { - std::io::ErrorKind::NotFound => IOError::NotFound, - std::io::ErrorKind::PermissionDenied => IOError::PermissionDenied, - std::io::ErrorKind::ConnectionRefused => IOError::ConnectionRefused, - std::io::ErrorKind::ConnectionReset => IOError::ConnectionReset, - std::io::ErrorKind::ConnectionAborted => IOError::ConnectionAborted, - std::io::ErrorKind::NotConnected => IOError::NotConnected, - std::io::ErrorKind::AddrInUse => IOError::AddrInUse, - std::io::ErrorKind::AddrNotAvailable => IOError::AddrNotAvailable, - std::io::ErrorKind::BrokenPipe => IOError::BrokenPipe, - std::io::ErrorKind::AlreadyExists => IOError::AlreadyExists, - std::io::ErrorKind::WouldBlock => IOError::WouldBlock, - std::io::ErrorKind::InvalidInput => IOError::InvalidInput, - std::io::ErrorKind::InvalidData => IOError::InvalidData, - std::io::ErrorKind::TimedOut => IOError::TimedOut, - std::io::ErrorKind::WriteZero => IOError::WriteZero, - std::io::ErrorKind::Interrupted => IOError::Interrupted, - std::io::ErrorKind::Other => IOError::Other, - std::io::ErrorKind::UnexpectedEof => IOError::UnexpectedEof, + 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, + io::ErrorKind::ConnectionReset => IOError::ConnectionReset, + io::ErrorKind::ConnectionAborted => IOError::ConnectionAborted, + io::ErrorKind::NotConnected => IOError::NotConnected, + io::ErrorKind::AddrInUse => IOError::AddrInUse, + io::ErrorKind::AddrNotAvailable => IOError::AddrNotAvailable, + io::ErrorKind::BrokenPipe => IOError::BrokenPipe, + io::ErrorKind::AlreadyExists => IOError::AlreadyExists, + io::ErrorKind::WouldBlock => IOError::WouldBlock, + io::ErrorKind::InvalidInput => IOError::InvalidInput, + io::ErrorKind::InvalidData => IOError::InvalidData, + io::ErrorKind::TimedOut => IOError::TimedOut, + io::ErrorKind::WriteZero => IOError::WriteZero, + io::ErrorKind::Interrupted => IOError::Interrupted, + io::ErrorKind::Other => IOError::Other, + io::ErrorKind::UnexpectedEof => IOError::UnexpectedEof, _ => IOError::Other, } } - pub(crate) fn to_rust(&self) -> std::io::Error { - std::io::Error::new(match self { - IOError::NotFound => std::io::ErrorKind::NotFound, - IOError::PermissionDenied => std::io::ErrorKind::PermissionDenied, - IOError::ConnectionRefused => std::io::ErrorKind::ConnectionRefused, - IOError::ConnectionReset => std::io::ErrorKind::ConnectionReset, - IOError::ConnectionAborted => std::io::ErrorKind::ConnectionAborted, - IOError::NotConnected => std::io::ErrorKind::NotConnected, - IOError::AddrInUse => std::io::ErrorKind::AddrInUse, - IOError::AddrNotAvailable => std::io::ErrorKind::AddrNotAvailable, - IOError::BrokenPipe => std::io::ErrorKind::BrokenPipe, - IOError::AlreadyExists => std::io::ErrorKind::AlreadyExists, - IOError::WouldBlock => std::io::ErrorKind::WouldBlock, - IOError::InvalidInput => std::io::ErrorKind::InvalidInput, - IOError::InvalidData => std::io::ErrorKind::InvalidData, - IOError::TimedOut => std::io::ErrorKind::TimedOut, - IOError::WriteZero => std::io::ErrorKind::WriteZero, - IOError::Interrupted => std::io::ErrorKind::Interrupted, - IOError::Other => std::io::ErrorKind::Other, - IOError::UnexpectedEof => std::io::ErrorKind::UnexpectedEof, - }, "") + 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, + IOError::ConnectionReset => io::ErrorKind::ConnectionReset, + IOError::ConnectionAborted => io::ErrorKind::ConnectionAborted, + IOError::NotConnected => io::ErrorKind::NotConnected, + IOError::AddrInUse => io::ErrorKind::AddrInUse, + IOError::AddrNotAvailable => io::ErrorKind::AddrNotAvailable, + IOError::BrokenPipe => io::ErrorKind::BrokenPipe, + IOError::AlreadyExists => io::ErrorKind::AlreadyExists, + IOError::WouldBlock => io::ErrorKind::WouldBlock, + IOError::InvalidInput => io::ErrorKind::InvalidInput, + IOError::InvalidData => io::ErrorKind::InvalidData, + IOError::TimedOut => io::ErrorKind::TimedOut, + IOError::WriteZero => io::ErrorKind::WriteZero, + 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(), "") } } @@ -305,8 +554,63 @@ 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 { - crate::lightning::chain::transaction::OutPoint_new(ThirtyTwoBytes { data: outpoint.txid.into_inner() }, outpoint.vout.try_into().unwrap()) +#[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.as_ref() }, outpoint.vout.try_into().unwrap()) } pub(crate) fn C_to_bitcoin_outpoint(outpoint: crate::lightning::chain::transaction::OutPoint) -> ::bitcoin::blockdata::transaction::OutPoint { unsafe { @@ -316,6 +620,71 @@ 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.as_ref() }, + previous_vout: txin.previous_output.vout, + } + } +} +#[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 } +} +#[no_mangle] +/// Gets the `witness` in the given `TxIn`. +pub extern "C" fn TxIn_get_witness(txin: &TxIn) -> Witness { + txin.witness.clone() +} +#[no_mangle] +/// Gets the `script_sig` in the given `TxIn`. +pub extern "C" fn TxIn_get_script_sig(txin: &TxIn) -> u8slice { + u8slice::from_vec(&txin.script_sig) +} +#[no_mangle] +/// Gets the `sequence` in the given `TxIn`. +pub extern "C" fn TxIn_get_sequence(txin: &TxIn) -> u32 { + txin.sequence +} +#[no_mangle] +/// Gets the previous outpoint txid in the given `TxIn`. +pub extern "C" fn TxIn_get_previous_txid(txin: &TxIn) -> ThirtyTwoBytes { + txin.previous_txid +} +#[no_mangle] +/// Gets the previout outpoint index in the given `TxIn`. +pub extern "C" fn TxIn_get_previous_vout(txin: &TxIn) -> u32 { + txin.previous_vout +} +#[no_mangle] +/// Frees the witness and script_sig in a TxIn +pub extern "C" fn TxIn_free(_res: TxIn) { } + #[repr(C)] #[derive(Clone)] /// A transaction output including a scriptPubKey and value. @@ -334,9 +703,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 } } @@ -348,6 +717,16 @@ pub extern "C" fn TxOut_new(script_pubkey: derived::CVec_u8Z, value: u64) -> TxO TxOut { script_pubkey, value } } #[no_mangle] +/// Gets the `script_pubkey` in the given `TxOut`. +pub extern "C" fn TxOut_get_script_pubkey(txout: &TxOut) -> u8slice { + u8slice::from_vec(&txout.script_pubkey) +} +#[no_mangle] +/// Gets the value in the given `TxOut`. +pub extern "C" fn TxOut_get_value(txout: &TxOut) -> u64 { + txout.value +} +#[no_mangle] /// Frees the data pointed to by script_pubkey. pub extern "C" fn TxOut_free(_res: TxOut) { } #[no_mangle] @@ -396,12 +775,8 @@ pub struct ThirtyTwoBytes { /// The thirty-two bytes pub data: [u8; 32], } -impl ThirtyTwoBytes { - pub(crate) fn null() -> Self { - Self { data: [0; 32] } - } -} +#[derive(Clone)] #[repr(C)] /// A 3-byte byte array. pub struct ThreeBytes { /** The three bytes */ pub data: [u8; 3], } @@ -422,6 +797,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)] +/// 32 u16s +pub struct ThirtyTwoU16s { /** The thirty-two 16-bit integers */ pub data: [u16; 32], } + pub(crate) struct VecWriter(pub Vec); impl lightning::util::ser::Writer for VecWriter { fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> { @@ -455,14 +835,14 @@ pub struct Str { /// Whether the data pointed to by `chars` should be freed or not. pub chars_is_owned: bool, } -impl Into for &'static str { +impl Into for &str { fn into(self) -> Str { - Str { chars: self.as_ptr(), len: self.len(), chars_is_owned: false } + self.to_owned().into() } } -impl Into for &mut &'static str { +impl Into for &mut &str { fn into(self) -> Str { - let us: &'static str = *self; + let us: &str = *self; us.into() } } @@ -488,6 +868,10 @@ impl Str { }; String::from_utf8(bytes).unwrap() } + #[cfg(not(feature = "no-std"))] + pub(crate) fn into_pathbuf(mut self) -> std::path::PathBuf { + std::path::PathBuf::from(self.into_string()) + } } impl Into for String { fn into(self) -> Str { @@ -495,9 +879,15 @@ impl Into for String { Str { chars: s.as_ptr(), len: s.len(), chars_is_owned: true } } } +#[cfg(not(feature = "no-std"))] +impl Into for std::path::PathBuf { + fn into(self) -> Str { + self.into_os_string().into_string().expect("We expect paths to be UTF-8 valid").into() + } +} impl Clone for Str { fn clone(&self) -> Self { - self.into_str().clone().into() + String::from(self.into_str()).into() } } @@ -550,10 +940,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) }; } } } @@ -654,7 +1044,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) }; } } }