Skip trait typedef in extra header as its unnecessary

... and OSX complains that "redefinition of typedef...is a C11
feature"

Drop rust-secp256k1 patch as it has been merged into a release upstream

Merge pull request #31 from TheBlueMatt/main

Fix aarch64 targeting and print an error if its disabled

Drop clang GH actions cache as it appears broken on OSX

Drop MacOS 11 runner until we get access to private preview

Fix aarch64 targeting and print an error if its disabled

Merge pull request #30 from TheBlueMatt/main

Clean up OSX support and build for aarch64-apple-darwin

Add OSX CI

Also build for aarch64-apple-darwin if we're building on x86_64 OSX

Clean up OSX support and rustc path selection somewhat

Merge pull request #29 from TheBlueMatt/main

Update to upstream 0.0.98

Update auto-generated bindings to upstream 0.0.98

Switch rust-lightning dep to upstream now that we're "stable"

Update git HEAD to upstream 0.0.98

Update bindings C++ demo to latest upstream (0.0.98) API

Only set -mcpu=sandybridge on x86_64

Drop spurious deref when converting Vec entries to C

Merge pull request #28 from TheBlueMatt/2021-06-fix-nondeterminism

Fix various sources of build non-determinism and default to targeting sandybridge (ie AVX)

Ensure we sanitize rustc random values for all lightning crates

Use 16 hexits for git describe to avoid nondeterminism

Set LC_ALL and -frandom-seed to avoid common nondeterminism sources

Swap default-cpu for sandybridge and use it when compiling libsecp

sandybridge is a reasonable choice because it supports AVX but is
also 10+ years old (with AMD support for AVX at similar times).

The next option would be haswell with AVX2, which doesn't add as
much and for which AMD processors only came about in mid-2015.

Merge pull request #27 from TheBlueMatt/main

Fix race in C++ demo where num_txs_broadcasted ++s before =0s

Fix race in C++ demo where num_txs_broadcasted ++s before =0s

Merge pull request #26 from TheBlueMatt/main

Update rust-secp patch to match latest version and bump upstream

Regenerate auto-generated bindings

Update RL git hash to latest upstream (hopefully next release)

Update rust-secp patch to match latest version

Merge pull request #25 from TheBlueMatt/2021-04-bp-inclusion

Add background-processor to the with-std bindings

Regenerate auto-generated bindings

Add background-processor to the with-std bindings

Take advantage of clone in more manually-defined c_types structs

Implement Clone for a few additional manually-defined c_types

Implement conversion of std::io::Error to Rust

Impl Send+Sync for every trait, not just those with it explicit

Because Send+Sync are generated by the compiler for us, we don't
really know when we should or should not generate it. That said,
Send+Sync aren't exposed outside of Rust, so it only impacts
whether we can use a type when passed to Rust, not how users will
ultimately interact with types.

Handle concrete Deref<Target=X> bounds in generic args

Merge pull request #24 from TheBlueMatt/main

Update Bindings for latest Upstream LDK

Update auto-generated bindings

Bump git depedency to latest upstream

Update auto-generated bindings to match latest upstream

Update bindings demo clients to the new event handling API

Update bindings demo to use invoices and the new inbound payment API

Create mappings for std::hasher::Hash and std::cmp::Eq

Add an export tag to indicate users cannot implement a given trait

Specifically, for the LDK `EventsProvider` trait, we can't
(trivially) implement the `process_pending_events` function,
defined as:
`fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler;`

We currently do not support implementing generic methods, as we'd
need to wrap them in a generic Rust-trait-to-C-trait conversion
utility, which we do not currently have. Thus, because users
almost certainly have no reason to implement the `EventsProvider`
themselves, its simpler to simply prevent the use of the C trait
struct as the Rust trait.

Concretely, this means just skipping the
`impl rustEventsProvider for CEventsProvider` block, which works
fine as no Rust functions take an `EventsProvider` as an argument.

Handle core:: and alloc::paths instead of just std:: (or prelude)

Merge pull request #23 from TheBlueMatt/main

Fix handling of returning Option<&Object> from Rust functions

Rebuild auto-generated bindings

Fix handling of returning Option<&Object> from Rust functions

