BranchesTags

Repository files navigation

rust-bitcoinkernel

rust-bitcoinkernel is a wrapper around libbitcoinkernel, an experimental C++ library exposing Bitcoin Core's validation engine. It supports both validation of blocks and transaction outputs as well as reading block data.

Building

The library statically compiles the Bitcoin Core libbitcoinkernel library as part of its build system.

Bitcoin Core is vendored as a git subtree in this project. The subtree can be updated, or made to point at a different commit or branch in Bitcoin Core's history with:

git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the update using the provided script:

./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as cmake and a working C and C++ compiler are required. An installation of boost is required as well. Consult the Bitcoin Core documentation for the required dependencies. Once setup, run:

cargo b

Android Cross-Compilation

Android cross-compilation requires Nix.

Nix handles the exact NDK version, Rust toolchains, Boost, and cmake automatically, giving you a reproducible build environment with no manual setup.

nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)

The resulting libraries and headers are placed in result/lib/ and result/include.

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 1.77 should build with --locked to ensure a compatible dependency resolution:

cargo build --locked

Lock files

Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum and most recent compatible versions.

To regenerate them run:

./contrib/update_lock_files.sh

Documentation

You can find detailed information about the library on its crates.io, or access its documentation directly via doc.rs.

Examples

Examples for the usage of the library can be found in the examples/ directory and the tests. For now, the example binary implements a bare-bones silent payments scanner.

Fuzzing

Fuzzing is done with cargo fuzz.

There are currently three supported fuzzing targets: block_roundtrip, chainman_process_block and script_verify. The chainman target touches the filesystem in /tmp. If /tmp is not already a tmpfs, the user should create a tmpfs in /tmp/rust_kernel_fuzz.

To get fuzzing run (in this case the verify target):

cargo fuzz run script_verify

Sanitizers can be turned on with e.g.

RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip

To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs flags.

New fuzzing results may be submitted to the following corpus repository: https://github.com/alexanderwiederin/qa-assets

Coverage

Once fuzzed, a coverage report can be generated with (picking the verify target as an example):

RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:

rustup component add llvm-tools-preview
cargo install rustfilt

About

Rust bindings for the bitcoin kernel library

Resources

Readme
MIT license
Activity

Stars

64 stars

Watchers

10 watching

Forks

24 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
rust-bitcoinkernel
rust-bitcoinkernel is a wrapper around
libbitcoinkernel, an experimental C++
library exposing Bitcoin Core's validation engine. It supports both validation
of blocks and transaction outputs as well as reading block data.
Building
The library statically compiles the Bitcoin Core libbitcoinkernel library as
part of its build system.
Bitcoin Core is vendored as a git subtree in this project. The subtree can
be updated, or made to point at a different commit or branch in Bitcoin Core's
history with:
git subtree pull --prefix libbitcoinkernel-sys/bitcoin https://github.com/bitcoin/bitcoin master --squash

After updating the subtree, you can check for kernel-related commits in the
update using the provided script:
./contrib/check_subtree_kernel_commits.sh

To build this library, the usual Bitcoin Core build requirements, such as
cmake and a working C and C++ compiler are required. An installation of boost
is required as well. Consult the Bitcoin Core documentation for the required
dependencies. Once setup, run:
cargo b
Android Cross-Compilation
Android cross-compilation requires Nix.
Nix handles the exact NDK version, Rust toolchains, Boost, and cmake
automatically, giving you a reproducible build environment with no manual setup.
nix build .#libbitcoinkernel-android-aarch64
nix build .#libbitcoinkernel-android-armv7
nix build .#libbitcoinkernel-android-x86_64 # build only; tests skipped (see flake.nix)
The resulting libraries and headers are placed in result/lib/ and result/include.
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
1.77 should build with --locked to ensure a compatible dependency
resolution:
cargo build --locked
Lock files
Cargo-minimal.lock and Cargo-recent.lock pin dependencies to their minimum
and most recent compatible versions.
To regenerate them run:
./contrib/update_lock_files.sh
Documentation
You can find detailed information about the library on its
crates.io, or access its
documentation directly via
doc.rs.
Examples
Examples for the usage of the library can be found in the examples/ directory
and the tests. For now, the example binary implements a bare-bones silent
payments scanner.
Fuzzing
Fuzzing is done with cargo fuzz.
There are currently three supported fuzzing targets: block_roundtrip,
chainman_process_block and script_verify. The chainman target touches
the filesystem in /tmp. If /tmp is not already a tmpfs, the user should
create a tmpfs in /tmp/rust_kernel_fuzz.
To get fuzzing run (in this case the verify target):
cargo fuzz run script_verify
Sanitizers can be turned on with e.g.
RUSTFLAGS="-Zsanitizer=address" cargo fuzz run block_roundtrip
To get the sanitizer flags working in the libbitcoinkernel Bitcoin Core
library, the easiest way for now is to edit the libbitcoinkernel-sys/build.rs
flags.
New fuzzing results may be submitted to the following corpus repository:
https://github.com/alexanderwiederin/qa-assets
Coverage
Once fuzzed, a coverage report can be generated with (picking the verify
target as an example):
RUSTFLAGS="-C instrument-coverage" cargo fuzz coverage script_verify
llvm-cov show \
-format=html \
-instr-profile=fuzz/coverage/script_verify/coverage.profdata \
target/x86_64-unknown-linux-gnu/coverage/x86_64-unknown-linux-gnu/release/script_verify \
-show-line-counts-or-regions \
-Xdemangler=rustfilt \
-output-dir=coverage_report \
-ignore-filename-regex="/rustc"

You may have to install the following tooling:
rustup component add llvm-tools-preview
cargo install rustfilt

About
Rust bindings for the bitcoin kernel library
Resources
Readme
MIT license
Activity
Stars
64 stars
Watchers
10 watching
Forks
24 forks
Report repository
Releases
Packages
Used by
Contributors
Languages