feat(nix): Android build outputs

This commit introduces nix outputs in flake.nix that prepares the
environment gathering dependencies that the Android build instructions
needs and testing instructions.

Testing android outputs is restricted to x86_64-linux and automatically
triggered when the build process ends. QEMU user-mode emulation is
configured as the Cargo test runner for cross-compiled Android targets.

Author: jaoleal

.gitignore

@@ -1,3 +1,4 @@
 /target
 Cargo.lock
 coverage_report
+result

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- Added Nix package outputs for Android with bundled NDK r24, Rust toolchains, Boost, and cmake.
 - Added `Block::check` to perform context-free validation of a block (size, weight, coinbase, transactions, sigops), with optional proof-of-work and merkle-root checks toggled via the `BLOCK_CHECK_BASE` / `_POW` / `_MERKLE` / `_ALL` flags. Returns a `BlockCheckResult` enum carrying the validation state on failure.
 - Implemented `Debug` for `BlockValidationResult`, `BlockValidationStateRef`, `ProcessBlockHeaderresult` and `BlockCheckResult`, enabling inspection via `{:?}` in logs and test output.
 - Added `#[must_use]` to `BlockCheckResult` and `ProcessBlockHeaderResult` to warn when validation results are silently ignored.

README.md

@@ -34,6 +34,23 @@ dependencies. Once setup, run:
 cargo b
 ```
 
+### Android Cross-Compilation
+
+Android cross-compilation requires [Nix](https://nixos.org/).
+
+Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
+automatically, giving you a reproducible build environment with no manual setup.
+
+```bash
+nix build .#android-aarch64
+nix build .#android-armv7
+nix build .#android-x86_64
+```
+
+The resulting libraries are placed in `result/lib/`.
+
+Output targets Android API 24+ (Nougat) minimum.
+
 ## MSRV (Minimum Supported Rust Version)
 
 The minimum supported Rust version is 1.71. Users on rustc older than

flake.nix

@@ -25,9 +25,10 @@
         };
 
         rustVersion = "1.71.0";
+        rustToolchainSha256 = "sha256-ks0nMEGGXKrHnfv4Fku+vhQ7gx76ruv6Ij4fKZR3l78=";
         rustToolchain = fenix.packages.${system}.fromToolchainName {
           name = rustVersion;
-          sha256 = "sha256-ks0nMEGGXKrHnfv4Fku+vhQ7gx76ruv6Ij4fKZR3l78=";
+          sha256 = rustToolchainSha256;
         };
         rustBuildToolchain = fenix.packages.${system}.combine [
           rustToolchain.rustc
@@ -85,6 +86,127 @@
             pkgs.gcc.cc.lib
           ];
         };
+
+        packages =
+          # Android build infrastructure (unfree NDK + SDK).
+          let
+            ndkVersion = "27.2.12479018"; # which NDK release to download
+            lockfile = ./Cargo-minimal.lock;
+            ANDROID_API_LEVEL = "24";
+            crateVersion =
+              (builtins.fromTOML (builtins.readFile ./libbitcoinkernel-sys/Cargo.toml)).package.version;
+
+            androidPkgs = import nixpkgs {
+              inherit system;
+              config.android_sdk.accept_license = true;
+              config.allowUnfree = true;
+            };
+            androidComposition = androidPkgs.androidenv.composeAndroidPackages {
+              # platformVersions is the SDK tooling version, not the minimum API level.
+              # The NDK target floor is set via ANDROID_API_LEVEL in build.rs (default 24).
+              platformVersions = [ "34" ];
+              ndkVersions = [ ndkVersion ];
+              includeNDK = true;
+            };
+            androidSdk = androidComposition.androidsdk;
+            androidNdk = "${androidSdk}/libexec/android-sdk/ndk/${ndkVersion}";
+
+            runTests = system == "x86_64-linux";
+
+            # x86_64-linux-android is excluded from tests: Rust 1.71's
+            # compiler_builtins lacks the f128 routines (__eqtf2, __multf3, …)
+            # that bionic's static libc.a requires on x86_64.
+            testableTargets = [
+              "aarch64-linux-android"
+              "armv7-linux-androideabi"
+            ];
+
+            mkAndroidPackage =
+              rustTarget:
+              let
+                canTest = runTests && builtins.elem rustTarget testableTargets;
+                rustTargetToolchain = fenix.packages.${system}.combine [
+                  rustToolchain.rustc
+                  rustToolchain.cargo
+                  rustToolchain.rust-src
+                  rustToolchain.rust-std
+                  (fenix.packages.${system}.targets.${rustTarget}.fromToolchainName {
+                    name = rustVersion;
+                    sha256 = rustToolchainSha256;
+                  }).rust-std
+                ];
+                rustPlatform = androidPkgs.makeRustPlatform {
+                  cargo = rustTargetToolchain;
+                  rustc = rustTargetToolchain;
+                };
+                qemuBin =
+                  if builtins.match "aarch64.*" rustTarget != null then
+                    "qemu-aarch64"
+                  else if builtins.match "armv7.*" rustTarget != null then
+                    "qemu-arm"
+                  else
+                    throw "Unsupported Android target: ${rustTarget}";
+                # NDK clang wrapper triple: armv7 uses "armv7a-linux-androideabi",
+                # all others match the Rust target triple.
+                ndkClangTriple =
+                  if builtins.match "armv7.*" rustTarget != null then "armv7a-linux-androideabi" else rustTarget;
+                ndkLinker = "${androidNdk}/toolchains/llvm/prebuilt/linux-x86_64/bin/${ndkClangTriple}${ANDROID_API_LEVEL}-clang";
+                cargoTargetPrefix = "CARGO_TARGET_${
+                  builtins.replaceStrings [ "-" ] [ "_" ] (pkgs.lib.toUpper rustTarget)
+                }";
+                cargoRunnerEnvVar = "${cargoTargetPrefix}_RUNNER";
+                cargoLinkerEnvVar = "${cargoTargetPrefix}_LINKER";
+              in
+              rustPlatform.buildRustPackage {
+                pname = "libbitcoinkernel-${rustTarget}";
+                version = crateVersion;
+                src = ./.;
+                cargoLock.lockFile = lockfile;
+                postPatch = ''
+                  cp ${lockfile} Cargo.lock
+                '';
+                nativeBuildInputs = [
+                  androidPkgs.cmake
+                  androidPkgs.boost.dev
+                  androidSdk
+                ]
+                ++ pkgs.lib.optionals canTest [
+                  pkgs.qemu
+                ];
+
+                ANDROID_HOME = "${androidSdk}/libexec/android-sdk";
+                ANDROID_NDK_HOME = androidNdk;
+                CMAKE_PREFIX_PATH = "${androidPkgs.boost.dev}";
+
+                # cargoBuildHook hardcodes the host --target at
+                # derivation time, so we bypass it for cross builds.
+                dontCargoBuild = true;
+                doCheck = canTest;
+                buildPhase = ''
+                  cargo build -p libbitcoinkernel-sys --target ${rustTarget} --offline --release
+                '';
+                checkPhase = pkgs.lib.optionalString canTest ''
+                  export ${cargoLinkerEnvVar}=${ndkLinker}
+                  export ${cargoRunnerEnvVar}=${pkgs.qemu}/bin/${qemuBin}
+                  export QEMU_LD_PREFIX=${androidNdk}/toolchains/llvm/prebuilt/linux-x86_64/sysroot
+                  export RUSTFLAGS="-C target-feature=+crt-static"
+                  cargo test --target ${rustTarget} --offline --release --verbose
+                '';
+                installPhase = ''
+                  mkdir -p $out/lib $out/include
+                  find target/${rustTarget}/release -path "*/out/install/lib/*.a" \
+                    -exec cp {} $out/lib/ \;
+                  find target/${rustTarget}/release -path "*/out/install/include/*" \
+                    -exec cp {} $out/include/ \;
+                '';
+              };
+          in
+          {
+            android-aarch64 = mkAndroidPackage "aarch64-linux-android";
+            android-armv7 = mkAndroidPackage "armv7-linux-androideabi";
+            android-x86_64 = mkAndroidPackage "x86_64-linux-android";
+            # i686 omitted: not a current target
+          };
       }
     );
 }