Specifically, these were previously mapped by calling
`<object.as_ref().unwrap() as *const _>`, taking a pointer to the
option on stack instead of a pointer to the option itself.

We just need to drop the `as_ref()` to make it correct.

Merge pull request #22 from TheBlueMatt/main

Redo wasm bindings

Fix double-free of String bytes after converting an owned Str.

Redo wasm bindings

Merge pull request #20 from TheBlueMatt/main

Update CI to work around missing version.rs

Update auto-generated bindings (without new version files)

Add ability to get the LDK and LDK-C-Bindings version

Fix no-std+WASM builds by not mixing -flto and -fembed-bitcode

Merge pull request #19 from TheBlueMatt/2021-04-invoice-incl

Bump git hashes to latest upstream

Update auto-generated bindings with new upstream invoice creation

Map enum tuple variants with no contents as unitary enum variants

cbindgen maps `enum A { V() }` with a `struct A_V_Body {}` which
has different size on C and C++ (0 and 1 bytes). While this is
fine if a different variant has non-0 size as the union will be
correctly sized. However, there isn't a lot of reason to rely on
this when we can just have a unitary variant as well.

Resolve issues with Str introduced when it became ownable

When converting from a Str to an &str, we previously took ownership
of the Str, copied the pointer to its characters to an &str and
returned the &str. This made the returned bytes always unreadable.

Further, there is now no reason to use Vec_u8Z for owned Strs, so
we swap for Str as well.

Resolve generic params with default (eg `<A=B(>) as their default.

Drop stale () -> u8 mapping (now) used in Rust-only code

Handle generics on enums

Take parameters to trait functions as mut

In keeping with "generally, make all variables mut so that
converters can assume inputs are mut", we should do the same for
trait implementation blocks.

Support secp256k1 RecoverableSignatures

Drop debug print that slipped into git

Update module paths for hash wrappers

Correct handling of Display trait conversion

Previously we were incorrectly taking the *Rust* objects as
parameters in C functions instead of the C-mapped ones.

Merge pull request #18 from TheBlueMatt/2021-04-invoice-incl

Bump to latest upstream and include lightning-invoice bindings

Update auto-generated bindings with lightning-invoice

Simplify crates in genbindings, add invoice, and bump upstream git

Handle std::time::SystemTime as a manually-converted object

Update C++ bindings demo to support new payment secret/hash API

Allow missing_docs again as lightning-invoice uses it for enums

Support super:: in use block resolution

Support FromStr and Display impls, even if impl'd in a priv module

Support Self in generics in some cases (eg Result<Self, E> in an impl block)

Support taking an owned Self in function exports

Add a u5 type and a [u8; 20]

Handle additional type aliases for secp256k1 types

Correctly handle methods on an enum that take self

Handle `Vec<&Thing>` conversion to C.

Handle type resolution of `crate::thing` without a `use crate`

Merge pull request #17 from TheBlueMatt/2021-04-upstream-confirm

Bump upstream to handle the Confirm trait

Ensure array lengthgs are Int literals

This fixes a bug where an array will be converted to
[u8; StringLiteral] which results in us deciding we don't know how
to map it.

Fixes: dec732cefbdd97585b7de7fd4a9521f44f1580dd

Fix build with old/OSX clang, fixes #15

Update git hash to latest upstream

Update auto-generated bindings to latest upstream

Drop redundant deref in vec iteration

Handle tuple-in-slice conversions both to *and* from C

Handle transaction conversion directly instead of via a new var

new var conversion isn't supported everywhere, and there's really
no reason transaction conversion should need it.

Somewhat more consistently map references to C

Instead of assuming that in some cases references are
pre-dereferenced before the to-C prefix and suffix conversions, we
no longer do that.

This matches other cases and is simply more consistent, apparently
fixing an old oversight in early generation code.

Merge pull request #16 from afilini/cleanup

Minor cleanup/refactoring

Replace more manually-built `syn::Path` with `parse_quote!()`

Use `quote::format_ident!()` to make new `syn::Ident`

Use `parse_quote!()` to build complex syn::* objects

Remove unused import

Add .gitignore to ./c-bindings-gen

Merge pull request #14 from TheBlueMatt/main

Update to latest upstream