Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d3afe1ba7b | ||
|
|
41e2b10d8d | ||
|
|
f43884c4a5 | ||
|
|
16f4013be5 | ||
|
|
7d1fbb310b | ||
|
|
bff8f4d801 | ||
|
|
b8a73b5ba4 | ||
|
|
3aac028c0b | ||
|
|
125cea97ad | ||
|
|
624df51578 | ||
|
|
3d906e757a | ||
|
|
f7b6f4bf0e | ||
|
|
176fb07e8f | ||
|
|
5557343c5c | ||
|
|
2c796aa1d2 | ||
|
|
86ab6ee1c9 | ||
|
|
2611e47d12 | ||
|
|
aac9a39a17 | ||
|
|
7bed84a511 | ||
|
|
f4d54f0c1f | ||
|
|
8496011747 | ||
|
|
efc23e537b | ||
|
|
01fddd3f9b | ||
|
|
dd5fe3ef3e | ||
|
|
636400f30c | ||
|
|
5449bc5594 | ||
|
|
46eda8c69a | ||
|
|
86c90c1051 | ||
|
|
e9291d4960 | ||
|
|
d5053487d2 | ||
|
|
ed12d4fd35 | ||
|
|
948501af3b | ||
|
|
2c9fb5060e | ||
|
|
9de7c2aaae | ||
|
|
c570e3c722 | ||
|
|
2a6c795ee1 | ||
|
|
e1abd12676 | ||
|
|
ab9bbc0d22 | ||
|
|
97ab852eeb | ||
|
|
9465d6b3ce | ||
|
|
986f6799cb | ||
|
|
076195d034 | ||
|
|
fd4625f98a | ||
|
|
0d3714d4ee | ||
|
|
27566535d0 | ||
|
|
d2a9878ac5 | ||
|
|
02f90a00f3 | ||
|
|
c0c05d29c3 | ||
|
|
1338539bbd | ||
|
|
5ba4858979 | ||
|
|
2dd1f61827 | ||
|
|
95934b99d0 | ||
|
|
92dc7143fc | ||
|
|
232accb63c | ||
|
|
06c9110af2 | ||
|
|
26e7571028 | ||
|
|
3f9bc88753 | ||
|
|
d6838bcf88 | ||
|
|
d516564702 | ||
|
|
9c7899e79d | ||
|
|
7d6a678216 | ||
|
|
9ce38e5827 | ||
|
|
3356752a9b | ||
|
|
8a3538bede | ||
|
|
9a4243eddc | ||
|
|
0f7178477e | ||
|
|
b963bc4872 | ||
|
|
e602bb92f4 | ||
|
|
7252134856 | ||
|
|
e6429e9983 | ||
|
|
13d450145e | ||
|
|
c80a91e5a4 | ||
|
|
4ba1c53538 | ||
|
|
7ebd741406 | ||
|
|
1786e4c984 | ||
|
|
b604c38bf9 | ||
|
|
e24c4aa2c6 | ||
|
|
ce8e78e849 | ||
|
|
f3528caf18 | ||
|
|
f2c922d8df | ||
|
|
c7e4a55ad1 | ||
|
|
8b213da919 | ||
|
|
ad725c78d4 | ||
|
|
5bace25d4a | ||
|
|
27665e386c | ||
|
|
15923216e8 | ||
|
|
dfd289462a | ||
|
|
b7f5388889 | ||
|
|
02223dca63 | ||
|
|
0bb1ceef99 | ||
|
|
0db975e064 | ||
|
|
44880b208d | ||
|
|
e6b8ca257b | ||
|
|
c8e145fd51 | ||
|
|
23dfc84719 | ||
|
|
d53f2d8dc4 | ||
|
|
ca7575d728 | ||
|
|
2bcc6437d7 | ||
|
|
dbfa393444 | ||
|
|
676b16bff4 | ||
|
|
4de2624374 | ||
|
|
8e9bfd5584 | ||
|
|
fe3496597f | ||
|
|
de4a89dc47 | ||
|
|
45a9e0be65 | ||
|
|
2fe1a20831 | ||
|
|
52f26d93d0 | ||
|
|
a4822c6d34 | ||
|
|
547f01e910 | ||
|
|
5191b7d045 | ||
|
|
76d662c3f3 | ||
|
|
40ea21c3d2 | ||
|
|
a2e6236d47 | ||
|
|
83d888266a | ||
|
|
b3d5576d89 | ||
|
|
a7b9084f98 | ||
|
|
1d9e8db758 | ||
|
|
01fd86a3ea | ||
|
|
ebed948825 | ||
|
|
8534e78999 | ||
|
|
b57655b74f | ||
|
|
42beeb13d7 | ||
|
|
ce6fe6954c | ||
|
|
0ace3e499b | ||
|
|
7890c9ebe8 | ||
|
|
8fe2655c10 | ||
|
|
82a09c49af | ||
|
|
e46c0f41e9 | ||
|
|
de78e05c0a | ||
|
|
1eefb4a84a | ||
|
|
4d2ac8b636 | ||
|
|
72cdf87714 | ||
|
|
50cd57d3d4 | ||
|
|
80108c83b9 | ||
|
|
22d95d59b2 | ||
|
|
3a061d8eb6 | ||
|
|
b3bb6afb41 | ||
|
|
c98586b98d | ||
|
|
67702125b5 | ||
|
|
71924b1105 | ||
|
|
82e527fa68 | ||
|
|
ed5c5ca578 | ||
|
|
943794be53 | ||
|
|
d1b5a5afde | ||
|
|
f05ab3b474 | ||
|
|
357bddb5dd | ||
|
|
6771cfb6d8 | ||
|
|
fa9855e9d6 | ||
|
|
78705ea4ff | ||
|
|
232d6d7e11 | ||
|
|
dc800417fe | ||
|
|
ef529884e3 | ||
|
|
4428be3845 | ||
|
|
a71637cc48 | ||
|
|
d196786641 | ||
|
|
521024016b | ||
|
|
f1c35b4756 | ||
|
|
b2ce605dc6 | ||
|
|
94ad7fbec2 | ||
|
|
696e3818c7 | ||
|
|
238629c188 | ||
|
|
783b948cf2 | ||
|
|
89f3075481 | ||
|
|
1b2d32d939 | ||
|
|
d55ab684d9 | ||
|
|
af90978ca2 | ||
|
|
504460fa77 | ||
|
|
3b7f03f3d9 | ||
|
|
867df3cb64 | ||
|
|
59f5d8a74d | ||
|
|
a3e52273c2 | ||
|
|
7ce2c6a194 | ||
|
|
58e11661a9 | ||
|
|
b004681fed |
@@ -1,5 +0,0 @@
|
||||
[source.crates-io]
|
||||
replace-with = "vendored-sources"
|
||||
|
||||
[source.vendored-sources]
|
||||
directory = "vendor"
|
||||
@@ -1,37 +0,0 @@
|
||||
name: public-benchmark-pages
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [main-release-gate]
|
||||
types: [completed]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-public-benchmark-pages
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-pages
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install SSH client
|
||||
run: |
|
||||
if ! command -v ssh >/dev/null 2>&1; then
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
fi
|
||||
- name: Render measured benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py render
|
||||
- name: Publish public benchmark page
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
BENCH_PAGES_DEPLOY_KEY: ${{ secrets.BENCH_PAGES_DEPLOY_KEY }}
|
||||
run: python3 ci/publish-bench-pages.py os
|
||||
- name: Clean generated page
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -1,24 +0,0 @@
|
||||
name: completed-ci-badge
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [main-release-gate, next-build]
|
||||
types: [completed]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-completed-ci-badge
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-fast
|
||||
permissions:
|
||||
actions: read
|
||||
contents: write
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Publish last completed attempts
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/last-attempt-badge.py
|
||||
@@ -1,54 +0,0 @@
|
||||
name: source-pr
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
branches: [main, next]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-source-pr-${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
source:
|
||||
runs-on: alkane-fast
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Detect README-only change
|
||||
id: surface
|
||||
run: |
|
||||
surface=full
|
||||
if [ "$GITHUB_EVENT_NAME" = pull_request ] &&
|
||||
{ [ "$GITHUB_BASE_REF" = main ] || [ "$GITHUB_BASE_REF" = next ]; } &&
|
||||
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF" 2>/dev/null)" &&
|
||||
changed="$(git diff --name-only "$base" HEAD)" &&
|
||||
[ "$changed" = README.md ]; then
|
||||
surface=documentation
|
||||
fi
|
||||
echo "surface=$surface" >> "$GITHUB_OUTPUT"
|
||||
- name: Check README-only change
|
||||
if: steps.surface.outputs.surface == 'documentation'
|
||||
run: |
|
||||
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
|
||||
git diff --check "$base" HEAD
|
||||
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' --; then
|
||||
echo "private key material found in tracked source" >&2
|
||||
exit 1
|
||||
else
|
||||
status=$?
|
||||
[ "$status" -eq 1 ]
|
||||
fi
|
||||
- name: Check source
|
||||
if: steps.surface.outputs.surface != 'documentation'
|
||||
run: |
|
||||
rustup component add rustfmt
|
||||
cargo fmt --check
|
||||
cargo test --locked
|
||||
- name: Clean generated source check
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -1,129 +0,0 @@
|
||||
name: main-release-gate
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-main
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
verify-and-release:
|
||||
runs-on: alkane-ci
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
permissions:
|
||||
contents: write
|
||||
actions: write
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Install Pages SSH client
|
||||
run: |
|
||||
if ! command -v ssh >/dev/null 2>&1; then
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
fi
|
||||
- name: Install Rust quality tools
|
||||
run: rustup component add rustfmt clippy
|
||||
- name: Formatting
|
||||
run: cargo fmt --check
|
||||
- name: Last-attempt badge checks
|
||||
run: python3 ci/test-last-attempt-badge.py
|
||||
- name: Benchmark history checks
|
||||
run: python3 ci/test-bench-history.py
|
||||
- name: Metric badge checks
|
||||
run: python3 ci/test-metrics.py
|
||||
- name: Release evidence gate checks
|
||||
run: python3 ci/test-conformance.py
|
||||
- name: Release publication checks
|
||||
run: python3 ci/test-release.py
|
||||
- name: CI cleanup containment checks
|
||||
run: python3 ci/test-cleanup-generated.py
|
||||
- name: Quality
|
||||
run: |
|
||||
cargo clippy --all-targets --locked -- -D warnings
|
||||
printf '{"format":true,"clippy_warnings_denied":true}\n' > quality-current.json
|
||||
- name: Build
|
||||
run: cargo build --release --locked
|
||||
- name: Unit and workflow tests
|
||||
run: |
|
||||
set -o pipefail
|
||||
cargo test --locked 2>&1 | tee tests-current.txt
|
||||
- name: Microbenchmarks
|
||||
run: |
|
||||
set -o pipefail
|
||||
cargo test --release --locked -- --ignored --nocapture --test-threads=1 | tee bench-current.txt
|
||||
- name: Restore coverage tool
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: /root/.cargo/bin/cargo-llvm-cov
|
||||
key: cargo-llvm-cov-0.8.7-rust-1.97.1-${{ runner.os }}
|
||||
- name: Coverage tool
|
||||
run: |
|
||||
rustup component add llvm-tools-preview
|
||||
if [ "$(cargo llvm-cov --version 2>/dev/null || true)" != 'cargo-llvm-cov 0.8.7' ]; then
|
||||
cargo install --locked --force cargo-llvm-cov --version 0.8.7
|
||||
fi
|
||||
[ "$(cargo llvm-cov --version)" = 'cargo-llvm-cov 0.8.7' ]
|
||||
- name: Unit test coverage
|
||||
run: |
|
||||
mkdir -p coverage
|
||||
CARGO_TARGET_DIR=target/coverage-tests cargo llvm-cov --json \
|
||||
--output-path coverage/tests.json --locked
|
||||
- name: Microbenchmark coverage
|
||||
run: |
|
||||
CARGO_TARGET_DIR=target/coverage-bench cargo llvm-cov --json \
|
||||
--output-path coverage/bench.json --locked -- --ignored
|
||||
- name: Load previous main benchmark measurement
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py prepare
|
||||
- name: Generate measured badges
|
||||
run: |
|
||||
python3 ci/metrics.py --tests-output tests-current.txt \
|
||||
--tests-coverage coverage/tests.json --bench-output bench-current.txt \
|
||||
--bench-coverage coverage/bench.json --quality-gate quality-current.json
|
||||
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
|
||||
with:
|
||||
name: alkane-os-metrics
|
||||
path: |
|
||||
badges/metrics.json
|
||||
quality-current.json
|
||||
coverage/tests.json
|
||||
coverage/bench.json
|
||||
bench-current.txt
|
||||
- name: Publish measured badges privately
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/publish-metrics.py
|
||||
- name: Record private benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py publish
|
||||
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
|
||||
with:
|
||||
name: alkane-os-benchmark-site-preview
|
||||
path: bench-site/index.html
|
||||
- name: Pairing and simulator conformance
|
||||
run: python3 ci/check-conformance.py
|
||||
- name: Select release version
|
||||
id: version
|
||||
run: python3 ci/version.py main >> "$GITHUB_OUTPUT"
|
||||
- name: Package source and benchmark result
|
||||
if: steps.version.outputs.release == 'true'
|
||||
run: |
|
||||
mkdir -p dist
|
||||
git archive --format=tar.gz --output="dist/alkane-os-${{ steps.version.outputs.version }}-source.tar.gz" HEAD
|
||||
cp target/release/alkane-os dist/
|
||||
cp bench-current.txt dist/
|
||||
- name: Create private release
|
||||
if: steps.version.outputs.release == 'true'
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: python3 ci/release.py "${{ steps.version.outputs.tag }}" false "dist/alkane-os-${{ steps.version.outputs.version }}-source.tar.gz" dist/alkane-os dist/bench-current.txt
|
||||
- name: Clean generated build and benchmark work
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -1,39 +0,0 @@
|
||||
name: next-build
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [next]
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-next
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: alkane-fast
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Build release candidate
|
||||
run: cargo build --release --locked
|
||||
- name: Select candidate version
|
||||
id: version
|
||||
run: python3 ci/version.py next >> "$GITHUB_OUTPUT"
|
||||
- name: Package source and build output
|
||||
if: steps.version.outputs.release == 'true'
|
||||
run: |
|
||||
mkdir -p dist
|
||||
git archive --format=tar.gz --output="dist/alkane-os-${{ steps.version.outputs.version }}-source.tar.gz" HEAD
|
||||
cp target/release/alkane-os dist/
|
||||
- name: Create private prerelease
|
||||
if: steps.version.outputs.release == 'true'
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: python3 ci/release.py "${{ steps.version.outputs.tag }}" true "dist/alkane-os-${{ steps.version.outputs.version }}-source.tar.gz" dist/alkane-os
|
||||
- name: Clean generated candidate build
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -1,4 +0,0 @@
|
||||
/target/
|
||||
/dist/
|
||||
/coverage/
|
||||
__pycache__/
|
||||
@@ -1,7 +0,0 @@
|
||||
# Alkane OS working rules
|
||||
|
||||
- Keep the project MIT-licensed and preserve third-party licenses in vendored dependencies.
|
||||
- Use run-scoped Cargo output for one-off work. In CI, set `CARGO_TARGET_DIR=target` and remove generated target, coverage, benchmark, and release staging after artifact publication, including failed runs.
|
||||
- Keep the main release gate on all seven boards, all 64 same-vendor pairings, unmodified stock firmware evidence, and genuine pool acceptance from real captured silicon nonces. Do not promote host-only probes to board conformance.
|
||||
- Keep mining, tuning, HAL, API, protocol parsing, and on-device runtime logic in Rust. Use Python only for host tests, CI, release work, and disposable diagnostics unless a documented interface requires it.
|
||||
- No emojis in files or persisted text.
|
||||
@@ -1,105 +0,0 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "alkane-os"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.154"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "3.0.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
@@ -1,16 +0,0 @@
|
||||
[package]
|
||||
name = "alkane-os"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "MIT"
|
||||
description = "Portable mining and tuning core for Alkane control boards"
|
||||
|
||||
[lib]
|
||||
name = "alkane_os"
|
||||
|
||||
[dependencies]
|
||||
serde_json = { version = "=1.0.154", features = ["arbitrary_precision"] }
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
@@ -1,22 +0,0 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2026 BlueFlare
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
@@ -1,62 +1,3 @@
|
||||
# Alkane OS
|
||||
# CI badges
|
||||
|
||||
[](https://gitea.bluefla.re/blueflare/alkane-os/actions)
|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||
|
||||
Rust mining and tuning core for Alkane control boards. The
|
||||
[SDK](https://gitea.bluefla.re/blueflare/alkane-sdk) builds board images and
|
||||
provides the hardware backend. The miner has no on-board web frontend.
|
||||
|
||||
## Status
|
||||
|
||||
The host miner supports BM1362 and BM1366 through the SDK's simulator HAL and
|
||||
Stratum V1. Tests have replayed 33 captured BM1366 shares and one BM1362
|
||||
share to a loopback pool with matching ACCEPT responses. Production board
|
||||
control is still under development.
|
||||
|
||||
The HAL client requests PSU shutdown on sensor faults and reserves work IDs
|
||||
until a confirmed reset or shutdown. A production backend still needs a
|
||||
power lease, watchdog, and validated temperature limits. SHA-256d and
|
||||
Litecoin Scrypt proof verification are implemented; Scrypt chip report
|
||||
handling and mining remain open.
|
||||
|
||||
Run `alkane-os --list-targets` for the target matrix. Set `POOL_PASSWORD` to
|
||||
the pool password, then mine with a simulator HAL socket and Stratum V1 pool:
|
||||
|
||||
```sh
|
||||
ALKANE_POOL_PASSWORD="$POOL_PASSWORD" alkane-os --mine-simulator HAL_SOCKET POOL_ADDRESS WORKER BM1366
|
||||
```
|
||||
|
||||
Use `BM1362` for that chip. Set `ALKANE_API_LISTEN=127.0.0.1:4028` for
|
||||
read-only `summary` and `version` commands; reach it remotely through SSH.
|
||||
|
||||
## Release gate
|
||||
|
||||
`main` runs tests, benchmarks, and conformance before release; `next` builds
|
||||
release candidates. The release gate is red. It requires all 64 same-vendor
|
||||
pairings (52 Bitmain, 12 WhatsMiner), unmodified stock firmware, captured
|
||||
silicon nonces, difficulty-1 pool acceptance, and bench-validated models.
|
||||
Stock firmware may faithfully reject a pairing; Alkane OS must mine it.
|
||||
See the [evidence contract](ci/CONFORMANCE.md).
|
||||
|
||||
Badges cover host code, not board conformance. See the public
|
||||
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-benchmarks/os/).
|
||||
|
||||
## Local checks
|
||||
|
||||
```sh
|
||||
CARGO_TARGET_DIR=/var/tmp/alkane-os-target cargo test --locked
|
||||
```
|
||||
|
||||
Use an executable target directory if the source mount is `noexec`.
|
||||
|
||||
## License
|
||||
|
||||
[MIT](LICENSE). Vendored dependencies keep their own licenses.
|
||||
Machine-maintained status for the last completed main and next workflow attempts.
|
||||
|
||||
@@ -1 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="157" height="20" role="img" aria-label="bench coverage: 32.6%"><rect width="110" height="20" rx="3" fill="#555"/><rect x="110" width="47" height="20" rx="3" fill="#dfb317"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="55.0" y="14">bench coverage</text><text x="133.5" y="14">32.6%</text></g></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="157" height="20" role="img" aria-label="bench coverage: 11.0%"><rect width="110" height="20" rx="3" fill="#555"/><rect x="110" width="47" height="20" rx="3" fill="#dfb317"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="55.0" y="14">bench coverage</text><text x="133.5" y="14">11.0%</text></g></svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 397 B After Width: | Height: | Size: 397 B |
@@ -1 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="143" height="20" role="img" aria-label="bench: baseline set"><rect width="47" height="20" rx="3" fill="#555"/><rect x="47" width="96" height="20" rx="3" fill="#007ec6"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="23.5" y="14">bench</text><text x="95.0" y="14">baseline set</text></g></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="150" height="20" role="img" aria-label="bench: +0.0% vs prev"><rect width="47" height="20" rx="3" fill="#555"/><rect x="47" width="103" height="20" rx="3" fill="#007ec6"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="23.5" y="14">bench</text><text x="98.5" y="14">+0.0% vs prev</text></g></svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 390 B After Width: | Height: | Size: 393 B |
@@ -1 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="115" height="20" role="img" aria-label="coverage: 69.6%"><rect width="68" height="20" rx="3" fill="#555"/><rect x="68" width="47" height="20" rx="3" fill="#dfb317"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="34.0" y="14">coverage</text><text x="91.5" y="14">69.6%</text></g></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="115" height="20" role="img" aria-label="coverage: 85.7%"><rect width="68" height="20" rx="3" fill="#555"/><rect x="68" width="47" height="20" rx="3" fill="#4c1"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="34.0" y="14">coverage</text><text x="91.5" y="14">85.7%</text></g></svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 382 B After Width: | Height: | Size: 379 B |
@@ -1 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="115" height="20" role="img" aria-label="dependencies: 0"><rect width="96" height="20" rx="3" fill="#555"/><rect x="96" width="19" height="20" rx="3" fill="#007ec6"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="48.0" y="14">dependencies</text><text x="105.5" y="14">0</text></g></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="122" height="20" role="img" aria-label="dependencies: 60"><rect width="96" height="20" rx="3" fill="#555"/><rect x="96" width="26" height="20" rx="3" fill="#007ec6"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="48.0" y="14">dependencies</text><text x="109.0" y="14">60</text></g></svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 383 B After Width: | Height: | Size: 385 B |
@@ -1 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="136" height="20" role="img" aria-label="lines of code: 485"><rect width="103" height="20" rx="3" fill="#555"/><rect x="103" width="33" height="20" rx="3" fill="#007ec6"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="51.5" y="14">lines of code</text><text x="119.5" y="14">485</text></g></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="150" height="20" role="img" aria-label="lines of code: 20.4K"><rect width="103" height="20" rx="3" fill="#555"/><rect x="103" width="47" height="20" rx="3" fill="#007ec6"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="51.5" y="14">lines of code</text><text x="126.5" y="14">20.4K</text></g></svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 391 B After Width: | Height: | Size: 395 B |
@@ -1,14 +1,45 @@
|
||||
{
|
||||
"tests": 2,
|
||||
"line_coverage_pct": 69.6,
|
||||
"bench_coverage_pct": 32.6,
|
||||
"tests": 252,
|
||||
"line_coverage_pct": 85.7,
|
||||
"bench_coverage_pct": 11.0,
|
||||
"bench_ns_per_op": {
|
||||
"power_policy": 0.686,
|
||||
"target_matrix": 33.929
|
||||
"bm1362_commands": 118.822,
|
||||
"bm1362_job_encoding": 146.111,
|
||||
"bm1362_work_encoding": 143.098,
|
||||
"bm1366_captured_report_poll": 651.914,
|
||||
"bm1366_report_decode": 54.195,
|
||||
"bm1366_session_cycle": 178.176,
|
||||
"bm1366_work_encoding": 140.373,
|
||||
"bm13xx_crc16": 153.906,
|
||||
"bm13xx_crc5": 25.409,
|
||||
"difficulty_target": 330.048,
|
||||
"hal_socket_exchange": 15816.499,
|
||||
"power_policy": 0.478,
|
||||
"scrypt_share_verification": 193545.438,
|
||||
"share_verification": 554.416,
|
||||
"stratum_accept_parse": 184.312,
|
||||
"stratum_authorize_format": 288.78,
|
||||
"stratum_configure_format": 497.344,
|
||||
"stratum_configure_parse": 731.367,
|
||||
"stratum_control_parse": 275.494,
|
||||
"stratum_header": 2927.859,
|
||||
"stratum_job_issue": 1931.006,
|
||||
"stratum_notify_parse": 734.993,
|
||||
"stratum_socket_round_trip": 16695.255,
|
||||
"stratum_submission": 241.16,
|
||||
"stratum_subscribe_format": 243.119,
|
||||
"stratum_subscription_parse": 397.224,
|
||||
"target_matrix": 18.798
|
||||
},
|
||||
"bench_improvement_pct": null,
|
||||
"lines_of_code": 485,
|
||||
"dependencies": 0,
|
||||
"bench_improvement_pct": 0.01469655302288628,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 20375,
|
||||
"dependencies": 60,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
|
||||
@@ -1 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="66" height="20" role="img" aria-label="tests: 2"><rect width="47" height="20" rx="3" fill="#555"/><rect x="47" width="19" height="20" rx="3" fill="#4c1"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="23.5" y="14">tests</text><text x="56.5" y="14">2</text></g></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="80" height="20" role="img" aria-label="tests: 252"><rect width="47" height="20" rx="3" fill="#555"/><rect x="47" width="33" height="20" rx="3" fill="#4c1"/><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11"><text x="23.5" y="14">tests</text><text x="63.5" y="14">252</text></g></svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 364 B After Width: | Height: | Size: 368 B |
@@ -1,52 +0,0 @@
|
||||
# Release conformance evidence
|
||||
|
||||
`check-conformance.py` is a release gate for all 64 same-vendor cells. It
|
||||
currently fails because the simulator and bench evidence producer is not yet
|
||||
implemented. A green Rust build, host HAL replay probe, or rootfs archive does
|
||||
not fill any cell.
|
||||
|
||||
Each CI run must put a JSON report at
|
||||
`ci/evidence/<GITHUB_RUN_ID>/<board>/<chip>.json`. The report binds its
|
||||
`run_id`, `source_commit`, `os_binary_sha256`, `board`, and `chip` to the
|
||||
current workflow. It records `stock_firmware_modified: false`,
|
||||
`simulator_booted_stock: true`, and a `stock_result` of `mines` or `rejects`.
|
||||
For a rejection, `stock_first_rejection` names the first genuine firmware
|
||||
gate. Reports for stock mining also reference `stock_pool_accept_capture`.
|
||||
|
||||
The report references files under `ci/evidence/` with objects containing
|
||||
`path` and `sha256`: `sdk_image`, `stock_image`, `simulator_trace`,
|
||||
`simulator_model`, `control_capture`, `chip_capture`,
|
||||
`alkane_share_accept_capture`, and `bench_validation`.
|
||||
The checker opens and hashes each file. It loads the trace and capture JSON,
|
||||
checks the current run/image/cell identities, verifies SHA-256d or Litecoin
|
||||
Scrypt nonces against
|
||||
a pool target at difficulty 1 or higher, and requires a matching
|
||||
`mining.submit` and pool ACCEPT response ID. A SHA-256 capture must include
|
||||
the matching `subscription` (`extranonce1`, `extranonce2_size`), full
|
||||
`notify` message, exact decimal `difficulty`, and a `configure_response`
|
||||
with an accepted BIP310 mask when version bits were submitted. A later
|
||||
`version_mask_event` may supply the effective `mining.set_version_mask`.
|
||||
The checker reconstructs
|
||||
the coinbase, merkle root, and complete submitted header; its 80 bytes and
|
||||
calculated difficulty target must match the capture. The trace binds
|
||||
the capture digests.
|
||||
The Scrypt verifier uses [Litecoin's 80-byte, N=1024, r=1, p=1 proof hash](https://github.com/litecoin-project/litecoin/blob/master/src/crypto/scrypt.cpp).
|
||||
Equihash proof verification remains pending, so its cells fail closed.
|
||||
Scrypt cells also remain pending until real silicon reports, stock behavior,
|
||||
and pool acceptance are captured for those chips.
|
||||
Bench calibration names the physical control-board and chip devices, their
|
||||
capture digests, and the simulator model digest. It can be reused across OS
|
||||
commits until the model or a physical capture changes.
|
||||
The fixed digests and artifact paths also appear in `conformance.json` so
|
||||
source review can track what each cell claims.
|
||||
|
||||
The simulator runner must generate these reports by booting pristine stock
|
||||
firmware and Alkane OS in a machine model, with nonce data replayed from
|
||||
real-silicon captures. A rejected stock pairing must show its first rejection
|
||||
in the simulator trace while Alkane OS reaches pool ACCEPT. Bench devices
|
||||
provide independent observations for model validation, not CI dependencies.
|
||||
The checker verifies its input artifacts and reported nonce. It cannot prove
|
||||
that a self-asserted pool response came from a real pool or turn a report into
|
||||
physical evidence. The capture producer must preserve raw request/response
|
||||
bytes and independent provenance. Capture provenance and faithful machine
|
||||
models remain release blockers until the runner and bench validation are built.
|
||||
@@ -1,54 +0,0 @@
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Write small badge artifacts to the private Gitea CI badge branch."""
|
||||
|
||||
import base64
|
||||
import json
|
||||
from urllib.error import HTTPError
|
||||
from urllib.parse import quote
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
BADGE_BRANCH = "ci-badges"
|
||||
|
||||
|
||||
def request_json(url: str, token: str, method: str = "GET",
|
||||
payload: dict | None = None) -> dict:
|
||||
body = None if payload is None else json.dumps(payload).encode()
|
||||
request = Request(url, data=body, method=method,
|
||||
headers={"Authorization": f"token {token}",
|
||||
"Content-Type": "application/json"})
|
||||
with urlopen(request, timeout=20) as response:
|
||||
return json.load(response)
|
||||
|
||||
|
||||
def publish_file(api: str, repo: str, filename: str, data: bytes,
|
||||
token: str, message: str, max_bytes: int = 65_536) -> None:
|
||||
if not filename or filename.startswith("/") or any(
|
||||
part in ("", ".", "..") for part in filename.split("/")):
|
||||
raise ValueError("invalid badge path")
|
||||
if len(data) > max_bytes:
|
||||
raise ValueError("artifact exceeds size limit")
|
||||
path = f"{api}/repos/{repo}/contents/{quote(filename, safe='/')}"
|
||||
encoded = base64.b64encode(data).decode("ascii")
|
||||
for attempt in range(3):
|
||||
try:
|
||||
current = request_json(path + "?ref=" + BADGE_BRANCH, token)
|
||||
if base64.b64decode(current["content"]) == data:
|
||||
return
|
||||
sha = current["sha"]
|
||||
method = "PUT"
|
||||
except HTTPError as error:
|
||||
if error.code != 404:
|
||||
raise
|
||||
sha = None
|
||||
method = "POST"
|
||||
payload = {"branch": BADGE_BRANCH, "content": encoded,
|
||||
"message": message + " [skip ci]"}
|
||||
if sha is not None:
|
||||
payload["sha"] = sha
|
||||
try:
|
||||
request_json(path, token, method, payload)
|
||||
return
|
||||
except HTTPError as error:
|
||||
if error.code not in (409, 422) or attempt == 2:
|
||||
raise
|
||||
raise RuntimeError("badge write did not complete")
|
||||
@@ -1,159 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Keep measured main-branch benchmarks in the private CI artifact branch."""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
from datetime import datetime, timezone
|
||||
import html
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
from urllib.error import HTTPError
|
||||
from urllib.parse import quote
|
||||
|
||||
from badge_store import BADGE_BRANCH, publish_file, request_json
|
||||
from bench_host import identity as benchmark_host
|
||||
|
||||
INDEX = "history/index.json"
|
||||
MAX_INDEX_ENTRIES = 50
|
||||
|
||||
|
||||
def read_artifact(api: str, repo: str, token: str, filename: str):
|
||||
url = f"{api}/repos/{repo}/contents/{quote(filename, safe='/')}?ref={BADGE_BRANCH}"
|
||||
try:
|
||||
value = request_json(url, token)
|
||||
except HTTPError as error:
|
||||
if error.code == 404:
|
||||
return None
|
||||
raise
|
||||
return json.loads(base64.b64decode(value["content"]))
|
||||
|
||||
|
||||
def valid_benches(metrics: dict) -> dict[str, float]:
|
||||
values = metrics.get("bench_ns_per_op")
|
||||
if not isinstance(values, dict) or not values:
|
||||
raise ValueError("benchmark measurements are missing")
|
||||
if any(not isinstance(key, str) or not re.fullmatch(r"[A-Za-z0-9_]+", key)
|
||||
or not isinstance(value, (float, int)) or isinstance(value, bool)
|
||||
or not math.isfinite(value) or value <= 0 for key, value in values.items()):
|
||||
raise ValueError("benchmark measurements are invalid")
|
||||
return values
|
||||
|
||||
|
||||
def git_distance(ancestor: str, sha: str) -> int | None:
|
||||
result = subprocess.run(("git", "rev-list", "--count", f"{ancestor}..{sha}"),
|
||||
capture_output=True, text=True, check=False)
|
||||
if result.returncode != 0:
|
||||
return None
|
||||
ancestor_check = subprocess.run(("git", "merge-base", "--is-ancestor", ancestor, sha),
|
||||
capture_output=True, check=False)
|
||||
return int(result.stdout.strip()) if ancestor_check.returncode == 0 else None
|
||||
|
||||
|
||||
def previous_measurement(index: dict, sha: str, distance=None, host=None) -> dict:
|
||||
distance = distance or git_distance
|
||||
choices = []
|
||||
for entry in index.get("entries", []):
|
||||
ancestor = entry.get("sha")
|
||||
if ancestor == sha or not isinstance(ancestor, str):
|
||||
continue
|
||||
if host is not None and entry.get("metrics", {}).get("bench_host") != host:
|
||||
continue
|
||||
gap = distance(ancestor, sha)
|
||||
if gap is not None and gap > 0:
|
||||
choices.append((gap, entry))
|
||||
if not choices:
|
||||
return {}
|
||||
return valid_benches(min(choices, key=lambda item: item[0])[1]["metrics"])
|
||||
|
||||
|
||||
def updated_index(index: dict, sha: str, metrics: dict, timestamp: str) -> dict:
|
||||
if not re.fullmatch(r"[0-9a-f]{40}", sha):
|
||||
raise ValueError("invalid commit SHA")
|
||||
valid_benches(metrics)
|
||||
entries = [entry for entry in index.get("entries", []) if entry.get("sha") != sha]
|
||||
entries.append({"sha": sha, "timestamp": timestamp, "metrics": metrics})
|
||||
return {"schema": 1, "entries": entries[-MAX_INDEX_ENTRIES:]}
|
||||
|
||||
|
||||
def render_html(index: dict) -> str:
|
||||
entries = list(reversed(index.get("entries", [])))
|
||||
names = sorted({name for entry in entries
|
||||
for name in valid_benches(entry["metrics"])})
|
||||
rows = []
|
||||
for entry in entries:
|
||||
sha = entry["sha"]
|
||||
if not re.fullmatch(r"[0-9a-f]{40}", sha):
|
||||
raise ValueError("invalid commit SHA in history")
|
||||
cells = [f'<td><a href="https://gitea.bluefla.re/blueflare/alkane-os/commit/{sha}">{sha[:10]}</a></td>',
|
||||
f'<td>{html.escape(entry["timestamp"])}</td>']
|
||||
values = valid_benches(entry["metrics"])
|
||||
host = entry["metrics"].get("bench_host", {})
|
||||
host_label = host.get("cpu_model", "unknown") if isinstance(host, dict) else "unknown"
|
||||
cells.append(f'<td>{html.escape(str(host_label))}</td>')
|
||||
cells += [f'<td>{values[name]:.3f}</td>' if name in values else '<td>new</td>'
|
||||
for name in names]
|
||||
rows.append("<tr>" + "".join(cells) + "</tr>")
|
||||
headings = "".join(f"<th scope=\"col\">{html.escape(name)} (ns/op)</th>" for name in names)
|
||||
return ("<!doctype html>\n<html lang=\"en\"><head><meta charset=\"utf-8\">"
|
||||
"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">"
|
||||
"<title>Alkane OS benchmarks</title><style>"
|
||||
"body{font:16px system-ui,sans-serif;max-width:1100px;margin:2rem auto;padding:0 1rem;color:#17212b}"
|
||||
"h1{font-size:2rem}p{max-width:70ch;line-height:1.5}"
|
||||
"table{border-collapse:collapse;min-width:100%}th,td{padding:.5rem;border-bottom:1px solid #ccd3da;text-align:right}"
|
||||
"th:first-child,td:first-child{text-align:left}th:nth-child(2),td:nth-child(2){text-align:left}"
|
||||
"th{background:#edf2f6;position:sticky;top:0}a{color:#145a9a}"
|
||||
".scroll{overflow-x:auto}small{color:#55616d}</style></head><body>"
|
||||
"<h1>Alkane OS microbenchmarks</h1>"
|
||||
"<p>Measured on main CI. Lower ns/op is faster. Results depend on runner load and are "
|
||||
"not board performance. A new benchmark has no earlier comparison.</p>"
|
||||
f"<p><small>Most recent {len(entries)} measured commits. Full per-commit JSON is retained "
|
||||
"in the private ci-badges branch.</small></p>"
|
||||
f"<div class=\"scroll\"><table><thead><tr><th scope=\"col\">Commit</th>"
|
||||
f"<th scope=\"col\">UTC</th><th scope=\"col\">CPU</th>{headings}</tr></thead><tbody>{''.join(rows)}"
|
||||
"</tbody></table></div></body></html>\n")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("action", choices=("prepare", "publish", "render"))
|
||||
args = parser.parse_args()
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
sha = os.environ["GITHUB_SHA"]
|
||||
index = read_artifact(api, repo, token, INDEX) or {"schema": 1, "entries": []}
|
||||
if index.get("schema") != 1 or not isinstance(index.get("entries"), list):
|
||||
raise ValueError("unsupported benchmark history index")
|
||||
if args.action == "prepare":
|
||||
baseline = previous_measurement(index, sha, host=benchmark_host())
|
||||
Path("badges").mkdir(exist_ok=True)
|
||||
Path("badges/bench-baseline.json").write_text(json.dumps(baseline) + "\n")
|
||||
print(f"Loaded {len(baseline)} prior benchmark measurements")
|
||||
return
|
||||
if args.action == "render":
|
||||
if not index["entries"]:
|
||||
raise ValueError("no measured benchmark history to publish")
|
||||
Path("bench-site").mkdir(exist_ok=True)
|
||||
Path("bench-site/index.html").write_text(render_html(index))
|
||||
print(f"Rendered {len(index['entries'])} measured benchmark commits")
|
||||
return
|
||||
metrics = json.loads(Path("badges/metrics.json").read_text())
|
||||
timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
|
||||
index = updated_index(index, sha, metrics, timestamp)
|
||||
record = json.dumps(index["entries"][-1], indent=2).encode() + b"\n"
|
||||
publish_file(api, repo, f"history/{sha}.json", record, token,
|
||||
"Record Alkane OS benchmarks", max_bytes=1_048_576)
|
||||
publish_file(api, repo, INDEX, json.dumps(index, indent=2).encode() + b"\n",
|
||||
token, "Update Alkane OS benchmark index", max_bytes=1_048_576)
|
||||
Path("bench-site").mkdir(exist_ok=True)
|
||||
Path("bench-site/index.html").write_text(render_html(index))
|
||||
print(f"Recorded benchmarks for {sha[:10]}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,19 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Identify the CPU class used for comparable CI microbenchmark baselines."""
|
||||
|
||||
import os
|
||||
import platform
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def identity() -> dict[str, object]:
|
||||
model = "unknown"
|
||||
cpuinfo = Path("/proc/cpuinfo")
|
||||
if cpuinfo.is_file():
|
||||
for line in cpuinfo.read_text(errors="replace").splitlines():
|
||||
if line.startswith(("model name\t", "Hardware\t", "Processor\t")):
|
||||
model = line.partition(":")[2].strip()[:160]
|
||||
break
|
||||
return {"architecture": platform.machine(), "cpu_model": model,
|
||||
"logical_cpus": os.cpu_count() or 1}
|
||||
@@ -1,401 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Require the binary target matrix and traceable per-cell release evidence."""
|
||||
|
||||
import argparse
|
||||
from decimal import Decimal, InvalidOperation
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
|
||||
REQUIRED_BOARDS = {
|
||||
"am335x-bb": "bitmain",
|
||||
"zynq-7010": "bitmain",
|
||||
"cv1835": "bitmain",
|
||||
"a113d": "bitmain",
|
||||
"allwinner-h3": "whatsminer",
|
||||
"allwinner-h6": "whatsminer",
|
||||
"allwinner-h616": "whatsminer",
|
||||
}
|
||||
REQUIRED_CHIPS = {
|
||||
**{chip: "bitmain" for chip in (
|
||||
"BM1384", "BM1387", "BM1360", "BM1362", "BM1366", "BM1368",
|
||||
"BM1370", "BM1396", "BM1397", "BM1398", "BM1489", "BM1491", "BM1746",
|
||||
)},
|
||||
**{chip: "whatsminer" for chip in (
|
||||
"KF1950", "ID-1968", "ID-1980", "ID-1990",
|
||||
)},
|
||||
}
|
||||
REQUIRED_ALGORITHMS = {
|
||||
**{chip: "Sha256" for chip in REQUIRED_CHIPS if chip not in
|
||||
("BM1489", "BM1491", "BM1746")},
|
||||
"BM1489": "Scrypt", "BM1491": "Scrypt", "BM1746": "Equihash",
|
||||
}
|
||||
DIGEST = re.compile(r"[0-9a-f]{64}\Z")
|
||||
COMMIT = re.compile(r"[0-9a-f]{40}\Z")
|
||||
DIFF_ONE_TARGET = 0xffff << (8 * (0x1d - 3))
|
||||
MAX_REPORT_BYTES = 1_048_576
|
||||
|
||||
|
||||
def sha256_file(path: pathlib.Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as source:
|
||||
for chunk in iter(lambda: source.read(1_048_576), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def load_report(path: pathlib.Path) -> dict:
|
||||
if path.stat().st_size > MAX_REPORT_BYTES:
|
||||
raise ValueError("evidence report exceeds 1 MiB")
|
||||
value = json.loads(path.read_text())
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError("evidence report is not an object")
|
||||
return value
|
||||
|
||||
|
||||
def artifact(root: pathlib.Path, value: object) -> pathlib.Path:
|
||||
if not isinstance(value, dict) or not isinstance(value.get("path"), str):
|
||||
raise ValueError("artifact reference is missing")
|
||||
digest = value.get("sha256")
|
||||
if not isinstance(digest, str) or not DIGEST.fullmatch(digest):
|
||||
raise ValueError("artifact digest is invalid")
|
||||
path = (root / value["path"]).resolve()
|
||||
if not path.is_relative_to(root.resolve()) or not path.is_file():
|
||||
raise ValueError("artifact is missing or outside evidence directory")
|
||||
if sha256_file(path) != digest:
|
||||
raise ValueError("artifact digest mismatch")
|
||||
return path
|
||||
|
||||
|
||||
def hex_field(value: object, size: int | None = None) -> bytes:
|
||||
if (not isinstance(value, str) or len(value) & 1
|
||||
or len(value) > 131_072 or not re.fullmatch(r"[0-9a-fA-F]*", value)
|
||||
or (size is not None and len(value) != size * 2)):
|
||||
raise ValueError("invalid Stratum hex field")
|
||||
return bytes.fromhex(value)
|
||||
|
||||
|
||||
def u32_hex(value: object) -> int:
|
||||
return int.from_bytes(hex_field(value, 4), "big")
|
||||
|
||||
|
||||
def reconstructed_header(capture: dict, params: list[str]) -> tuple[bytes, int]:
|
||||
subscription = capture.get("subscription")
|
||||
notify = capture.get("notify")
|
||||
if not isinstance(subscription, dict) or not isinstance(notify, dict):
|
||||
raise ValueError("subscription and notify are required to bind the share")
|
||||
extra1 = hex_field(subscription.get("extranonce1"))
|
||||
extra_size = subscription.get("extranonce2_size")
|
||||
if (len(extra1) > 32 or type(extra_size) is not int
|
||||
or not 0 <= extra_size <= 32):
|
||||
raise ValueError("invalid subscription extranonce")
|
||||
extra2 = hex_field(params[2], extra_size)
|
||||
job = notify.get("params")
|
||||
if (notify.get("method") != "mining.notify" or not isinstance(job, list)
|
||||
or len(job) != 9 or job[0] != params[1]
|
||||
or not isinstance(job[4], list) or len(job[4]) > 64
|
||||
or type(job[8]) is not bool):
|
||||
raise ValueError("submission is not bound to a matching notify")
|
||||
prevhash = hex_field(job[1], 32)
|
||||
coinbase = hex_field(job[2]) + extra1 + extra2 + hex_field(job[3])
|
||||
if len(coinbase) > 65_536:
|
||||
raise ValueError("coinbase exceeds supported size")
|
||||
root = hashlib.sha256(hashlib.sha256(coinbase).digest()).digest()
|
||||
for branch in job[4]:
|
||||
pair = root + hex_field(branch, 32)
|
||||
root = hashlib.sha256(hashlib.sha256(pair).digest()).digest()
|
||||
base_version = u32_hex(job[5])
|
||||
nbits = u32_hex(job[6])
|
||||
u32_hex(job[7])
|
||||
submitted_ntime = u32_hex(params[3])
|
||||
submitted_nonce = u32_hex(params[4])
|
||||
if len(params) == 6:
|
||||
configure = capture.get("configure_response")
|
||||
result = configure.get("result") if isinstance(configure, dict) else None
|
||||
if not isinstance(result, dict) or result.get("version-rolling") is not True:
|
||||
raise ValueError("version rolling was not negotiated")
|
||||
mask_text = result.get("version-rolling.mask")
|
||||
mask_event = capture.get("version_mask_event")
|
||||
if mask_event is not None:
|
||||
fields = mask_event.get("params") if isinstance(mask_event, dict) else None
|
||||
if (not isinstance(mask_event, dict)
|
||||
or mask_event.get("method") != "mining.set_version_mask"
|
||||
or not isinstance(fields, list) or len(fields) != 1):
|
||||
raise ValueError("invalid effective version mask event")
|
||||
mask_text = fields[0]
|
||||
mask = u32_hex(mask_text)
|
||||
bits = u32_hex(params[5])
|
||||
if bits & ~mask:
|
||||
raise ValueError("submitted version bits exceed negotiated mask")
|
||||
version = (base_version & ~mask) | bits
|
||||
else:
|
||||
if capture.get("configure_response") is not None or capture.get("version_mask_event") is not None:
|
||||
raise ValueError("negotiated version mask requires submission bits")
|
||||
version = base_version
|
||||
header = bytearray()
|
||||
header.extend(version.to_bytes(4, "little"))
|
||||
for offset in range(0, 32, 4):
|
||||
header.extend(prevhash[offset:offset + 4][::-1])
|
||||
header.extend(root)
|
||||
header.extend(submitted_ntime.to_bytes(4, "little"))
|
||||
header.extend(nbits.to_bytes(4, "little"))
|
||||
header.extend(submitted_nonce.to_bytes(4, "little"))
|
||||
return bytes(header), submitted_nonce
|
||||
|
||||
|
||||
def proof_digest(header: bytes, algorithm: str) -> bytes:
|
||||
if algorithm == "Sha256":
|
||||
return hashlib.sha256(hashlib.sha256(header).digest()).digest()
|
||||
if algorithm == "Scrypt":
|
||||
return hashlib.scrypt(header, salt=header, n=1024, r=1, p=1, dklen=32)
|
||||
raise ValueError(f"{algorithm} share verifier is not implemented")
|
||||
|
||||
|
||||
def verify_accept(capture: dict, algorithm: str) -> None:
|
||||
if algorithm not in ("Sha256", "Scrypt"):
|
||||
raise ValueError(f"{algorithm} share verifier is not implemented")
|
||||
if capture.get("nonce_source") != "real_silicon_capture":
|
||||
raise ValueError("share was not sourced from captured silicon")
|
||||
header_hex = capture.get("header80")
|
||||
target_hex = capture.get("pool_target_le")
|
||||
nonce = capture.get("nonce")
|
||||
if (not isinstance(header_hex, str) or len(header_hex) != 160
|
||||
or not isinstance(target_hex, str) or not DIGEST.fullmatch(target_hex)
|
||||
or type(nonce) is not int or not 0 <= nonce <= 0xffffffff):
|
||||
raise ValueError("invalid accepted share work")
|
||||
try:
|
||||
header = bytearray.fromhex(header_hex)
|
||||
except ValueError as error:
|
||||
raise ValueError("invalid accepted share header") from error
|
||||
if int.from_bytes(header[76:80], "little") != nonce:
|
||||
raise ValueError("nonce differs from submitted header")
|
||||
submission = capture.get("submission")
|
||||
response = capture.get("pool_response")
|
||||
params = submission.get("params") if isinstance(submission, dict) else None
|
||||
if (not isinstance(params, list) or len(params) not in (5, 6)
|
||||
or not all(isinstance(value, str) for value in params)
|
||||
or not params[0] or not params[1]
|
||||
or params[3].lower() != f"{int.from_bytes(header[68:72], 'little'):08x}"
|
||||
or params[4].lower() != f"{nonce:08x}"
|
||||
or (len(params) == 6 and not re.fullmatch(r"[0-9a-f]{8}", params[5].lower()))
|
||||
or not isinstance(response, dict)
|
||||
or submission.get("method") != "mining.submit"
|
||||
or type(submission.get("id")) is not int
|
||||
or response.get("id") != submission["id"]
|
||||
or response.get("result") is not True
|
||||
or response.get("error") is not None):
|
||||
raise ValueError("no matching pool ACCEPT for submitted nonce")
|
||||
target = int.from_bytes(bytes.fromhex(target_hex), "little")
|
||||
if not 0 < target <= DIFF_ONE_TARGET:
|
||||
raise ValueError("pool target is below difficulty one")
|
||||
difficulty_text = capture.get("difficulty")
|
||||
if not isinstance(difficulty_text, str) or len(difficulty_text) > 128:
|
||||
raise ValueError("effective pool difficulty is missing")
|
||||
try:
|
||||
difficulty = Decimal(difficulty_text)
|
||||
except InvalidOperation as error:
|
||||
raise ValueError("invalid pool difficulty") from error
|
||||
if not difficulty.is_finite() or difficulty < 1:
|
||||
raise ValueError("pool difficulty is below one")
|
||||
if abs(difficulty.as_tuple().exponent) > 64:
|
||||
raise ValueError("pool difficulty exceeds supported range")
|
||||
numerator, denominator = difficulty.as_integer_ratio()
|
||||
expected_target = DIFF_ONE_TARGET * denominator // numerator
|
||||
if target != expected_target:
|
||||
raise ValueError("pool target differs from effective difficulty")
|
||||
rebuilt, submitted_nonce = reconstructed_header(capture, params)
|
||||
if submitted_nonce != nonce or rebuilt != header:
|
||||
raise ValueError("submitted Stratum job differs from captured header")
|
||||
hash_bytes = proof_digest(header, algorithm)
|
||||
if int.from_bytes(hash_bytes, "little") > target:
|
||||
raise ValueError("captured nonce misses the pool target")
|
||||
|
||||
|
||||
def verify_cell(row: dict, root: pathlib.Path, run_id: str,
|
||||
source_commit: str, binary_digest: str,
|
||||
algorithm: str) -> None:
|
||||
board, chip = row["board"], row["chip"]
|
||||
report_path = (root / run_id / board / f"{chip}.json").resolve()
|
||||
if not report_path.is_relative_to(root.resolve()):
|
||||
raise ValueError("evidence report is outside evidence directory")
|
||||
report = load_report(report_path)
|
||||
identity = {"schema": 1, "run_id": run_id, "source_commit": source_commit,
|
||||
"os_binary_sha256": binary_digest, "board": board, "chip": chip,
|
||||
"stock_firmware_modified": False, "algorithm": algorithm}
|
||||
if any(report.get(key) != value for key, value in identity.items()):
|
||||
raise ValueError("evidence belongs to a different run, source, binary, or cell")
|
||||
if report.get("stock_result") != row.get("stock_result"):
|
||||
raise ValueError("stock result differs from manifest")
|
||||
if report.get("stock_first_rejection") != row.get("stock_first_rejection"):
|
||||
raise ValueError("stock rejection differs from manifest")
|
||||
if report["stock_result"] == "rejects" and not report.get("stock_first_rejection"):
|
||||
raise ValueError("stock rejection gate is missing")
|
||||
if report.get("simulator_booted_stock") is not True:
|
||||
raise ValueError("unmodified stock boot is unverified")
|
||||
paths = {}
|
||||
for field, digest_field in (("sdk_image", "sdk_image_sha256"),
|
||||
("stock_image", "stock_image_sha256"),
|
||||
("simulator_trace", "simulator_trace_sha256")):
|
||||
paths[field] = artifact(root, report.get(field))
|
||||
if report[field]["sha256"] != row.get(digest_field):
|
||||
raise ValueError(f"{field} digest differs from manifest")
|
||||
artifact(root, report.get("simulator_model"))
|
||||
model_digest = report["simulator_model"]["sha256"]
|
||||
for field in ("control_capture", "chip_capture"):
|
||||
artifact(root, report.get(field))
|
||||
trace = load_report(paths["simulator_trace"])
|
||||
trace_identity = {"run_id": run_id, "source_commit": source_commit,
|
||||
"board": board, "chip": chip,
|
||||
"sdk_image_sha256": row["sdk_image_sha256"],
|
||||
"stock_image_sha256": row["stock_image_sha256"],
|
||||
"stock_firmware_modified": False,
|
||||
"stock_result": row["stock_result"],
|
||||
"algorithm": algorithm,
|
||||
"simulator_model_sha256": model_digest}
|
||||
if any(trace.get(key) != value for key, value in trace_identity.items()):
|
||||
raise ValueError("simulator trace does not bind stock image and current run")
|
||||
if report["stock_result"] == "rejects":
|
||||
if trace.get("first_rejection") != row["stock_first_rejection"]:
|
||||
raise ValueError("stock rejection gate is absent from simulator trace")
|
||||
else:
|
||||
stock_capture = load_report(artifact(root, report.get("stock_pool_accept_capture")))
|
||||
if trace.get("stock_pool_accept_capture_sha256") != report["stock_pool_accept_capture"]["sha256"]:
|
||||
raise ValueError("stock pool acceptance is not linked to simulator trace")
|
||||
if (stock_capture.get("board") != board or stock_capture.get("chip") != chip
|
||||
or stock_capture.get("firmware") != "stock"):
|
||||
raise ValueError("stock pool acceptance belongs to another firmware or cell")
|
||||
verify_accept(stock_capture, algorithm)
|
||||
capture = load_report(artifact(root, report.get("alkane_share_accept_capture")))
|
||||
if report["alkane_share_accept_capture"]["path"] != row.get("alkane_share_accept_capture"):
|
||||
raise ValueError("accepted share artifact differs from manifest")
|
||||
if trace.get("alkane_share_accept_capture_sha256") != report["alkane_share_accept_capture"]["sha256"]:
|
||||
raise ValueError("Alkane pool acceptance is not linked to simulator trace")
|
||||
if (capture.get("board") != board or capture.get("chip") != chip
|
||||
or capture.get("firmware") != "alkane"):
|
||||
raise ValueError("accepted share belongs to another cell")
|
||||
verify_accept(capture, algorithm)
|
||||
bench = load_report(artifact(root, report.get("bench_validation")))
|
||||
if report["bench_validation"]["path"] != row.get("bench_validation"):
|
||||
raise ValueError("bench artifact differs from manifest")
|
||||
if (bench.get("board") != board or bench.get("chip") != chip
|
||||
or bench.get("validated") is not True
|
||||
or bench.get("simulator_model_sha256") != model_digest
|
||||
or any(bench.get(f"{field}_sha256") != report[field]["sha256"]
|
||||
for field in ("control_capture", "chip_capture"))
|
||||
or any(not isinstance(bench.get(f"{name}_device_id"), str)
|
||||
or not bench[f"{name}_device_id"]
|
||||
for name in ("control", "chip"))):
|
||||
raise ValueError("bench validation is missing or belongs to another cell")
|
||||
|
||||
|
||||
def binary_targets(path: pathlib.Path) -> dict[tuple[str, str], str]:
|
||||
output = subprocess.run(
|
||||
[str(path), "--list-targets"],
|
||||
check=True, capture_output=True, text=True, timeout=15,
|
||||
).stdout.splitlines()
|
||||
if not output or output[0] != "control_board,hash_chip,algorithm":
|
||||
raise ValueError("Alkane OS binary has no target matrix header")
|
||||
targets = {}
|
||||
for line in output[1:]:
|
||||
parts = line.split(",")
|
||||
if len(parts) != 3 or not all(parts):
|
||||
raise ValueError(f"invalid binary target row: {line!r}")
|
||||
cell = (parts[0], parts[1])
|
||||
if cell in targets:
|
||||
raise ValueError("duplicate binary target")
|
||||
targets[cell] = parts[2]
|
||||
return targets
|
||||
|
||||
|
||||
def validate(manifest: dict, built_targets: dict[tuple[str, str], str],
|
||||
evidence_root: pathlib.Path = pathlib.Path("ci/evidence"),
|
||||
run_id: str = "", source_commit: str = "",
|
||||
binary_digest: str = "") -> list[str]:
|
||||
errors = []
|
||||
if manifest.get("schema") != 1:
|
||||
errors.append("unsupported conformance manifest schema")
|
||||
boards = set(manifest["boards"])
|
||||
chips = set(manifest["chips"])
|
||||
vendors = manifest["vendors"]
|
||||
if len(boards) != len(manifest["boards"]) or len(chips) != len(manifest["chips"]):
|
||||
errors.append("duplicate board or chip in manifest")
|
||||
for name, vendor in {**REQUIRED_BOARDS, **REQUIRED_CHIPS}.items():
|
||||
if name not in boards | chips or vendors.get(name) != vendor:
|
||||
errors.append(f"required target identity changed: {name}")
|
||||
if set(vendors) != boards | chips:
|
||||
errors.append("vendor map differs from board and chip lists")
|
||||
expected = {(board, chip) for board in boards for chip in chips
|
||||
if vendors.get(board) == vendors.get(chip)}
|
||||
rows = manifest["targets"]
|
||||
actual = {(row["board"], row["chip"]) for row in rows}
|
||||
if len(expected) < 64 or actual != expected or len(rows) != len(expected):
|
||||
errors.append(f"manifest matrix mismatch: {len(actual)} present, {len(expected)} expected")
|
||||
if set(built_targets) != expected:
|
||||
errors.append(f"binary matrix mismatch: {len(built_targets)} built, {len(expected)} expected")
|
||||
for (board, chip), algorithm in built_targets.items():
|
||||
if chip in REQUIRED_ALGORITHMS and algorithm != REQUIRED_ALGORITHMS[chip]:
|
||||
errors.append(f"binary algorithm mismatch: {board} x {chip}")
|
||||
if (not run_id.isdecimal() or not COMMIT.fullmatch(source_commit)
|
||||
or not DIGEST.fullmatch(binary_digest)):
|
||||
errors.append("current run, source commit, or binary digest is unbound")
|
||||
required = ("sdk_image_sha256", "stock_image_sha256", "stock_result",
|
||||
"alkane_share_accept_capture", "simulator_trace_sha256",
|
||||
"bench_validation")
|
||||
for row in rows:
|
||||
cell = f"{row['board']} x {row['chip']}"
|
||||
missing = [field for field in required if not row.get(field)]
|
||||
if row.get("stock_result") not in (None, "mines", "rejects"):
|
||||
missing.append("stock_result invalid")
|
||||
if row.get("stock_result") == "rejects" and not row.get("stock_first_rejection"):
|
||||
missing.append("stock_first_rejection")
|
||||
for field in ("sdk_image_sha256", "stock_image_sha256", "simulator_trace_sha256"):
|
||||
value = row.get(field)
|
||||
if value and (not isinstance(value, str) or not DIGEST.fullmatch(value)):
|
||||
missing.append(f"{field} invalid")
|
||||
if missing:
|
||||
errors.append(f"{cell}: {', '.join(missing)}")
|
||||
elif run_id.isdecimal() and COMMIT.fullmatch(source_commit) and DIGEST.fullmatch(binary_digest):
|
||||
try:
|
||||
verify_cell(row, evidence_root, run_id, source_commit, binary_digest,
|
||||
built_targets.get((row["board"], row["chip"]), "unknown"))
|
||||
except (OSError, ValueError, KeyError, TypeError, json.JSONDecodeError) as error:
|
||||
errors.append(f"{cell}: evidence invalid: {error}")
|
||||
return errors
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--manifest", type=pathlib.Path,
|
||||
default=pathlib.Path("ci/conformance.json"))
|
||||
parser.add_argument("--binary", type=pathlib.Path,
|
||||
default=pathlib.Path(os.environ.get("CARGO_TARGET_DIR", "target"))
|
||||
/ "release/alkane-os")
|
||||
parser.add_argument("--evidence-dir", type=pathlib.Path,
|
||||
default=pathlib.Path("ci/evidence"))
|
||||
parser.add_argument("--run-id", default=os.environ.get("GITHUB_RUN_ID", ""))
|
||||
args = parser.parse_args()
|
||||
manifest = json.loads(args.manifest.read_text())
|
||||
try:
|
||||
built_targets = binary_targets(args.binary.resolve())
|
||||
except (OSError, subprocess.SubprocessError, ValueError) as error:
|
||||
sys.exit(f"cannot verify Alkane OS binary target matrix: {error}")
|
||||
source_commit = subprocess.run(["git", "rev-parse", "HEAD"], check=True,
|
||||
capture_output=True, text=True).stdout.strip()
|
||||
errors = validate(manifest, built_targets, args.evidence_dir, args.run_id,
|
||||
source_commit, sha256_file(args.binary.resolve()))
|
||||
if errors:
|
||||
print(f"Conformance pending: {len(errors)} issues across {len(manifest['targets'])} targets")
|
||||
for error in errors[:8]:
|
||||
print(f" {error}")
|
||||
sys.exit(1)
|
||||
print(f"Conformance complete: {len(manifest['targets'])} targets")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,42 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Remove generated Alkane OS CI files after tests and release upload."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DIRECTORIES = ("target", "coverage", "dist", "bench-site")
|
||||
FILES = ("tests-current.txt", "bench-current.txt", "quality-current.json")
|
||||
|
||||
|
||||
def cleanup() -> None:
|
||||
if not os.environ.get("GITHUB_RUN_ID"):
|
||||
raise ValueError("cleanup is restricted to CI runs")
|
||||
for name in DIRECTORIES:
|
||||
path = ROOT / name
|
||||
if path.is_symlink() or path.parent.resolve() != ROOT.resolve():
|
||||
raise ValueError(f"unsafe generated directory: {path}")
|
||||
if path.is_dir():
|
||||
shutil.rmtree(path)
|
||||
print(f"Removed generated directory: {name}")
|
||||
elif path.exists():
|
||||
raise ValueError(f"expected a generated directory: {path}")
|
||||
for name in FILES:
|
||||
path = ROOT / name
|
||||
if path.is_symlink() or path.parent.resolve() != ROOT.resolve():
|
||||
raise ValueError(f"unsafe generated file: {path}")
|
||||
if path.is_file():
|
||||
path.unlink()
|
||||
print(f"Removed generated file: {name}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
cleanup()
|
||||
except (OSError, ValueError) as error:
|
||||
print(f"ERROR: Alkane OS cleanup: {error}", file=sys.stderr)
|
||||
raise SystemExit(1)
|
||||
@@ -1,763 +0,0 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"boards": [
|
||||
"am335x-bb",
|
||||
"zynq-7010",
|
||||
"cv1835",
|
||||
"a113d",
|
||||
"allwinner-h3",
|
||||
"allwinner-h6",
|
||||
"allwinner-h616"
|
||||
],
|
||||
"chips": [
|
||||
"BM1384",
|
||||
"BM1387",
|
||||
"BM1360",
|
||||
"BM1362",
|
||||
"BM1366",
|
||||
"BM1368",
|
||||
"BM1370",
|
||||
"BM1396",
|
||||
"BM1397",
|
||||
"BM1398",
|
||||
"BM1489",
|
||||
"BM1491",
|
||||
"BM1746",
|
||||
"KF1950",
|
||||
"ID-1968",
|
||||
"ID-1980",
|
||||
"ID-1990"
|
||||
],
|
||||
"vendors": {
|
||||
"am335x-bb": "bitmain",
|
||||
"zynq-7010": "bitmain",
|
||||
"cv1835": "bitmain",
|
||||
"a113d": "bitmain",
|
||||
"allwinner-h3": "whatsminer",
|
||||
"allwinner-h6": "whatsminer",
|
||||
"allwinner-h616": "whatsminer",
|
||||
"BM1384": "bitmain",
|
||||
"BM1387": "bitmain",
|
||||
"BM1360": "bitmain",
|
||||
"BM1362": "bitmain",
|
||||
"BM1366": "bitmain",
|
||||
"BM1368": "bitmain",
|
||||
"BM1370": "bitmain",
|
||||
"BM1396": "bitmain",
|
||||
"BM1397": "bitmain",
|
||||
"BM1398": "bitmain",
|
||||
"BM1489": "bitmain",
|
||||
"BM1491": "bitmain",
|
||||
"BM1746": "bitmain",
|
||||
"KF1950": "whatsminer",
|
||||
"ID-1968": "whatsminer",
|
||||
"ID-1980": "whatsminer",
|
||||
"ID-1990": "whatsminer"
|
||||
},
|
||||
"targets": [
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1384",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1387",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1360",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1362",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1366",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1368",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1370",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1396",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1397",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1398",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1489",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1491",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "am335x-bb",
|
||||
"chip": "BM1746",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1384",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1387",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1360",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1362",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1366",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1368",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1370",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1396",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1397",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1398",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1489",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1491",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1746",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1384",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1387",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1360",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1362",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1366",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1368",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1370",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1396",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1397",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1398",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1489",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1491",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "cv1835",
|
||||
"chip": "BM1746",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1384",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1387",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1360",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1362",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1366",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1368",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1370",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1396",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1397",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1398",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1489",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1491",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1746",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h3",
|
||||
"chip": "KF1950",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h3",
|
||||
"chip": "ID-1968",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h3",
|
||||
"chip": "ID-1980",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h3",
|
||||
"chip": "ID-1990",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h6",
|
||||
"chip": "KF1950",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h6",
|
||||
"chip": "ID-1968",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h6",
|
||||
"chip": "ID-1980",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h6",
|
||||
"chip": "ID-1990",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h616",
|
||||
"chip": "KF1950",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h616",
|
||||
"chip": "ID-1968",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h616",
|
||||
"chip": "ID-1980",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
},
|
||||
{
|
||||
"board": "allwinner-h616",
|
||||
"chip": "ID-1990",
|
||||
"sdk_image_sha256": null,
|
||||
"stock_image_sha256": null,
|
||||
"stock_result": null,
|
||||
"stock_first_rejection": null,
|
||||
"alkane_share_accept_capture": null,
|
||||
"simulator_trace_sha256": null,
|
||||
"bench_validation": null
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish the last completed main/next CI result to a private badge branch."""
|
||||
|
||||
import os
|
||||
from urllib.parse import quote, urlencode
|
||||
|
||||
from badge_store import publish_file, request_json
|
||||
|
||||
|
||||
WORKFLOWS = {"main.yml": "main", "next.yml": "next"}
|
||||
|
||||
|
||||
def badge(branch: str, conclusion: str, run_id: int) -> bytes:
|
||||
passed = conclusion == "success"
|
||||
word = "pass" if passed else "fail"
|
||||
color = "#2ea043" if passed else "#d1242f"
|
||||
title = f"CI {branch}: last completed attempt {word} (run {run_id})"
|
||||
return (f'<svg xmlns="http://www.w3.org/2000/svg" width="102" height="20" '
|
||||
f'role="img" aria-label="{title}"><title>{title}</title>'
|
||||
'<rect width="102" height="20" rx="3" fill="#555"/>'
|
||||
f'<path d="M39 0h60a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H39z" fill="{color}"/>'
|
||||
'<text x="20" y="14" fill="#fff" text-anchor="middle" '
|
||||
'font-family="sans-serif" font-size="11">CI</text>'
|
||||
f'<text x="70" y="14" fill="#fff" text-anchor="middle" '
|
||||
f'font-family="sans-serif" font-size="11">{word}</text></svg>\n').encode()
|
||||
|
||||
|
||||
def latest_completed(api: str, repo: str, workflow: str, branch: str,
|
||||
token: str) -> tuple[int, str]:
|
||||
path = quote(workflow, safe="")
|
||||
latest = None
|
||||
for page in range(1, 21):
|
||||
query = urlencode({"branch": branch, "limit": 50, "page": page})
|
||||
url = f"{api}/repos/{repo}/actions/workflows/{path}/runs?{query}"
|
||||
runs = request_json(url, token).get("workflow_runs", [])
|
||||
for run in runs:
|
||||
if run.get("head_branch") != branch or run.get("status") != "completed":
|
||||
continue
|
||||
if run.get("conclusion") not in ("success", "failure"):
|
||||
continue
|
||||
candidate = (int(run["id"]), run["conclusion"])
|
||||
if latest is None or candidate[0] > latest[0]:
|
||||
latest = candidate
|
||||
if len(runs) < 50:
|
||||
break
|
||||
if latest is None:
|
||||
raise RuntimeError(f"no completed {branch} run found for {workflow}")
|
||||
return latest
|
||||
|
||||
|
||||
def publish(api: str, repo: str, branch: str, data: bytes, token: str) -> None:
|
||||
publish_file(api, repo, f"{branch}.svg", data, token,
|
||||
f"Record completed {branch} CI attempt")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if os.environ["GITHUB_EVENT_NAME"] not in ("workflow_run", "workflow_dispatch"):
|
||||
raise RuntimeError("badge publisher must follow CI completion or manual dispatch")
|
||||
if os.environ["GITHUB_REF"] != "refs/heads/main":
|
||||
raise RuntimeError("badge publisher must use the main branch")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
completed = {branch: latest_completed(api, repo, workflow, branch, token)
|
||||
for workflow, branch in WORKFLOWS.items()}
|
||||
for branch, (run_id, conclusion) in completed.items():
|
||||
publish(api, repo, branch, badge(branch, conclusion, run_id), token)
|
||||
print(f"{branch} badge records completed run {run_id}: {conclusion}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,147 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Generate reviewable metrics and self-contained badges from CI measurements."""
|
||||
|
||||
import argparse
|
||||
import html
|
||||
import json
|
||||
import math
|
||||
import pathlib
|
||||
import re
|
||||
import tomllib
|
||||
from bench_host import identity as benchmark_host
|
||||
|
||||
EXPECTED_BENCHES = frozenset({
|
||||
"target_matrix", "power_policy", "share_verification",
|
||||
"scrypt_share_verification", "bm1366_work_encoding", "bm1362_commands",
|
||||
"bm1362_job_encoding", "bm1366_report_decode", "stratum_header",
|
||||
"stratum_submission", "stratum_authorize_format", "stratum_notify_parse",
|
||||
"stratum_control_parse", "stratum_configure_parse", "difficulty_target",
|
||||
"stratum_job_issue", "bm1366_session_cycle", "bm1362_work_encoding",
|
||||
"stratum_configure_format", "stratum_subscribe_format",
|
||||
"stratum_subscription_parse", "stratum_accept_parse",
|
||||
"hal_socket_exchange", "stratum_socket_round_trip",
|
||||
"bm13xx_crc5", "bm13xx_crc16", "bm1366_captured_report_poll",
|
||||
})
|
||||
BENCH_LINE = re.compile(r"\bBENCH ([A-Za-z0-9_]+) ([0-9]+(?:\.[0-9]+)?) ns/op\Z")
|
||||
|
||||
|
||||
def coverage(path):
|
||||
data = json.loads(pathlib.Path(path).read_text())
|
||||
return data["data"][0]["totals"]["lines"]["percent"]
|
||||
|
||||
|
||||
def bench_results(path):
|
||||
results = {}
|
||||
for line in pathlib.Path(path).read_text().splitlines():
|
||||
if "BENCH " not in line:
|
||||
continue
|
||||
match = BENCH_LINE.search(line)
|
||||
if match is None:
|
||||
raise ValueError("malformed microbenchmark result")
|
||||
name, value = match.groups()
|
||||
measurement = float(value)
|
||||
if name in results or not math.isfinite(measurement) or measurement <= 0:
|
||||
raise ValueError("duplicate or invalid microbenchmark result")
|
||||
results[name] = measurement
|
||||
return results
|
||||
|
||||
|
||||
def benchmark_delta(current, baseline):
|
||||
if set(current) != EXPECTED_BENCHES:
|
||||
raise ValueError("microbenchmark set differs from the declared suite")
|
||||
if not isinstance(baseline, dict) or not set(baseline).issubset(current):
|
||||
raise ValueError("baseline contains retired or invalid benchmarks")
|
||||
if any(not isinstance(value, (int, float)) or isinstance(value, bool)
|
||||
or not math.isfinite(value) or value <= 0 for value in baseline.values()):
|
||||
raise ValueError("baseline contains invalid measurements")
|
||||
if not baseline:
|
||||
return None
|
||||
return sum((baseline[name] - current[name]) / baseline[name]
|
||||
for name in baseline) / len(baseline) * 100
|
||||
|
||||
|
||||
def quality_grade(path):
|
||||
checks = json.loads(pathlib.Path(path).read_text())
|
||||
if checks != {"format": True, "clippy_warnings_denied": True}:
|
||||
raise ValueError("format and strict Clippy must pass before publishing quality")
|
||||
return "A"
|
||||
|
||||
|
||||
def compact(number):
|
||||
value = float(number)
|
||||
units = ("", "K", "M", "G")
|
||||
index = 0
|
||||
while value >= 999.5 and index < len(units) - 1:
|
||||
value /= 1000
|
||||
index += 1
|
||||
digits = 0 if value >= 100 else 1 if value >= 10 else 2
|
||||
number = f"{value:.{digits}f}"
|
||||
if digits:
|
||||
number = number.rstrip("0").rstrip(".")
|
||||
return number + units[index]
|
||||
|
||||
|
||||
def svg(label, value, color):
|
||||
label, value = html.escape(label), html.escape(value)
|
||||
lw, vw = 12 + 7 * len(label), 12 + 7 * len(value)
|
||||
return (f'<svg xmlns="http://www.w3.org/2000/svg" width="{lw + vw}" height="20" '
|
||||
f'role="img" aria-label="{label}: {value}">'
|
||||
f'<rect width="{lw}" height="20" rx="3" fill="#555"/>'
|
||||
f'<rect x="{lw}" width="{vw}" height="20" rx="3" fill="{color}"/>'
|
||||
f'<g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="11">'
|
||||
f'<text x="{lw / 2}" y="14">{label}</text>'
|
||||
f'<text x="{lw + vw / 2}" y="14">{value}</text></g></svg>\n')
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--tests-output", required=True)
|
||||
parser.add_argument("--tests-coverage", required=True)
|
||||
parser.add_argument("--bench-output", required=True)
|
||||
parser.add_argument("--bench-coverage", required=True)
|
||||
parser.add_argument("--quality-gate", required=True)
|
||||
parser.add_argument("--bench-baseline", default="badges/bench-baseline.json")
|
||||
args = parser.parse_args()
|
||||
test_output = pathlib.Path(args.tests_output).read_text()
|
||||
tests = sum(map(int, re.findall(r"test result: ok\. (\d+) passed", test_output)))
|
||||
if tests < 1:
|
||||
raise SystemExit("no passing tests parsed")
|
||||
current = bench_results(args.bench_output)
|
||||
base_path = pathlib.Path(args.bench_baseline)
|
||||
baseline = json.loads(base_path.read_text()) if base_path.exists() else {}
|
||||
delta = benchmark_delta(current, baseline)
|
||||
line_coverage = coverage(args.tests_coverage)
|
||||
bench_coverage = coverage(args.bench_coverage)
|
||||
loc = sum(len(path.read_text().splitlines()) for parent in (pathlib.Path("src"), pathlib.Path("ci"))
|
||||
for path in parent.rglob("*") if path.suffix in (".rs", ".py", ".sh"))
|
||||
lock = tomllib.loads(pathlib.Path("Cargo.lock").read_text())
|
||||
dependencies = sum(item["name"] != "alkane-os" for item in lock["package"])
|
||||
metrics = {"tests": tests, "line_coverage_pct": round(line_coverage, 1),
|
||||
"bench_coverage_pct": round(bench_coverage, 1),
|
||||
"bench_ns_per_op": current, "bench_improvement_pct": delta,
|
||||
"bench_host": benchmark_host(),
|
||||
"lines_of_code": loc, "dependencies": dependencies,
|
||||
"code_quality": quality_grade(args.quality_gate),
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"}
|
||||
pathlib.Path("badges").mkdir(exist_ok=True)
|
||||
pathlib.Path("badges/metrics.json").write_text(json.dumps(metrics, indent=2) + "\n")
|
||||
badges = {
|
||||
"tests": ("tests", str(tests), "#4c1"),
|
||||
"coverage": ("coverage", f"{line_coverage:.1f}%", "#4c1" if line_coverage >= 80 else "#dfb317"),
|
||||
"bench-coverage": ("bench coverage", f"{bench_coverage:.1f}%", "#4c1" if bench_coverage >= 80 else "#dfb317"),
|
||||
"bench": ("bench", "baseline set" if delta is None else f"{delta:+.1f}% vs prev", "#007ec6"),
|
||||
"loc": ("lines of code", compact(loc), "#007ec6"),
|
||||
"dependencies": ("dependencies", str(dependencies), "#007ec6"),
|
||||
"quality": ("code quality", metrics["code_quality"],
|
||||
{"A": "#4c1", "B": "#97ca00", "C": "#dfb317",
|
||||
"D": "#fe7d37", "F": "#e05d44"}[metrics["code_quality"]]),
|
||||
"license": ("license", "MIT", "#007ec6"),
|
||||
}
|
||||
for name, (label, value, color) in badges.items():
|
||||
pathlib.Path(f"badges/{name}.svg").write_text(svg(label, value, color))
|
||||
print(json.dumps(metrics))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,125 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish a measured benchmark page to the public, data-only Pages repo."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shlex
|
||||
import subprocess
|
||||
import tempfile
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
PAGES_REPO = "ssh://git@gitea.bluefla.re:2222/blueflare/alkane-benchmarks.git"
|
||||
GUARD_REPO = "https://gitea.bluefla.re/blueflare/alkane-benchmarks.git"
|
||||
GUARD_COMMIT = "ea160545c49bc419a245692deda8dd7db7a611eb"
|
||||
PAGES_HOST = "gitea.bluefla.re"
|
||||
PAGES_HOST_FINGERPRINT = "SHA256:lqB5cmC9E5HNeg/lkzdOwQ++I8A70Wx7lnNs6liN24g"
|
||||
PAGES_HOST_KEY = "[gitea.bluefla.re]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO1II6NkmRW+QAd+Wj+7qbNrA8Oo+/N/WRog4hELskn/"
|
||||
|
||||
|
||||
def run(*args: str, env: dict[str, str] | None = None,
|
||||
cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
|
||||
result = subprocess.run(args, env=env, cwd=cwd, text=True,
|
||||
capture_output=True, check=False)
|
||||
if result.returncode:
|
||||
detail = result.stderr.strip()[:2000]
|
||||
raise RuntimeError(f"{args[0]} {args[1]} exited {result.returncode}: {detail}")
|
||||
return result
|
||||
|
||||
|
||||
def current_main_sha() -> str:
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
request = Request(f"{api}/repos/{repo}/branches/main",
|
||||
headers={"Authorization": f"token {token}"})
|
||||
with urlopen(request, timeout=20) as response:
|
||||
branch = json.load(response)
|
||||
return branch["commit"]["id"]
|
||||
|
||||
|
||||
def publish(site: str) -> None:
|
||||
if os.environ.get("GITHUB_REF") != "refs/heads/main":
|
||||
raise ValueError("benchmark Pages publication requires main")
|
||||
sha = os.environ["GITHUB_SHA"]
|
||||
if current_main_sha() != sha:
|
||||
print("Skipping benchmark page from a superseded main commit")
|
||||
return
|
||||
page = Path("bench-site/index.html").read_bytes()
|
||||
if not page.startswith(b"<!doctype html>") or len(page) > 1_048_576:
|
||||
raise ValueError("invalid benchmark page")
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-pages-") as directory:
|
||||
temporary = Path(directory)
|
||||
guard_checkout = temporary / "guard"
|
||||
run("git", "clone", "--quiet", "--single-branch", "--branch", "next",
|
||||
GUARD_REPO, str(guard_checkout))
|
||||
guard_source = run("git", "show", f"{GUARD_COMMIT}:ci/validate_site.py",
|
||||
cwd=guard_checkout).stdout
|
||||
guard_script = temporary / "validate_site.py"
|
||||
guard_script.write_text(guard_source)
|
||||
run("python3", str(guard_script), "--page", site,
|
||||
str(Path("bench-site/index.html").resolve()))
|
||||
key = os.environ["BENCH_PAGES_DEPLOY_KEY"]
|
||||
if not key.startswith("-----BEGIN OPENSSH PRIVATE KEY-----"):
|
||||
raise ValueError("missing benchmark Pages deploy key")
|
||||
key_path = temporary / "deploy_key"
|
||||
key_path.write_text(key.rstrip("\n") + "\n")
|
||||
key_path.chmod(0o600)
|
||||
known_hosts = temporary / "known_hosts"
|
||||
known_hosts.write_text(PAGES_HOST_KEY + "\n")
|
||||
fingerprint = run("ssh-keygen", "-lf", str(known_hosts)).stdout.split()[1]
|
||||
if fingerprint != PAGES_HOST_FINGERPRINT:
|
||||
raise ValueError("benchmark Pages SSH host key changed")
|
||||
git_env = os.environ.copy()
|
||||
ssh_command = (f"ssh -i {shlex.quote(str(key_path))} -o IdentitiesOnly=yes "
|
||||
f"-o UserKnownHostsFile={shlex.quote(str(known_hosts))} "
|
||||
"-o StrictHostKeyChecking=yes -o ConnectTimeout=10")
|
||||
git_env["GIT_SSH_COMMAND"] = ssh_command
|
||||
git_env["GIT_TERMINAL_PROMPT"] = "0"
|
||||
checkout = temporary / "site"
|
||||
run("git", "clone", "--quiet", "--single-branch", "--branch", "gh-pages",
|
||||
PAGES_REPO, str(checkout), env=git_env)
|
||||
run("git", "config", "user.name", "Alkane CI", cwd=checkout)
|
||||
run("git", "config", "user.email", "ci@bluefla.re", cwd=checkout)
|
||||
for attempt in range(3):
|
||||
if current_main_sha() != sha:
|
||||
print("Skipping benchmark page from a superseded main commit")
|
||||
return
|
||||
run("git", "fetch", "--quiet", "origin", "gh-pages", env=git_env,
|
||||
cwd=checkout)
|
||||
run("git", "checkout", "-q", "-B", "bench-publish", "origin/gh-pages",
|
||||
cwd=checkout)
|
||||
destination = checkout / site / "index.html"
|
||||
destination.parent.mkdir(exist_ok=True)
|
||||
destination.write_bytes(page)
|
||||
run("git", "add", f"{site}/index.html", cwd=checkout)
|
||||
changed = subprocess.run(("git", "diff", "--cached", "--quiet"),
|
||||
cwd=checkout, check=False)
|
||||
if changed.returncode == 0:
|
||||
print(f"{site} benchmark page is already current")
|
||||
return
|
||||
if changed.returncode != 1:
|
||||
raise RuntimeError("cannot compare benchmark page")
|
||||
run("git", "commit", "-q", "-m",
|
||||
f"Update {site} benchmarks for {sha[:10]} [skip ci]", cwd=checkout)
|
||||
pushed = subprocess.run(("git", "push", "--quiet", "origin",
|
||||
"HEAD:gh-pages"), env=git_env, cwd=checkout,
|
||||
text=True, capture_output=True, check=False)
|
||||
if pushed.returncode == 0:
|
||||
print(f"Published {site} benchmark page for {sha[:10]}")
|
||||
return
|
||||
if attempt == 2:
|
||||
raise RuntimeError(f"benchmark Pages push failed: {pushed.stderr.strip()}")
|
||||
raise RuntimeError("benchmark Pages publication did not complete")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("site", choices=("sdk", "os", "toolkit"))
|
||||
publish(parser.parse_args().site)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,32 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish measured main-branch metric badges to the private badge branch."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from badge_store import publish_file
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
NAMES = ("tests", "coverage", "bench", "bench-coverage", "loc",
|
||||
"dependencies", "quality", "license")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
for name in NAMES:
|
||||
data = (ROOT / "badges" / f"{name}.svg").read_bytes()
|
||||
if not data.lstrip().startswith(b"<svg"):
|
||||
raise ValueError(f"invalid {name} SVG")
|
||||
publish_file(api, repo, f"badges/{name}.svg", data, token,
|
||||
f"Update measured {name} badge")
|
||||
data = (ROOT / "badges/metrics.json").read_bytes()
|
||||
publish_file(api, repo, "badges/metrics.json", data, token,
|
||||
"Update measured badge data")
|
||||
print(f"Published {len(NAMES)} measured badge SVGs and metrics.json")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,160 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish a complete Gitea release after all assets are attached to a draft."""
|
||||
|
||||
import json
|
||||
import hashlib
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
|
||||
def request(url, method="GET", payload=None, content_type=None):
|
||||
headers = {"Authorization": "token " + os.environ["GITEA_TOKEN"]}
|
||||
if content_type:
|
||||
headers["Content-Type"] = content_type
|
||||
operation = urllib.request.Request(url, data=payload, headers=headers, method=method)
|
||||
with urllib.request.urlopen(operation, timeout=60) as response:
|
||||
body = response.read()
|
||||
return json.loads(body) if body else None
|
||||
|
||||
|
||||
def json_request(url, method, value):
|
||||
return request(url, method, json.dumps(value).encode(), "application/json")
|
||||
|
||||
|
||||
def files_to_publish(names):
|
||||
paths = [pathlib.Path(name) for name in names]
|
||||
if not paths or len({path.name for path in paths}) != len(paths):
|
||||
raise ValueError("release assets must have distinct basenames")
|
||||
for path in paths:
|
||||
if not path.is_file() or path.stat().st_size == 0:
|
||||
raise ValueError(f"release asset missing or empty: {path}")
|
||||
return paths
|
||||
|
||||
|
||||
def sha256_file(path):
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as source:
|
||||
for chunk in iter(lambda: source.read(1_048_576), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
class NoRedirect(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(self, request, fp, code, message, headers, new_url):
|
||||
return None
|
||||
|
||||
|
||||
def asset_digest(asset, api):
|
||||
url = asset["browser_download_url"]
|
||||
remote = urllib.parse.urlsplit(url)
|
||||
expected = urllib.parse.urlsplit(api)
|
||||
if remote.scheme != "https" or remote.netloc != expected.netloc:
|
||||
raise ValueError("asset download is outside the trusted Gitea host")
|
||||
operation = urllib.request.Request(
|
||||
url, headers={"Authorization": "token " + os.environ["GITEA_TOKEN"]})
|
||||
digest = hashlib.sha256()
|
||||
with urllib.request.build_opener(NoRedirect).open(operation, timeout=60) as response:
|
||||
for chunk in iter(lambda: response.read(1_048_576), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def get_release(url):
|
||||
try:
|
||||
return request(url)
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code == 404:
|
||||
return None
|
||||
raise
|
||||
|
||||
|
||||
def check_tag_commit(api, repo, tag, sha):
|
||||
url = f"{api}/repos/{repo}/tags/{urllib.parse.quote(tag, safe='')}"
|
||||
try:
|
||||
remote_tag = request(url)
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code == 404:
|
||||
return False
|
||||
raise
|
||||
if not isinstance(remote_tag, dict) or remote_tag.get("commit", {}).get("sha") != sha:
|
||||
raise ValueError("Git tag points to a different or unknown commit")
|
||||
return True
|
||||
|
||||
|
||||
def publish(tag, prerelease, paths, api, repo, sha):
|
||||
base = f"{api}/repos/{repo}/releases"
|
||||
tag_url = f"{base}/tags/{urllib.parse.quote(tag, safe='')}"
|
||||
metadata = {
|
||||
"tag_name": tag,
|
||||
"target_commitish": sha,
|
||||
"name": tag,
|
||||
"body": f"Automated Alkane OS build from {sha}. Conformance results are in the repository.",
|
||||
"prerelease": prerelease,
|
||||
}
|
||||
check_tag_commit(api, repo, tag, sha)
|
||||
release = get_release(tag_url)
|
||||
if release is None:
|
||||
release = json_request(base, "POST", {**metadata, "draft": True})
|
||||
elif release.get("target_commitish") != sha:
|
||||
raise ValueError("release tag already belongs to another source revision")
|
||||
release_url = f"{base}/{release['id']}"
|
||||
assets_url = f"{release_url}/assets"
|
||||
existing = request(assets_url)
|
||||
wanted = {path.name: path.stat().st_size for path in paths}
|
||||
digests = {path.name: sha256_file(path) for path in paths}
|
||||
present = {asset["name"]: asset for asset in existing}
|
||||
if not release.get("draft") and all(
|
||||
(asset := present.get(name)) is not None and asset["size"] == size
|
||||
and asset_digest(asset, api) == digests[name]
|
||||
for name, size in wanted.items()
|
||||
):
|
||||
if not check_tag_commit(api, repo, tag, sha):
|
||||
raise ValueError("published release has no Git tag")
|
||||
print(f"Release {tag} is already complete")
|
||||
return
|
||||
if not release.get("draft"):
|
||||
release = json_request(release_url, "PATCH", {**metadata, "draft": True})
|
||||
if not release.get("draft"):
|
||||
raise ValueError("incomplete release could not be returned to draft")
|
||||
for asset in existing:
|
||||
if asset["name"] in wanted:
|
||||
request(f"{assets_url}/{asset['id']}", "DELETE")
|
||||
for path in paths:
|
||||
query = urllib.parse.urlencode({"name": path.name})
|
||||
request(f"{assets_url}?{query}", "POST", path.read_bytes(),
|
||||
"application/octet-stream")
|
||||
uploaded = request(assets_url)
|
||||
actual = {asset["name"]: asset for asset in uploaded}
|
||||
if any((asset := actual.get(name)) is None or asset["size"] != size
|
||||
or asset_digest(asset, api) != digests[name]
|
||||
for name, size in wanted.items()):
|
||||
raise ValueError("draft release asset verification failed")
|
||||
check_tag_commit(api, repo, tag, sha)
|
||||
release = json_request(release_url, "PATCH", {**metadata, "draft": False})
|
||||
if release.get("draft"):
|
||||
raise ValueError("release remained a draft after publishing")
|
||||
if not check_tag_commit(api, repo, tag, sha):
|
||||
raise ValueError("published release did not create the expected Git tag")
|
||||
print(f"Published {tag} with {len(paths)} assets")
|
||||
|
||||
|
||||
def main():
|
||||
if len(sys.argv) < 4:
|
||||
sys.exit("usage: release.py TAG PRERELEASE FILE [FILE ...]")
|
||||
tag, prerelease, *names = sys.argv[1:]
|
||||
try:
|
||||
paths = files_to_publish(names)
|
||||
api = os.environ.get("GITHUB_API_URL", "https://gitea.bluefla.re/api/v1").rstrip("/")
|
||||
publish(tag, prerelease.lower() == "true", paths, api,
|
||||
os.environ["GITHUB_REPOSITORY"], os.environ["GITHUB_SHA"])
|
||||
except (ValueError, OSError, urllib.error.HTTPError) as error:
|
||||
sys.exit(f"release publication failed: {error}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,58 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Exercise benchmark history selection and safe site rendering."""
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
from bench_history import previous_measurement, render_html, updated_index
|
||||
|
||||
|
||||
class HistoryTests(unittest.TestCase):
|
||||
def test_retry_uses_previous_commit(self):
|
||||
first = "a" * 40
|
||||
second = "b" * 40
|
||||
index = {"schema": 1, "entries": [
|
||||
{"sha": first, "timestamp": "2026-01-01T00:00:00+00:00",
|
||||
"metrics": {"bench_ns_per_op": {"hash": 10.0}}},
|
||||
{"sha": second, "timestamp": "2026-01-02T00:00:00+00:00",
|
||||
"metrics": {"bench_ns_per_op": {"hash": 8.0}}}]}
|
||||
self.assertEqual(previous_measurement(index, second,
|
||||
lambda ancestor, sha: 1 if ancestor == first else None),
|
||||
{"hash": 10.0})
|
||||
updated = updated_index(index, second, {"bench_ns_per_op": {"hash": 7.5}},
|
||||
"2026-01-03T00:00:00+00:00")
|
||||
self.assertEqual(len(updated["entries"]), 2)
|
||||
self.assertEqual(updated["entries"][-1]["metrics"]["bench_ns_per_op"]["hash"], 7.5)
|
||||
|
||||
def test_invalid_measurement_and_sha_rejected(self):
|
||||
with self.assertRaises(ValueError):
|
||||
updated_index({}, "bad", {"bench_ns_per_op": {"hash": 1}}, "now")
|
||||
with self.assertRaises(ValueError):
|
||||
updated_index({}, "a" * 40, {"bench_ns_per_op": {"hash": -1}}, "now")
|
||||
|
||||
def test_baseline_must_match_cpu_class(self):
|
||||
first = "a" * 40
|
||||
host = {"architecture": "x86_64", "cpu_model": "A", "logical_cpus": 8}
|
||||
other = {"architecture": "x86_64", "cpu_model": "B", "logical_cpus": 8}
|
||||
index = {"entries": [{"sha": first, "metrics": {
|
||||
"bench_ns_per_op": {"hash": 10.0}, "bench_host": host}}]}
|
||||
distance = lambda _ancestor, _sha: 1
|
||||
self.assertEqual(previous_measurement(index, "b" * 40, distance, host),
|
||||
{"hash": 10.0})
|
||||
self.assertEqual(previous_measurement(index, "b" * 40, distance, other), {})
|
||||
|
||||
def test_site_escapes_history_content(self):
|
||||
entry = {"sha": "a" * 40, "timestamp": "<script>alert(1)</script>",
|
||||
"metrics": {"bench_ns_per_op": {"hash": 10.0},
|
||||
"bench_host": {"cpu_model": "<script>cpu</script>"}}}
|
||||
page = render_html({"entries": [entry]})
|
||||
self.assertIn("<script>", page)
|
||||
self.assertNotIn("<script>", page)
|
||||
self.assertIn("10.000", page)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,50 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Verify cleanup removes only generated files inside the CI checkout."""
|
||||
|
||||
import importlib.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
SPEC = importlib.util.spec_from_file_location(
|
||||
"cleanup_generated", Path(__file__).resolve().with_name("cleanup-generated.py"))
|
||||
CLEANUP = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(CLEANUP)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-os-cleanup-") as temporary:
|
||||
root = Path(temporary)
|
||||
outside = root.parent / (root.name + "-outside")
|
||||
outside.mkdir()
|
||||
(outside / "keep").write_bytes(b"safe")
|
||||
previous = CLEANUP.ROOT
|
||||
CLEANUP.ROOT = root
|
||||
try:
|
||||
with patch.dict(os.environ, {"GITHUB_RUN_ID": "123"}):
|
||||
(root / "target").mkdir()
|
||||
(root / "target/build").write_bytes(b"generated")
|
||||
(root / "bench-current.txt").write_bytes(b"generated")
|
||||
CLEANUP.cleanup()
|
||||
assert not (root / "target").exists()
|
||||
assert not (root / "bench-current.txt").exists()
|
||||
(root / "target").symlink_to(outside, target_is_directory=True)
|
||||
try:
|
||||
CLEANUP.cleanup()
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
raise AssertionError("cleanup followed a symlink")
|
||||
assert (outside / "keep").read_bytes() == b"safe"
|
||||
finally:
|
||||
CLEANUP.ROOT = previous
|
||||
(outside / "keep").unlink()
|
||||
outside.rmdir()
|
||||
print("Alkane OS CI cleanup containment: PASS")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,115 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Regression checks for the fail-closed release evidence gate."""
|
||||
|
||||
import copy
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
from tempfile import TemporaryDirectory
|
||||
import unittest
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).with_name("check-conformance.py")
|
||||
spec = importlib.util.spec_from_file_location("check_conformance", SCRIPT)
|
||||
gate = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(gate)
|
||||
MANIFEST = json.loads(Path(__file__).with_name("conformance.json").read_text())
|
||||
TARGETS = {(row["board"], row["chip"]): gate.REQUIRED_ALGORITHMS[row["chip"]]
|
||||
for row in MANIFEST["targets"]}
|
||||
|
||||
|
||||
class ConformanceGateTest(unittest.TestCase):
|
||||
def test_placeholder_matrix_cannot_pass_without_current_run_artifacts(self):
|
||||
manifest = copy.deepcopy(MANIFEST)
|
||||
for row in manifest["targets"]:
|
||||
row.update(sdk_image_sha256="0" * 64,
|
||||
stock_image_sha256="0" * 64,
|
||||
simulator_trace_sha256="0" * 64,
|
||||
stock_result="mines",
|
||||
alkane_share_accept_capture="does-not-exist.json",
|
||||
bench_validation="not-run")
|
||||
with TemporaryDirectory() as directory:
|
||||
errors = gate.validate(manifest, TARGETS, Path(directory), "123",
|
||||
"a" * 40, "b" * 64)
|
||||
self.assertEqual(len(errors), 64)
|
||||
self.assertTrue(all("evidence invalid" in error for error in errors))
|
||||
|
||||
def test_stale_source_identity_is_rejected(self):
|
||||
row = copy.deepcopy(MANIFEST["targets"][0])
|
||||
row["stock_result"] = "mines"
|
||||
with TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
report = root / "123" / row["board"] / f"{row['chip']}.json"
|
||||
report.parent.mkdir(parents=True)
|
||||
report.write_text(json.dumps({"schema": 1, "run_id": "123",
|
||||
"source_commit": "f" * 40,
|
||||
"os_binary_sha256": "b" * 64,
|
||||
"board": row["board"], "chip": row["chip"],
|
||||
"stock_firmware_modified": False}))
|
||||
with self.assertRaisesRegex(ValueError, "different run, source"):
|
||||
gate.verify_cell(row, root, "123", "a" * 40, "b" * 64,
|
||||
TARGETS[(row["board"], row["chip"])])
|
||||
|
||||
def test_share_accept_requires_real_difficulty_one_work(self):
|
||||
capture = {"nonce_source": "real_silicon_capture",
|
||||
"header80": "00" * 80,
|
||||
"pool_target_le": "ff" * 32, "nonce": 0,
|
||||
"submission": {"id": 4, "method": "mining.submit",
|
||||
"params": ["worker", "job", "", "00000000", "00000000"]},
|
||||
"pool_response": {"id": 4, "result": True, "error": None}}
|
||||
with self.assertRaisesRegex(ValueError, "below difficulty one"):
|
||||
gate.verify_accept(capture, "Sha256")
|
||||
capture["submission"]["params"][4] = "00000001"
|
||||
with self.assertRaisesRegex(ValueError, "submitted nonce"):
|
||||
gate.verify_accept(capture, "Sha256")
|
||||
|
||||
def test_scrypt_proof_matches_litecoin_and_independent_vectors(self):
|
||||
header = bytes.fromhex(
|
||||
"01000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f27"
|
||||
"9fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4"
|
||||
"ea78e011d012d59d4"
|
||||
)
|
||||
self.assertEqual(len(header), 80)
|
||||
self.assertEqual(
|
||||
gate.proof_digest(header, "Scrypt")[::-1].hex(),
|
||||
"0000000110c8357966576df46f3b802ca897deb7ad18b12f1c24ecff6386ebd9",
|
||||
)
|
||||
self.assertEqual(
|
||||
gate.proof_digest(bytes(range(80)), "Scrypt").hex(),
|
||||
"bc540a1a801df96e493005c71e010e2d387607fbf0fec416fd3c2645aa1ba9d2",
|
||||
)
|
||||
|
||||
def test_equihash_cells_still_need_an_algorithm_specific_verifier(self):
|
||||
with self.assertRaisesRegex(ValueError, "Equihash share verifier"):
|
||||
gate.verify_accept({}, "Equihash")
|
||||
|
||||
def test_submitted_header_reconstruction_rejects_version_and_extranonce_changes(self):
|
||||
capture = {
|
||||
"subscription": {"extranonce1": "aa", "extranonce2_size": 1},
|
||||
"notify": {"method": "mining.notify", "params": [
|
||||
"job", "11" * 32, "01", "02", [],
|
||||
"20000000", "1d00ffff", "12345678", True]},
|
||||
"configure_response": {"result": {
|
||||
"version-rolling": True, "version-rolling.mask": "1fffe000"}},
|
||||
}
|
||||
params = ["worker", "job", "bb", "12345678", "00000001", "00002000"]
|
||||
header, _ = gate.reconstructed_header(capture, params)
|
||||
self.assertEqual(len(header), 80)
|
||||
self.assertEqual(header[:4], (0x20002000).to_bytes(4, "little"))
|
||||
self.assertEqual(header[4:8], b"\x11" * 4)
|
||||
changed = params.copy()
|
||||
changed[5] = "ffffffff"
|
||||
with self.assertRaisesRegex(ValueError, "version bits"):
|
||||
gate.reconstructed_header(capture, changed)
|
||||
changed[5] = params[5]
|
||||
changed[2] = "f"
|
||||
with self.assertRaisesRegex(ValueError, "Stratum hex"):
|
||||
gate.reconstructed_header(capture, changed)
|
||||
changed[2] = "cc"
|
||||
rebuilt, _ = gate.reconstructed_header(capture, changed)
|
||||
self.assertNotEqual(rebuilt, header)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,73 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Check that queued CI runs do not displace the last completed result."""
|
||||
|
||||
import importlib.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
from badge_store import publish_file
|
||||
|
||||
path = Path(__file__).with_name("last-attempt-badge.py")
|
||||
spec = importlib.util.spec_from_file_location("last_attempt_badge", path)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
|
||||
|
||||
def runs(_url, _token):
|
||||
return {"workflow_runs": [
|
||||
{"id": 105, "head_branch": "main", "status": "completed", "conclusion": "cancelled"},
|
||||
{"id": 104, "head_branch": "main", "status": "queued", "conclusion": None},
|
||||
{"id": 103, "head_branch": "main", "status": "completed", "conclusion": "failure"},
|
||||
{"id": 102, "head_branch": "main", "status": "completed", "conclusion": "success"},
|
||||
]}
|
||||
|
||||
|
||||
with patch.object(module, "request_json", runs):
|
||||
assert module.latest_completed("https://example.invalid/api/v1", "owner/repo",
|
||||
"main.yml", "main", "token") == (103, "failure")
|
||||
|
||||
svg = module.badge("main", "failure", 103)
|
||||
root = ET.fromstring(svg)
|
||||
assert root.attrib["aria-label"] == "CI main: last completed attempt fail (run 103)"
|
||||
assert b">fail</text>" in svg
|
||||
assert b"#d1242f" in svg
|
||||
assert b">pass</text>" in module.badge("next", "success", 108)
|
||||
environment = {
|
||||
"GITHUB_EVENT_NAME": "workflow_run",
|
||||
"GITHUB_REF": "refs/heads/main",
|
||||
"GITHUB_REPOSITORY": "owner/repo",
|
||||
"GITHUB_API_URL": "https://example.invalid/api/v1",
|
||||
"GITEA_TOKEN": "test-token",
|
||||
}
|
||||
with patch.dict(os.environ, environment), \
|
||||
patch.object(module, "latest_completed", side_effect=[(201, "success"),
|
||||
(202, "failure")]) as latest, \
|
||||
patch.object(module, "publish") as published:
|
||||
module.main()
|
||||
assert latest.call_count == 2
|
||||
assert [call.args[2] for call in published.call_args_list] == ["main", "next"]
|
||||
with patch.dict(os.environ, {**environment, "GITHUB_EVENT_NAME": "workflow_dispatch"}), \
|
||||
patch.object(module, "latest_completed", side_effect=[(201, "success"),
|
||||
(202, "failure")]), \
|
||||
patch.object(module, "publish") as published:
|
||||
module.main()
|
||||
assert published.call_count == 2
|
||||
with patch.dict(os.environ, {**environment, "GITHUB_EVENT_NAME": "schedule"}):
|
||||
try:
|
||||
module.main()
|
||||
except RuntimeError as error:
|
||||
assert "CI completion or manual dispatch" in str(error)
|
||||
else:
|
||||
raise AssertionError("scheduled event entered badge publisher")
|
||||
for invalid in ("", "/main.svg", "../main.svg", "badges//main.svg"):
|
||||
try:
|
||||
publish_file("https://example.invalid/api/v1", "owner/repo", invalid,
|
||||
b"<svg/>", "token", "test")
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
raise AssertionError(f"unsafe badge path accepted: {invalid}")
|
||||
print("last completed CI badge: queued run ignored, pass/fail SVGs valid")
|
||||
@@ -1,51 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Regression checks for measured benchmark and quality badges."""
|
||||
|
||||
import sys
|
||||
import json
|
||||
from pathlib import Path
|
||||
from tempfile import TemporaryDirectory
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
from metrics import EXPECTED_BENCHES, bench_results, benchmark_delta, compact, quality_grade
|
||||
|
||||
|
||||
class MetricTests(unittest.TestCase):
|
||||
def test_quality_requires_both_static_checks(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "quality.json"
|
||||
path.write_text(json.dumps({"format": True, "clippy_warnings_denied": True}))
|
||||
self.assertEqual(quality_grade(path), "A")
|
||||
path.write_text(json.dumps({"format": True, "clippy_warnings_denied": False}))
|
||||
with self.assertRaises(ValueError):
|
||||
quality_grade(path)
|
||||
|
||||
def test_benchmark_parser_and_short_si_badge(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "bench.txt"
|
||||
path.write_text("test bench_sha ... BENCH sha 42.125 ns/op\n")
|
||||
self.assertEqual(bench_results(path), {"sha": 42.125})
|
||||
path.write_text("BENCH sha 42.125 ns/op\nBENCH sha 40.000 ns/op\n")
|
||||
with self.assertRaisesRegex(ValueError, "duplicate"):
|
||||
bench_results(path)
|
||||
path.write_text("BENCH sha 42.125 ns/op\nBENCH broken nan ns/op\n")
|
||||
with self.assertRaisesRegex(ValueError, "malformed"):
|
||||
bench_results(path)
|
||||
self.assertEqual(compact(1234567), "1.23M")
|
||||
|
||||
def test_benchmark_suite_and_baseline_must_be_complete(self):
|
||||
current = {name: 10.0 for name in EXPECTED_BENCHES}
|
||||
self.assertIsNone(benchmark_delta(current, {}))
|
||||
self.assertEqual(benchmark_delta(current, {"target_matrix": 20.0}), 50.0)
|
||||
with self.assertRaisesRegex(ValueError, "declared suite"):
|
||||
benchmark_delta({"target_matrix": 10.0}, {})
|
||||
with self.assertRaisesRegex(ValueError, "retired"):
|
||||
benchmark_delta(current, {"removed_bench": 20.0})
|
||||
with self.assertRaisesRegex(ValueError, "invalid measurements"):
|
||||
benchmark_delta(current, {"target_matrix": float("inf")})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,133 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Check draft release recovery without making network requests."""
|
||||
|
||||
import importlib.util
|
||||
import hashlib
|
||||
import urllib.error
|
||||
from pathlib import Path
|
||||
from tempfile import TemporaryDirectory
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).with_name("release.py")
|
||||
spec = importlib.util.spec_from_file_location("release", SCRIPT)
|
||||
release = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(release)
|
||||
|
||||
|
||||
class FakeGitea:
|
||||
def __init__(self):
|
||||
self.release = None
|
||||
self.assets = []
|
||||
self.blobs = {}
|
||||
self.fail_second_upload = True
|
||||
self.uploads = 0
|
||||
self.tag_sha = None
|
||||
|
||||
def request(self, url, method="GET", payload=None, content_type=None):
|
||||
if "/tags/" in url and "/releases/" not in url:
|
||||
if self.tag_sha is None:
|
||||
raise urllib.error.HTTPError(url, 404, "missing", {}, None)
|
||||
return {"commit": {"sha": self.tag_sha}}
|
||||
if "/assets" in url:
|
||||
if method == "GET":
|
||||
return list(self.assets)
|
||||
if method == "DELETE":
|
||||
asset_id = int(url.rsplit("/", 1)[1])
|
||||
self.assets = [item for item in self.assets if item["id"] != asset_id]
|
||||
self.blobs.pop(asset_id, None)
|
||||
return None
|
||||
self.uploads += 1
|
||||
if self.fail_second_upload and self.uploads == 2:
|
||||
raise OSError("injected upload failure")
|
||||
name = release.urllib.parse.parse_qs(url.split("?", 1)[1])["name"][0]
|
||||
item = {"id": self.uploads, "name": name, "size": len(payload),
|
||||
"browser_download_url": f"https://api/download/{self.uploads}"}
|
||||
self.assets.append(item)
|
||||
self.blobs[self.uploads] = payload
|
||||
return item
|
||||
if method == "GET":
|
||||
return self.release
|
||||
if method == "POST":
|
||||
assert self.release is None
|
||||
self.release = {**release.json.loads(payload), "id": 7}
|
||||
return dict(self.release)
|
||||
if method == "PATCH":
|
||||
self.release.update(release.json.loads(payload))
|
||||
if not self.release["draft"] and self.tag_sha is None:
|
||||
self.tag_sha = self.release["target_commitish"]
|
||||
return dict(self.release)
|
||||
raise AssertionError((method, url))
|
||||
|
||||
|
||||
class ReleaseTest(unittest.TestCase):
|
||||
def test_retry_after_partial_upload_keeps_release_draft_until_complete(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
paths = [Path(directory) / "source.tar.gz", Path(directory) / "bench.txt"]
|
||||
for path in paths:
|
||||
path.write_bytes(path.name.encode())
|
||||
fake = FakeGitea()
|
||||
def digest(asset, _api):
|
||||
return hashlib.sha256(fake.blobs[asset["id"]]).hexdigest()
|
||||
|
||||
with patch.object(release, "request", fake.request), \
|
||||
patch.object(release, "asset_digest", digest):
|
||||
with self.assertRaisesRegex(OSError, "injected upload failure"):
|
||||
release.publish("v1.2.3", False, paths, "https://api", "org/repo", "a" * 40)
|
||||
self.assertTrue(fake.release["draft"])
|
||||
self.assertEqual(len(fake.assets), 1)
|
||||
fake.fail_second_upload = False
|
||||
release.publish("v1.2.3", False, paths, "https://api", "org/repo", "a" * 40)
|
||||
self.assertFalse(fake.release["draft"])
|
||||
self.assertEqual({item["name"] for item in fake.assets},
|
||||
{path.name for path in paths})
|
||||
fake.assets[0]["size"] = len(fake.blobs[fake.assets[0]["id"]])
|
||||
fake.blobs[fake.assets[0]["id"]] = b"x" * fake.assets[0]["size"]
|
||||
release.publish("v1.2.3", False, paths, "https://api", "org/repo", "a" * 40)
|
||||
self.assertFalse(fake.release["draft"])
|
||||
self.assertEqual(digest(fake.assets[0], "https://api"),
|
||||
release.sha256_file(paths[0]))
|
||||
|
||||
def test_preflight_rejects_missing_and_duplicate_assets(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "one"
|
||||
with self.assertRaisesRegex(ValueError, "missing or empty"):
|
||||
release.files_to_publish([str(path)])
|
||||
path.write_bytes(b"x")
|
||||
with self.assertRaisesRegex(ValueError, "distinct"):
|
||||
release.files_to_publish([str(path), str(path)])
|
||||
|
||||
def test_existing_git_tag_mismatch_blocks_release_without_changes(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "image.tar.gz"
|
||||
path.write_bytes(b"image")
|
||||
fake = FakeGitea()
|
||||
fake.tag_sha = "b" * 40
|
||||
fake.release = {"id": 7, "tag_name": "v1.2.3",
|
||||
"target_commitish": "a" * 40, "draft": False}
|
||||
with patch.object(release, "request", fake.request):
|
||||
with self.assertRaisesRegex(ValueError, "Git tag points"):
|
||||
release.publish("v1.2.3", False, [path], "https://api",
|
||||
"org/repo", "a" * 40)
|
||||
self.assertEqual(fake.uploads, 0)
|
||||
self.assertFalse(fake.release["draft"])
|
||||
|
||||
def test_complete_release_without_git_tag_is_not_accepted(self):
|
||||
with TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "image.tar.gz"
|
||||
path.write_bytes(b"image")
|
||||
fake = FakeGitea()
|
||||
fake.release = {"id": 7, "tag_name": "v1.2.3",
|
||||
"target_commitish": "a" * 40, "draft": False}
|
||||
fake.assets = [{"id": 1, "name": path.name, "size": path.stat().st_size}]
|
||||
with patch.object(release, "request", fake.request), \
|
||||
patch.object(release, "asset_digest", lambda *_: release.sha256_file(path)):
|
||||
with self.assertRaisesRegex(ValueError, "no Git tag"):
|
||||
release.publish("v1.2.3", False, [path], "https://api",
|
||||
"org/repo", "a" * 40)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1 +0,0 @@
|
||||
0
|
||||
@@ -1,56 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Select a release tag from Git history. The major version is manual."""
|
||||
|
||||
import argparse
|
||||
import pathlib
|
||||
import re
|
||||
import subprocess
|
||||
|
||||
|
||||
def git(*args):
|
||||
return subprocess.check_output(["git", *args], text=True).strip()
|
||||
|
||||
|
||||
def versions(branch):
|
||||
suffix = r"" if branch == "main" else r"-rc\.(\d+)"
|
||||
pattern = re.compile(r"^v(\d+)\.(\d+)\.(\d+)" + suffix + r"$")
|
||||
result = []
|
||||
for tag in git("tag", "-l", "v*").splitlines():
|
||||
match = pattern.fullmatch(tag)
|
||||
if match:
|
||||
result.append((tuple(map(int, match.groups())), tag))
|
||||
return sorted(result)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("branch", choices=("main", "next"))
|
||||
args = parser.parse_args()
|
||||
major = int(pathlib.Path("ci/version-x.txt").read_text().strip())
|
||||
finals = versions("main")
|
||||
previous = finals[-1] if finals else None
|
||||
if previous and previous[0][0] > major:
|
||||
raise SystemExit("manual major version is behind the latest release")
|
||||
if previous and previous[0][0] == major:
|
||||
_, minor, patch = previous[0]
|
||||
changed = git("diff", "--name-only", previous[1], "HEAD").splitlines()
|
||||
if not changed:
|
||||
print("release=false")
|
||||
return
|
||||
feature = any(path.startswith("src/") or path == "Cargo.toml" for path in changed)
|
||||
minor, patch = (minor + 1, 0) if feature else (minor, patch + 1)
|
||||
else:
|
||||
minor, patch = (1, 0) if major == 0 else (0, 0)
|
||||
base = f"v{major}.{minor}.{patch}"
|
||||
if args.branch == "next":
|
||||
candidates = [parts[0][3] for parts in versions("next") if parts[0][:3] == (major, minor, patch)]
|
||||
tag = f"{base}-rc.{max(candidates, default=0) + 1}"
|
||||
else:
|
||||
tag = base
|
||||
print("release=true")
|
||||
print(f"tag={tag}")
|
||||
print(f"version={tag[1:]}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,116 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded host-only check: captured BM13xx report through HAL to a strict pool.
|
||||
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::miner::Bm1366Miner;
|
||||
use alkane_os::stratum_client::{PoolConnection, PoolEvent, ReportEvent};
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const CAPTURED_HEADER: [u8; 80] = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38, 0x9d,
|
||||
0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6, 0xc2, 0x25,
|
||||
0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78,
|
||||
0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38,
|
||||
0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
|
||||
const BM1362_HEADER_HEX: &str = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a0503969b7384e1215aace8cfc65dae22d8493ad48fec0b7ac3b0ad7b4e7",
|
||||
"fb0c5c0012e6a8f06021700000000"
|
||||
);
|
||||
|
||||
fn bm1362_header() -> Result<[u8; 80], io::Error> {
|
||||
let mut header = [0_u8; 80];
|
||||
for (index, pair) in BM1362_HEADER_HEX.as_bytes().chunks_exact(2).enumerate() {
|
||||
let digits = std::str::from_utf8(pair).map_err(io::Error::other)?;
|
||||
header[index] = u8::from_str_radix(digits, 16).map_err(io::Error::other)?;
|
||||
}
|
||||
Ok(header)
|
||||
}
|
||||
|
||||
fn failure(message: impl Into<String>) -> io::Error {
|
||||
io::Error::other(message.into())
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let socket = args.next().ok_or_else(|| {
|
||||
failure("usage: simulator_pool_replay_probe HAL_SOCKET POOL_ADDRESS [SHARES] [CHIP]")
|
||||
})?;
|
||||
let address: SocketAddr = args
|
||||
.next()
|
||||
.ok_or_else(|| failure("missing pool address"))?
|
||||
.parse()?;
|
||||
let expected_accepts: usize = args.next().map_or(Ok(1), |value| value.parse())?;
|
||||
if !(1..=64).contains(&expected_accepts) {
|
||||
return Err(failure("SHARES must be between 1 and 64").into());
|
||||
}
|
||||
let chip = args.next().unwrap_or_else(|| "BM1366".to_owned());
|
||||
let first_header = match chip.as_str() {
|
||||
"BM1366" => CAPTURED_HEADER,
|
||||
"BM1362" if expected_accepts == 1 => bm1362_header()?,
|
||||
"BM1362" => return Err(failure("BM1362 has one captured header").into()),
|
||||
_ => return Err(failure("unsupported captured chip").into()),
|
||||
};
|
||||
if args.next().is_some() {
|
||||
return Err(failure("unexpected argument").into());
|
||||
}
|
||||
if !address.ip().is_loopback() {
|
||||
return Err(failure("probe pool must be on loopback").into());
|
||||
}
|
||||
|
||||
let mut backend = HalClient::connect(socket)?;
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000)
|
||||
.ok_or_else(|| failure("invalid simulator configuration"))?;
|
||||
let mut pool = PoolConnection::connect(
|
||||
address,
|
||||
"alkane-simulator-probe",
|
||||
"alkane.test",
|
||||
"x",
|
||||
Duration::from_secs(2),
|
||||
Duration::from_secs(5),
|
||||
)
|
||||
.map_err(|error| failure(format!("pool handshake: {error:?}")))?;
|
||||
miner.start()?;
|
||||
let deadline = Instant::now() + Duration::from_secs(10 + 2 * expected_accepts as u64);
|
||||
let mut issued = 0;
|
||||
let mut submitted = 0;
|
||||
let mut accepted = 0;
|
||||
while Instant::now() < deadline {
|
||||
let (event, reports) = pool
|
||||
.cycle(&mut miner)
|
||||
.map_err(|error| failure(format!("mining cycle: {error:?}")))?;
|
||||
submitted += reports
|
||||
.iter()
|
||||
.filter(|report| matches!(report, ReportEvent::Submitted(_)))
|
||||
.count();
|
||||
match event {
|
||||
PoolEvent::Work(work) => {
|
||||
if issued == 0 && work.header != first_header {
|
||||
return Err(failure("pool job differs from real-silicon capture").into());
|
||||
}
|
||||
issued += 1;
|
||||
}
|
||||
PoolEvent::ShareAccepted(_) => {
|
||||
if accepted >= submitted || accepted >= issued {
|
||||
return Err(failure("unattributed pool acceptance").into());
|
||||
}
|
||||
accepted += 1;
|
||||
if accepted == expected_accepts {
|
||||
miner.stop()?;
|
||||
println!(
|
||||
"{chip} real captured nonce accepted by strict loopback pool ({accepted} shares)"
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
PoolEvent::ShareRejected(_) => return Err(failure("pool rejected share").into()),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Err(failure("captured share was not accepted before deadline").into())
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Exercise the SDK's host-only BM13xx HAL simulator with a captured job.
|
||||
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel};
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
|
||||
const HEADER: [u8; 80] = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38, 0x9d,
|
||||
0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6, 0xc2, 0x25,
|
||||
0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78,
|
||||
0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38,
|
||||
0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
|
||||
const BM1362_HEADER_HEX: &str = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a0503969b7384e1215aace8cfc65dae22d8493ad48fec0b7ac3b0ad7b4e7",
|
||||
"fb0c5c0012e6a8f06021700000000"
|
||||
);
|
||||
|
||||
fn bm1362_header() -> Result<[u8; 80], io::Error> {
|
||||
let mut header = [0_u8; 80];
|
||||
for (index, pair) in BM1362_HEADER_HEX.as_bytes().chunks_exact(2).enumerate() {
|
||||
let digits = std::str::from_utf8(pair).map_err(io::Error::other)?;
|
||||
header[index] = u8::from_str_radix(digits, 16).map_err(io::Error::other)?;
|
||||
}
|
||||
Ok(header)
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let path = args
|
||||
.next()
|
||||
.ok_or("usage: simulator_replay_probe SOCKET_PATH [BM1366|BM1362]")?;
|
||||
let chip = args.next().unwrap_or_else(|| "BM1366".to_owned());
|
||||
if args.next().is_some() {
|
||||
return Err("unexpected argument".into());
|
||||
}
|
||||
let (header, nonce, model) = match chip.as_str() {
|
||||
"BM1366" => (HEADER, 0xedad_ff38, ChipModel::Bm1366),
|
||||
"BM1362" => (bm1362_header()?, 0x630b_2533, ChipModel::Bm1362),
|
||||
_ => return Err("unsupported captured chip".into()),
|
||||
};
|
||||
let mut backend = HalClient::connect(path)?;
|
||||
// Chip initialization is outside this host-only check.
|
||||
let mut miner = Bm1366Miner::new_for_chip(&mut backend, model, 0, 0, 0, 100, 80_000)
|
||||
.ok_or("invalid simulator probe configuration")?;
|
||||
miner.start()?;
|
||||
let mut target = [0_u8; 32];
|
||||
target[26..28].fill(0xff);
|
||||
miner.submit(header, target, 0x18)?;
|
||||
let share = miner.poll()?.ok_or("missing captured nonce report")?;
|
||||
miner.stop()?;
|
||||
assert_eq!(share.nonce, nonce);
|
||||
println!("{chip} captured report verified at difficulty 1");
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "0c9731a8f94bfd865df59164dbb03ff1e5528fb7",
|
||||
"timestamp": "2026-10-17T07:13:35+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.3,
|
||||
"bench_coverage_pct": 41.3,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 165.617,
|
||||
"bm1362_job_encoding": 201.374,
|
||||
"bm1362_work_encoding": 201.031,
|
||||
"bm1366_captured_report_poll": 991.977,
|
||||
"bm1366_report_decode": 83.607,
|
||||
"bm1366_session_cycle": 255.529,
|
||||
"bm1366_work_encoding": 207.648,
|
||||
"bm13xx_crc16": 219.14,
|
||||
"bm13xx_crc5": 34.822,
|
||||
"difficulty_target": 656.388,
|
||||
"hal_socket_exchange": 36781.484,
|
||||
"power_policy": 0.877,
|
||||
"scrypt_share_verification": 256913.781,
|
||||
"share_verification": 887.985,
|
||||
"stratum_accept_parse": 426.494,
|
||||
"stratum_authorize_format": 664.446,
|
||||
"stratum_configure_format": 1200.607,
|
||||
"stratum_configure_parse": 1665.166,
|
||||
"stratum_control_parse": 728.588,
|
||||
"stratum_header": 4721.786,
|
||||
"stratum_job_issue": 3712.656,
|
||||
"stratum_notify_parse": 1477.922,
|
||||
"stratum_socket_round_trip": 57735.305,
|
||||
"stratum_submission": 551.557,
|
||||
"stratum_subscribe_format": 583.6,
|
||||
"stratum_subscription_parse": 928.84,
|
||||
"target_matrix": 31.78
|
||||
},
|
||||
"bench_improvement_pct": 10.177633367079036,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5780,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "148a0ce5e4daa4582a7a34489fe47a56dd95ca2e",
|
||||
"timestamp": "2026-10-17T07:08:13+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.3,
|
||||
"bench_coverage_pct": 41.3,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 129.337,
|
||||
"bm1362_job_encoding": 152.174,
|
||||
"bm1362_work_encoding": 153.276,
|
||||
"bm1366_captured_report_poll": 708.34,
|
||||
"bm1366_report_decode": 57.134,
|
||||
"bm1366_session_cycle": 183.153,
|
||||
"bm1366_work_encoding": 148.746,
|
||||
"bm13xx_crc16": 160.021,
|
||||
"bm13xx_crc5": 26.347,
|
||||
"difficulty_target": 342.74,
|
||||
"hal_socket_exchange": 15917.646,
|
||||
"power_policy": 0.488,
|
||||
"scrypt_share_verification": 193904.781,
|
||||
"share_verification": 582.904,
|
||||
"stratum_accept_parse": 184.808,
|
||||
"stratum_authorize_format": 324.428,
|
||||
"stratum_configure_format": 504.974,
|
||||
"stratum_configure_parse": 738.614,
|
||||
"stratum_control_parse": 278.135,
|
||||
"stratum_header": 3139.763,
|
||||
"stratum_job_issue": 1898.936,
|
||||
"stratum_notify_parse": 1010.965,
|
||||
"stratum_socket_round_trip": 19381.315,
|
||||
"stratum_submission": 271.733,
|
||||
"stratum_subscribe_format": 267.703,
|
||||
"stratum_subscription_parse": 435.592,
|
||||
"target_matrix": 19.871
|
||||
},
|
||||
"bench_improvement_pct": -6.571618825769334,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 5776,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "1d000e037bbbc37ba586245f04d988eeb20d2c4e",
|
||||
"timestamp": "2026-10-19T02:49:25+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 242.157,
|
||||
"bm1362_job_encoding": 286.811,
|
||||
"bm1362_work_encoding": 236.946,
|
||||
"bm1366_captured_report_poll": 1427.465,
|
||||
"bm1366_report_decode": 93.29,
|
||||
"bm1366_session_cycle": 408.666,
|
||||
"bm1366_work_encoding": 338.106,
|
||||
"bm13xx_crc16": 313.61,
|
||||
"bm13xx_crc5": 44.221,
|
||||
"difficulty_target": 1194.541,
|
||||
"hal_socket_exchange": 37791.399,
|
||||
"power_policy": 0.958,
|
||||
"scrypt_share_verification": 322385.789,
|
||||
"share_verification": 1420.128,
|
||||
"stratum_accept_parse": 523.608,
|
||||
"stratum_authorize_format": 787.622,
|
||||
"stratum_configure_format": 2076.944,
|
||||
"stratum_configure_parse": 1829.266,
|
||||
"stratum_control_parse": 796.057,
|
||||
"stratum_header": 5512.653,
|
||||
"stratum_job_issue": 4009.455,
|
||||
"stratum_notify_parse": 1744.167,
|
||||
"stratum_socket_round_trip": 66408.86,
|
||||
"stratum_submission": 736.476,
|
||||
"stratum_subscribe_format": 767.041,
|
||||
"stratum_subscription_parse": 1417.268,
|
||||
"target_matrix": 46.073
|
||||
},
|
||||
"bench_improvement_pct": -5.355437076345111,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5802,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"sha": "1d0c275a043d3067cc7d2d0d617c1b5de815b9bd",
|
||||
"timestamp": "2026-10-17T04:01:28+00:00",
|
||||
"metrics": {
|
||||
"tests": 68,
|
||||
"line_coverage_pct": 87.2,
|
||||
"bench_coverage_pct": 34.9,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 165.354,
|
||||
"bm1362_job_encoding": 200.286,
|
||||
"bm1366_report_decode": 83.727,
|
||||
"bm1366_session_cycle": 223.244,
|
||||
"bm1366_work_encoding": 209.351,
|
||||
"difficulty_target": 661.52,
|
||||
"power_policy": 0.825,
|
||||
"scrypt_share_verification": 270686.164,
|
||||
"share_verification": 958.951,
|
||||
"stratum_authorize_format": 683.429,
|
||||
"stratum_configure_parse": 1641.642,
|
||||
"stratum_control_parse": 604.253,
|
||||
"stratum_header": 5196.406,
|
||||
"stratum_job_issue": 4004.139,
|
||||
"stratum_notify_parse": 1463.534,
|
||||
"stratum_submission": 520.837,
|
||||
"target_matrix": 30.431
|
||||
},
|
||||
"bench_improvement_pct": 12.990854943787838,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5249,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "23a67af7db1c59d48ed052d2f399f53852fba7fd",
|
||||
"timestamp": "2026-10-17T06:22:39+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.3,
|
||||
"bench_coverage_pct": 41.3,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 118.466,
|
||||
"bm1362_job_encoding": 141.095,
|
||||
"bm1362_work_encoding": 140.218,
|
||||
"bm1366_captured_report_poll": 619.37,
|
||||
"bm1366_report_decode": 54.631,
|
||||
"bm1366_session_cycle": 174.583,
|
||||
"bm1366_work_encoding": 140.707,
|
||||
"bm13xx_crc16": 154.111,
|
||||
"bm13xx_crc5": 25.45,
|
||||
"difficulty_target": 330.927,
|
||||
"hal_socket_exchange": 16029.276,
|
||||
"power_policy": 0.488,
|
||||
"scrypt_share_verification": 193320.875,
|
||||
"share_verification": 577.433,
|
||||
"stratum_accept_parse": 181.167,
|
||||
"stratum_authorize_format": 287.414,
|
||||
"stratum_configure_format": 488.179,
|
||||
"stratum_configure_parse": 703.635,
|
||||
"stratum_control_parse": 263.262,
|
||||
"stratum_header": 2946.961,
|
||||
"stratum_job_issue": 1830.304,
|
||||
"stratum_notify_parse": 743.751,
|
||||
"stratum_socket_round_trip": 16392.885,
|
||||
"stratum_submission": 270.776,
|
||||
"stratum_subscribe_format": 259.584,
|
||||
"stratum_subscription_parse": 404.322,
|
||||
"target_matrix": 18.848
|
||||
},
|
||||
"bench_improvement_pct": -2.5965982435089954,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 5776,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "361a6f45872bac472719eb1205440627734b9dc0",
|
||||
"timestamp": "2026-10-19T02:42:52+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 232.262,
|
||||
"bm1362_job_encoding": 268.042,
|
||||
"bm1362_work_encoding": 293.119,
|
||||
"bm1366_captured_report_poll": 1005.482,
|
||||
"bm1366_report_decode": 107.082,
|
||||
"bm1366_session_cycle": 342.536,
|
||||
"bm1366_work_encoding": 318.703,
|
||||
"bm13xx_crc16": 294.818,
|
||||
"bm13xx_crc5": 43.289,
|
||||
"difficulty_target": 909.418,
|
||||
"hal_socket_exchange": 41358.24,
|
||||
"power_policy": 0.916,
|
||||
"scrypt_share_verification": 363389.156,
|
||||
"share_verification": 1773.295,
|
||||
"stratum_accept_parse": 543.03,
|
||||
"stratum_authorize_format": 858.969,
|
||||
"stratum_configure_format": 1298.086,
|
||||
"stratum_configure_parse": 2120.089,
|
||||
"stratum_control_parse": 607.363,
|
||||
"stratum_header": 6954.921,
|
||||
"stratum_job_issue": 5228.494,
|
||||
"stratum_notify_parse": 2059.438,
|
||||
"stratum_socket_round_trip": 45648.118,
|
||||
"stratum_submission": 727.713,
|
||||
"stratum_subscribe_format": 731.331,
|
||||
"stratum_subscription_parse": 1136.976,
|
||||
"target_matrix": 41.489
|
||||
},
|
||||
"bench_improvement_pct": -18.46436035258768,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5802,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "484f479b90eff4fcc7772d323ff4c9b6a4b93771",
|
||||
"timestamp": "2026-11-12T22:58:16+00:00",
|
||||
"metrics": {
|
||||
"tests": 252,
|
||||
"line_coverage_pct": 85.7,
|
||||
"bench_coverage_pct": 11.0,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 275.944,
|
||||
"bm1362_job_encoding": 312.568,
|
||||
"bm1362_work_encoding": 326.845,
|
||||
"bm1366_captured_report_poll": 1718.903,
|
||||
"bm1366_report_decode": 135.625,
|
||||
"bm1366_session_cycle": 378.843,
|
||||
"bm1366_work_encoding": 325.481,
|
||||
"bm13xx_crc16": 331.899,
|
||||
"bm13xx_crc5": 62.62,
|
||||
"difficulty_target": 861.822,
|
||||
"hal_socket_exchange": 33430.247,
|
||||
"power_policy": 1.164,
|
||||
"scrypt_share_verification": 406989.328,
|
||||
"share_verification": 1563.182,
|
||||
"stratum_accept_parse": 666.681,
|
||||
"stratum_authorize_format": 1155.103,
|
||||
"stratum_configure_format": 1917.635,
|
||||
"stratum_configure_parse": 2337.488,
|
||||
"stratum_control_parse": 913.604,
|
||||
"stratum_header": 8352.213,
|
||||
"stratum_job_issue": 5823.769,
|
||||
"stratum_notify_parse": 2406.618,
|
||||
"stratum_socket_round_trip": 66469.58,
|
||||
"stratum_submission": 865.538,
|
||||
"stratum_subscribe_format": 1011.42,
|
||||
"stratum_subscription_parse": 1294.617,
|
||||
"target_matrix": 55.748
|
||||
},
|
||||
"bench_improvement_pct": null,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "Intel(R) Xeon(R) CPU E5-2620 v2 @ 2.10GHz",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 20375,
|
||||
"dependencies": 60,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"sha": "5aab1e0131f1b86ef568c59e06a1d68b39a97dc7",
|
||||
"timestamp": "2026-10-17T01:14:10+00:00",
|
||||
"metrics": {
|
||||
"tests": 68,
|
||||
"line_coverage_pct": 87.4,
|
||||
"bench_coverage_pct": 35.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 181.12,
|
||||
"bm1362_job_encoding": 212.353,
|
||||
"bm1366_report_decode": 83.909,
|
||||
"bm1366_session_cycle": 217.569,
|
||||
"bm1366_work_encoding": 218.388,
|
||||
"difficulty_target": 692.324,
|
||||
"power_policy": 0.845,
|
||||
"scrypt_share_verification": 298371.453,
|
||||
"share_verification": 934.966,
|
||||
"stratum_authorize_format": 783.436,
|
||||
"stratum_configure_parse": 1568.098,
|
||||
"stratum_control_parse": 852.454,
|
||||
"stratum_header": 5480.384,
|
||||
"stratum_job_issue": 3591.099,
|
||||
"stratum_notify_parse": 1770.242,
|
||||
"stratum_submission": 555.39,
|
||||
"target_matrix": 34.08
|
||||
},
|
||||
"bench_improvement_pct": -1.2856187431122177,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5227,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
{
|
||||
"sha": "5faeb774113d09d150ad8cfa5bee3951fae0d8e8",
|
||||
"timestamp": "2026-10-17T04:02:08+00:00",
|
||||
"metrics": {
|
||||
"tests": 68,
|
||||
"line_coverage_pct": 87.2,
|
||||
"bench_coverage_pct": 34.9,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 118.16,
|
||||
"bm1362_job_encoding": 140.788,
|
||||
"bm1366_report_decode": 54.245,
|
||||
"bm1366_session_cycle": 154.963,
|
||||
"bm1366_work_encoding": 141.589,
|
||||
"difficulty_target": 323.774,
|
||||
"power_policy": 0.461,
|
||||
"scrypt_share_verification": 186319.641,
|
||||
"share_verification": 550.887,
|
||||
"stratum_authorize_format": 294.061,
|
||||
"stratum_configure_parse": 711.528,
|
||||
"stratum_control_parse": 254.993,
|
||||
"stratum_header": 2969.331,
|
||||
"stratum_job_issue": 1825.709,
|
||||
"stratum_notify_parse": 689.88,
|
||||
"stratum_submission": 249.138,
|
||||
"target_matrix": 19.153
|
||||
},
|
||||
"bench_improvement_pct": null,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 5249,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "871a2cd3f782bbe4ca171fb89f4a9a546e07e0d7",
|
||||
"timestamp": "2026-10-19T03:52:23+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 120.796,
|
||||
"bm1362_job_encoding": 141.136,
|
||||
"bm1362_work_encoding": 143.088,
|
||||
"bm1366_captured_report_poll": 638.604,
|
||||
"bm1366_report_decode": 54.562,
|
||||
"bm1366_session_cycle": 174.175,
|
||||
"bm1366_work_encoding": 144.601,
|
||||
"bm13xx_crc16": 155.011,
|
||||
"bm13xx_crc5": 25.634,
|
||||
"difficulty_target": 333.155,
|
||||
"hal_socket_exchange": 15028.565,
|
||||
"power_policy": 0.478,
|
||||
"scrypt_share_verification": 188387.836,
|
||||
"share_verification": 576.683,
|
||||
"stratum_accept_parse": 182.574,
|
||||
"stratum_authorize_format": 298.237,
|
||||
"stratum_configure_format": 565.741,
|
||||
"stratum_configure_parse": 717.721,
|
||||
"stratum_control_parse": 257.534,
|
||||
"stratum_header": 2940.601,
|
||||
"stratum_job_issue": 1793.692,
|
||||
"stratum_notify_parse": 697.719,
|
||||
"stratum_socket_round_trip": 15954.266,
|
||||
"stratum_submission": 252.056,
|
||||
"stratum_subscribe_format": 258.863,
|
||||
"stratum_subscription_parse": 429.497,
|
||||
"target_matrix": 18.526
|
||||
},
|
||||
"bench_improvement_pct": 0.9487568131159643,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 5837,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
{
|
||||
"sha": "a2d03658137b3426d3feb0311dc74640a2a4a9fd",
|
||||
"timestamp": "2026-10-16T07:36:30+00:00",
|
||||
"metrics": {
|
||||
"tests": 30,
|
||||
"line_coverage_pct": 86.5,
|
||||
"bench_coverage_pct": 46.9,
|
||||
"bench_ns_per_op": {
|
||||
"bm1366_session_cycle": 153.229,
|
||||
"bm1366_work_encoding": 160.908,
|
||||
"power_policy": 0.616,
|
||||
"bm1366_report_decode": 57.895,
|
||||
"difficulty_target": 351.668,
|
||||
"stratum_control_parse": 411.535,
|
||||
"share_verification": 701.448,
|
||||
"target_matrix": 20.303,
|
||||
"stratum_header": 3184.797,
|
||||
"stratum_notify_parse": 792.362,
|
||||
"stratum_submission": 463.577
|
||||
},
|
||||
"bench_improvement_pct": null,
|
||||
"lines_of_code": 2458,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "a4f499ce124412ddd34d42b8375c5625c6a64f3b",
|
||||
"timestamp": "2026-10-17T15:28:32+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 120.203,
|
||||
"bm1362_job_encoding": 142.7,
|
||||
"bm1362_work_encoding": 142.153,
|
||||
"bm1366_captured_report_poll": 649.73,
|
||||
"bm1366_report_decode": 55.762,
|
||||
"bm1366_session_cycle": 179.294,
|
||||
"bm1366_work_encoding": 144.509,
|
||||
"bm13xx_crc16": 158.162,
|
||||
"bm13xx_crc5": 26.395,
|
||||
"difficulty_target": 336.608,
|
||||
"hal_socket_exchange": 15741.728,
|
||||
"power_policy": 0.491,
|
||||
"scrypt_share_verification": 198707.742,
|
||||
"share_verification": 584.64,
|
||||
"stratum_accept_parse": 182.362,
|
||||
"stratum_authorize_format": 299.346,
|
||||
"stratum_configure_format": 501.471,
|
||||
"stratum_configure_parse": 708.574,
|
||||
"stratum_control_parse": 260.388,
|
||||
"stratum_header": 3092.729,
|
||||
"stratum_job_issue": 1895.633,
|
||||
"stratum_notify_parse": 709.715,
|
||||
"stratum_socket_round_trip": 16433.906,
|
||||
"stratum_submission": 246.741,
|
||||
"stratum_subscribe_format": 253.29,
|
||||
"stratum_subscription_parse": 415.463,
|
||||
"target_matrix": 19.494
|
||||
},
|
||||
"bench_improvement_pct": 9.825072287666742,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 5796,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "ae7745772ae51cc196a60bd433b3d933ed512eae",
|
||||
"timestamp": "2026-10-19T05:01:58+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 280.556,
|
||||
"bm1362_job_encoding": 331.654,
|
||||
"bm1362_work_encoding": 279.539,
|
||||
"bm1366_captured_report_poll": 1519.435,
|
||||
"bm1366_report_decode": 133.258,
|
||||
"bm1366_session_cycle": 447.576,
|
||||
"bm1366_work_encoding": 269.042,
|
||||
"bm13xx_crc16": 341.921,
|
||||
"bm13xx_crc5": 55.941,
|
||||
"difficulty_target": 1096.821,
|
||||
"hal_socket_exchange": 46202.277,
|
||||
"power_policy": 1.47,
|
||||
"scrypt_share_verification": 497556.016,
|
||||
"share_verification": 1543.566,
|
||||
"stratum_accept_parse": 736.83,
|
||||
"stratum_authorize_format": 920.035,
|
||||
"stratum_configure_format": 2086.944,
|
||||
"stratum_configure_parse": 2439.709,
|
||||
"stratum_control_parse": 998.693,
|
||||
"stratum_header": 8158.071,
|
||||
"stratum_job_issue": 6180.409,
|
||||
"stratum_notify_parse": 2500.056,
|
||||
"stratum_socket_round_trip": 66973.135,
|
||||
"stratum_submission": 1065.12,
|
||||
"stratum_subscribe_format": 1295.934,
|
||||
"stratum_subscription_parse": 1605.76,
|
||||
"target_matrix": 88.817
|
||||
},
|
||||
"bench_improvement_pct": -26.37049020368169,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5837,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"sha": "b1eb641729e77c6451bfe646288d36dd4364aa7e",
|
||||
"timestamp": "2026-10-16T19:19:28+00:00",
|
||||
"metrics": {
|
||||
"tests": 62,
|
||||
"line_coverage_pct": 88.5,
|
||||
"bench_coverage_pct": 35.5,
|
||||
"bench_ns_per_op": {
|
||||
"bm1366_report_decode": 80.406,
|
||||
"bm1366_session_cycle": 229.356,
|
||||
"bm1366_work_encoding": 205.691,
|
||||
"difficulty_target": 669.365,
|
||||
"power_policy": 0.849,
|
||||
"scrypt_share_verification": 286639.148,
|
||||
"share_verification": 882.469,
|
||||
"stratum_authorize_format": 697.138,
|
||||
"stratum_configure_parse": 1646.612,
|
||||
"stratum_control_parse": 822.593,
|
||||
"stratum_header": 5209.663,
|
||||
"stratum_job_issue": 3602.652,
|
||||
"stratum_notify_parse": 1521.427,
|
||||
"stratum_submission": 568.883,
|
||||
"target_matrix": 34.432
|
||||
},
|
||||
"bench_improvement_pct": 5.279824105907481,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 4914,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "b9686af9c8f80feaf6dc893699e4d975a59f5949",
|
||||
"timestamp": "2026-10-17T10:17:58+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.3,
|
||||
"bench_coverage_pct": 41.3,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 174.547,
|
||||
"bm1362_job_encoding": 214.201,
|
||||
"bm1362_work_encoding": 236.065,
|
||||
"bm1366_captured_report_poll": 986.53,
|
||||
"bm1366_report_decode": 83.521,
|
||||
"bm1366_session_cycle": 279.829,
|
||||
"bm1366_work_encoding": 271.038,
|
||||
"bm13xx_crc16": 290.546,
|
||||
"bm13xx_crc5": 49.464,
|
||||
"difficulty_target": 869.765,
|
||||
"hal_socket_exchange": 35832.668,
|
||||
"power_policy": 1.13,
|
||||
"scrypt_share_verification": 290309.086,
|
||||
"share_verification": 886.321,
|
||||
"stratum_accept_parse": 426.084,
|
||||
"stratum_authorize_format": 680.234,
|
||||
"stratum_configure_format": 1204.431,
|
||||
"stratum_configure_parse": 1749.496,
|
||||
"stratum_control_parse": 562.863,
|
||||
"stratum_header": 4986.07,
|
||||
"stratum_job_issue": 3828.325,
|
||||
"stratum_notify_parse": 1794.247,
|
||||
"stratum_socket_round_trip": 46774.744,
|
||||
"stratum_submission": 647.318,
|
||||
"stratum_subscribe_format": 601.506,
|
||||
"stratum_subscription_parse": 1172.352,
|
||||
"target_matrix": 34.356
|
||||
},
|
||||
"bench_improvement_pct": -9.836890264091615,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5787,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "c13db2a5ba9b73ac1fa5b478b7a3032d1810b336",
|
||||
"timestamp": "2026-10-19T03:40:55+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 224.556,
|
||||
"bm1362_job_encoding": 300.77,
|
||||
"bm1362_work_encoding": 246.604,
|
||||
"bm1366_captured_report_poll": 1238.499,
|
||||
"bm1366_report_decode": 119.342,
|
||||
"bm1366_session_cycle": 274.465,
|
||||
"bm1366_work_encoding": 266.664,
|
||||
"bm13xx_crc16": 309.028,
|
||||
"bm13xx_crc5": 52.466,
|
||||
"difficulty_target": 973.075,
|
||||
"hal_socket_exchange": 37957.504,
|
||||
"power_policy": 1.147,
|
||||
"scrypt_share_verification": 284277.391,
|
||||
"share_verification": 1321.256,
|
||||
"stratum_accept_parse": 596.537,
|
||||
"stratum_authorize_format": 1332.566,
|
||||
"stratum_configure_format": 2032.848,
|
||||
"stratum_configure_parse": 2749.941,
|
||||
"stratum_control_parse": 797.614,
|
||||
"stratum_header": 6383.481,
|
||||
"stratum_job_issue": 5409.785,
|
||||
"stratum_notify_parse": 2303.943,
|
||||
"stratum_socket_round_trip": 46976.996,
|
||||
"stratum_submission": 797.677,
|
||||
"stratum_subscribe_format": 750.893,
|
||||
"stratum_subscription_parse": 917.124,
|
||||
"target_matrix": 42.305
|
||||
},
|
||||
"bench_improvement_pct": -4.082790698433242,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5802,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "c7cda3064ec8e51072abd598f714dbee41436f44",
|
||||
"timestamp": "2026-11-16T22:05:06+00:00",
|
||||
"metrics": {
|
||||
"tests": 252,
|
||||
"line_coverage_pct": 85.7,
|
||||
"bench_coverage_pct": 11.0,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 118.822,
|
||||
"bm1362_job_encoding": 146.111,
|
||||
"bm1362_work_encoding": 143.098,
|
||||
"bm1366_captured_report_poll": 651.914,
|
||||
"bm1366_report_decode": 54.195,
|
||||
"bm1366_session_cycle": 178.176,
|
||||
"bm1366_work_encoding": 140.373,
|
||||
"bm13xx_crc16": 153.906,
|
||||
"bm13xx_crc5": 25.409,
|
||||
"difficulty_target": 330.048,
|
||||
"hal_socket_exchange": 15816.499,
|
||||
"power_policy": 0.478,
|
||||
"scrypt_share_verification": 193545.438,
|
||||
"share_verification": 554.416,
|
||||
"stratum_accept_parse": 184.312,
|
||||
"stratum_authorize_format": 288.78,
|
||||
"stratum_configure_format": 497.344,
|
||||
"stratum_configure_parse": 731.367,
|
||||
"stratum_control_parse": 275.494,
|
||||
"stratum_header": 2927.859,
|
||||
"stratum_job_issue": 1931.006,
|
||||
"stratum_notify_parse": 734.993,
|
||||
"stratum_socket_round_trip": 16695.255,
|
||||
"stratum_submission": 241.16,
|
||||
"stratum_subscribe_format": 243.119,
|
||||
"stratum_subscription_parse": 397.224,
|
||||
"target_matrix": 18.798
|
||||
},
|
||||
"bench_improvement_pct": 0.01469655302288628,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 20375,
|
||||
"dependencies": 60,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "cc14543ced1621d4565882a311773c48f5d3614c",
|
||||
"timestamp": "2026-11-12T21:22:45+00:00",
|
||||
"metrics": {
|
||||
"tests": 250,
|
||||
"line_coverage_pct": 85.6,
|
||||
"bench_coverage_pct": 11.1,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 225.644,
|
||||
"bm1362_job_encoding": 328.479,
|
||||
"bm1362_work_encoding": 309.737,
|
||||
"bm1366_captured_report_poll": 1359.428,
|
||||
"bm1366_report_decode": 114.877,
|
||||
"bm1366_session_cycle": 389.925,
|
||||
"bm1366_work_encoding": 331.867,
|
||||
"bm13xx_crc16": 290.487,
|
||||
"bm13xx_crc5": 54.944,
|
||||
"difficulty_target": 1124.235,
|
||||
"hal_socket_exchange": 45278.473,
|
||||
"power_policy": 1.052,
|
||||
"scrypt_share_verification": 418213.531,
|
||||
"share_verification": 1196.389,
|
||||
"stratum_accept_parse": 657.239,
|
||||
"stratum_authorize_format": 1235.067,
|
||||
"stratum_configure_format": 1755.29,
|
||||
"stratum_configure_parse": 2531.665,
|
||||
"stratum_control_parse": 800.904,
|
||||
"stratum_header": 7417.373,
|
||||
"stratum_job_issue": 5545.003,
|
||||
"stratum_notify_parse": 2787.602,
|
||||
"stratum_socket_round_trip": 57270.365,
|
||||
"stratum_submission": 827.388,
|
||||
"stratum_subscribe_format": 908.918,
|
||||
"stratum_subscription_parse": 1413.105,
|
||||
"target_matrix": 52.823
|
||||
},
|
||||
"bench_improvement_pct": -37.70168914723892,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 20288,
|
||||
"dependencies": 60,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
{
|
||||
"sha": "e83ced0e20ca4de09cdf967d051da4a4c678a7b8",
|
||||
"timestamp": "2026-10-17T04:04:54+00:00",
|
||||
"metrics": {
|
||||
"tests": 68,
|
||||
"line_coverage_pct": 87.2,
|
||||
"bench_coverage_pct": 34.9,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 224.772,
|
||||
"bm1362_job_encoding": 223.29,
|
||||
"bm1366_report_decode": 86.828,
|
||||
"bm1366_session_cycle": 238.508,
|
||||
"bm1366_work_encoding": 276.985,
|
||||
"difficulty_target": 741.29,
|
||||
"power_policy": 1.119,
|
||||
"scrypt_share_verification": 323664.125,
|
||||
"share_verification": 909.603,
|
||||
"stratum_authorize_format": 805.021,
|
||||
"stratum_configure_parse": 1718.245,
|
||||
"stratum_control_parse": 709.261,
|
||||
"stratum_header": 5112.093,
|
||||
"stratum_job_issue": 3901.994,
|
||||
"stratum_notify_parse": 1956.082,
|
||||
"stratum_submission": 556.537,
|
||||
"target_matrix": 32.949
|
||||
},
|
||||
"bench_improvement_pct": -13.93138021432414,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5249,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "e8faf398f5fa947cedf9f6ed1d96c4b06a2bc9fe",
|
||||
"timestamp": "2026-10-17T09:20:34+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.3,
|
||||
"bench_coverage_pct": 41.3,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 130.267,
|
||||
"bm1362_job_encoding": 148.2,
|
||||
"bm1362_work_encoding": 145.577,
|
||||
"bm1366_captured_report_poll": 670.107,
|
||||
"bm1366_report_decode": 57.707,
|
||||
"bm1366_session_cycle": 182.859,
|
||||
"bm1366_work_encoding": 148.095,
|
||||
"bm13xx_crc16": 162.08,
|
||||
"bm13xx_crc5": 26.493,
|
||||
"difficulty_target": 350.947,
|
||||
"hal_socket_exchange": 15814.126,
|
||||
"power_policy": 0.503,
|
||||
"scrypt_share_verification": 201815.781,
|
||||
"share_verification": 606.034,
|
||||
"stratum_accept_parse": 198.899,
|
||||
"stratum_authorize_format": 469.782,
|
||||
"stratum_configure_format": 606.131,
|
||||
"stratum_configure_parse": 754.196,
|
||||
"stratum_control_parse": 276.155,
|
||||
"stratum_header": 3225.103,
|
||||
"stratum_job_issue": 2011.455,
|
||||
"stratum_notify_parse": 772.011,
|
||||
"stratum_socket_round_trip": 21484.808,
|
||||
"stratum_submission": 474.468,
|
||||
"stratum_subscribe_format": 285.806,
|
||||
"stratum_subscription_parse": 611.025,
|
||||
"target_matrix": 24.21
|
||||
},
|
||||
"bench_improvement_pct": -7.99990807179019,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 7 8745H w/ Radeon 780M Graphics",
|
||||
"logical_cpus": 4
|
||||
},
|
||||
"lines_of_code": 5787,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"sha": "e928140351830bac139efb98820e53804636c893",
|
||||
"timestamp": "2026-10-21T12:04:09+00:00",
|
||||
"metrics": {
|
||||
"tests": 73,
|
||||
"line_coverage_pct": 86.4,
|
||||
"bench_coverage_pct": 41.2,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 179.018,
|
||||
"bm1362_job_encoding": 205.43,
|
||||
"bm1362_work_encoding": 227.761,
|
||||
"bm1366_captured_report_poll": 987.287,
|
||||
"bm1366_report_decode": 104.075,
|
||||
"bm1366_session_cycle": 291.804,
|
||||
"bm1366_work_encoding": 240.474,
|
||||
"bm13xx_crc16": 321.653,
|
||||
"bm13xx_crc5": 46.539,
|
||||
"difficulty_target": 896.713,
|
||||
"hal_socket_exchange": 34825.955,
|
||||
"power_policy": 0.833,
|
||||
"scrypt_share_verification": 300374.305,
|
||||
"share_verification": 889.826,
|
||||
"stratum_accept_parse": 460.427,
|
||||
"stratum_authorize_format": 838.222,
|
||||
"stratum_configure_format": 1193.101,
|
||||
"stratum_configure_parse": 1507.419,
|
||||
"stratum_control_parse": 595.072,
|
||||
"stratum_header": 4761.147,
|
||||
"stratum_job_issue": 4159.136,
|
||||
"stratum_notify_parse": 1926.673,
|
||||
"stratum_socket_round_trip": 50607.73,
|
||||
"stratum_submission": 548.007,
|
||||
"stratum_subscribe_format": 596.867,
|
||||
"stratum_subscription_parse": 886.226,
|
||||
"target_matrix": 32.376
|
||||
},
|
||||
"bench_improvement_pct": 32.8319410335087,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5841,
|
||||
"dependencies": 11,
|
||||
"code_quality": "A",
|
||||
"quality_scope": "main CI passed cargo fmt and warnings-denied Clippy on all targets",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"sha": "ea8030b707605cc7f974773438aab1a4f369b2ad",
|
||||
"timestamp": "2026-10-17T01:17:31+00:00",
|
||||
"metrics": {
|
||||
"tests": 68,
|
||||
"line_coverage_pct": 87.2,
|
||||
"bench_coverage_pct": 34.9,
|
||||
"bench_ns_per_op": {
|
||||
"bm1362_commands": 164.352,
|
||||
"bm1362_job_encoding": 201.856,
|
||||
"bm1366_report_decode": 108.608,
|
||||
"bm1366_session_cycle": 301.841,
|
||||
"bm1366_work_encoding": 280.799,
|
||||
"difficulty_target": 951.712,
|
||||
"power_policy": 1.058,
|
||||
"scrypt_share_verification": 347436.078,
|
||||
"share_verification": 920.142,
|
||||
"stratum_authorize_format": 670.238,
|
||||
"stratum_configure_parse": 1618.133,
|
||||
"stratum_control_parse": 675.35,
|
||||
"stratum_header": 4941.007,
|
||||
"stratum_job_issue": 5048.704,
|
||||
"stratum_notify_parse": 1751.053,
|
||||
"stratum_submission": 759.693,
|
||||
"target_matrix": 32.171
|
||||
},
|
||||
"bench_improvement_pct": -11.111256562965927,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5249,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"sha": "ebea5f5cfd994118b7fa5b5870863df7bb3ede3a",
|
||||
"timestamp": "2026-10-16T19:15:47+00:00",
|
||||
"metrics": {
|
||||
"tests": 62,
|
||||
"line_coverage_pct": 88.5,
|
||||
"bench_coverage_pct": 35.5,
|
||||
"bench_ns_per_op": {
|
||||
"bm1366_report_decode": 105.816,
|
||||
"bm1366_session_cycle": 248.387,
|
||||
"bm1366_work_encoding": 225.861,
|
||||
"difficulty_target": 696.309,
|
||||
"power_policy": 0.838,
|
||||
"scrypt_share_verification": 269455.297,
|
||||
"share_verification": 881.432,
|
||||
"stratum_authorize_format": 740.798,
|
||||
"stratum_configure_parse": 2156.62,
|
||||
"stratum_control_parse": 754.595,
|
||||
"stratum_header": 5139.92,
|
||||
"stratum_job_issue": 3880.848,
|
||||
"stratum_notify_parse": 2049.311,
|
||||
"stratum_submission": 564.143,
|
||||
"target_matrix": 31.667
|
||||
},
|
||||
"bench_improvement_pct": null,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 4914,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"sha": "f1b4780e2c29545f999a32d082d53d981cde1eab",
|
||||
"timestamp": "2026-10-17T01:10:07+00:00",
|
||||
"metrics": {
|
||||
"tests": 68,
|
||||
"line_coverage_pct": 87.4,
|
||||
"bench_coverage_pct": 32.9,
|
||||
"bench_ns_per_op": {
|
||||
"bm1366_report_decode": 85.369,
|
||||
"bm1366_session_cycle": 217.528,
|
||||
"bm1366_work_encoding": 211.19,
|
||||
"difficulty_target": 699.086,
|
||||
"power_policy": 0.833,
|
||||
"scrypt_share_verification": 289038.242,
|
||||
"share_verification": 1156.075,
|
||||
"stratum_authorize_format": 704.473,
|
||||
"stratum_configure_parse": 1625.25,
|
||||
"stratum_control_parse": 597.014,
|
||||
"stratum_header": 5390.022,
|
||||
"stratum_job_issue": 3546.33,
|
||||
"stratum_notify_parse": 2066.816,
|
||||
"stratum_submission": 627.814,
|
||||
"target_matrix": 32.316
|
||||
},
|
||||
"bench_improvement_pct": -2.9414495847373345,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5227,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"sha": "f6889940c3bc8f5f2d85ee45d992f485e2f00df9",
|
||||
"timestamp": "2026-10-17T01:06:27+00:00",
|
||||
"metrics": {
|
||||
"tests": 62,
|
||||
"line_coverage_pct": 86.7,
|
||||
"bench_coverage_pct": 34.7,
|
||||
"bench_ns_per_op": {
|
||||
"bm1366_report_decode": 80.39,
|
||||
"bm1366_session_cycle": 217.507,
|
||||
"bm1366_work_encoding": 226.831,
|
||||
"difficulty_target": 722.424,
|
||||
"power_policy": 0.816,
|
||||
"scrypt_share_verification": 268871.328,
|
||||
"share_verification": 877.36,
|
||||
"stratum_authorize_format": 720.309,
|
||||
"stratum_configure_parse": 1798.745,
|
||||
"stratum_control_parse": 608.061,
|
||||
"stratum_header": 5195.553,
|
||||
"stratum_job_issue": 4198.027,
|
||||
"stratum_notify_parse": 1548.651,
|
||||
"stratum_submission": 637.805,
|
||||
"target_matrix": 32.238
|
||||
},
|
||||
"bench_improvement_pct": -0.8416320684715105,
|
||||
"bench_host": {
|
||||
"architecture": "x86_64",
|
||||
"cpu_model": "AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx",
|
||||
"logical_cpus": 8
|
||||
},
|
||||
"lines_of_code": 5000,
|
||||
"dependencies": 11,
|
||||
"code_quality": "B",
|
||||
"license": "MIT"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="102" height="20" role="img" aria-label="CI main: last completed attempt fail (run 13252)"><title>CI main: last completed attempt fail (run 13252)</title><rect width="102" height="20" rx="3" fill="#555"/><path d="M39 0h60a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H39z" fill="#d1242f"/><text x="20" y="14" fill="#fff" text-anchor="middle" font-family="sans-serif" font-size="11">CI</text><text x="70" y="14" fill="#fff" text-anchor="middle" font-family="sans-serif" font-size="11">fail</text></svg>
|
||||
|
After Width: | Height: | Size: 533 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="102" height="20" role="img" aria-label="CI next: last completed attempt pass (run 7374)"><title>CI next: last completed attempt pass (run 7374)</title><rect width="102" height="20" rx="3" fill="#555"/><path d="M39 0h60a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H39z" fill="#2ea043"/><text x="20" y="14" fill="#fff" text-anchor="middle" font-family="sans-serif" font-size="11">CI</text><text x="70" y="14" fill="#fff" text-anchor="middle" font-family="sans-serif" font-size="11">pass</text></svg>
|
||||
|
After Width: | Height: | Size: 531 B |
@@ -1,232 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! BM1362 frame encoding from captured command and job traffic.
|
||||
//!
|
||||
//! These pure encoders do not initialize a chain. PLL fields, voltage, and
|
||||
//! model-specific operating points still require silicon-backed validation.
|
||||
|
||||
use crate::bm13xx::{crc16, crc5, reverse_words};
|
||||
|
||||
pub const JOB_BYTES: usize = 88;
|
||||
pub const CHIP_ADDRESS_STEP: u8 = 2;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ModelGeometry {
|
||||
chips_per_chain: u8,
|
||||
ticket_mask: u8,
|
||||
}
|
||||
|
||||
pub const S19J_PRO: ModelGeometry = ModelGeometry {
|
||||
chips_per_chain: 126,
|
||||
ticket_mask: 0x7f,
|
||||
};
|
||||
pub const S19J: ModelGeometry = ModelGeometry {
|
||||
chips_per_chain: 108,
|
||||
ticket_mask: 0x7f,
|
||||
};
|
||||
pub const S19_88: ModelGeometry = ModelGeometry {
|
||||
chips_per_chain: 88,
|
||||
ticket_mask: 0x3f,
|
||||
};
|
||||
|
||||
impl ModelGeometry {
|
||||
pub const fn new(chips_per_chain: u8, ticket_mask: u8) -> Option<Self> {
|
||||
if chips_per_chain == 0 || chips_per_chain > 128 {
|
||||
return None;
|
||||
}
|
||||
Some(Self {
|
||||
chips_per_chain,
|
||||
ticket_mask,
|
||||
})
|
||||
}
|
||||
|
||||
pub const fn chips_per_chain(self) -> u8 {
|
||||
self.chips_per_chain
|
||||
}
|
||||
|
||||
pub const fn ticket_mask(self) -> u8 {
|
||||
self.ticket_mask
|
||||
}
|
||||
|
||||
/// Addresses for an observed two-address-step enumeration walk.
|
||||
pub fn chip_addresses(self) -> impl Iterator<Item = u8> {
|
||||
(0..self.chips_per_chain).map(|index| index * CHIP_ADDRESS_STEP)
|
||||
}
|
||||
}
|
||||
|
||||
fn short_command(code: u8, address: u8, register: u8) -> [u8; 7] {
|
||||
let mut frame = [0x55, 0xaa, code, 0x05, address, register, 0];
|
||||
frame[6] = crc5(&frame[2..6]);
|
||||
frame
|
||||
}
|
||||
|
||||
fn long_command(code: u8, address: u8, register: u8, value: u32) -> [u8; 11] {
|
||||
let mut frame = [0_u8; 11];
|
||||
frame[..6].copy_from_slice(&[0x55, 0xaa, code, 0x09, address, register]);
|
||||
frame[6..10].copy_from_slice(&value.to_be_bytes());
|
||||
frame[10] = crc5(&frame[2..10]);
|
||||
frame
|
||||
}
|
||||
|
||||
pub fn chain_inactive() -> [u8; 7] {
|
||||
short_command(0x53, 0, 0)
|
||||
}
|
||||
|
||||
pub fn set_chip_address(address: u8) -> [u8; 7] {
|
||||
short_command(0x40, address, 0)
|
||||
}
|
||||
|
||||
pub fn read_register(address: u8, register: u8) -> [u8; 7] {
|
||||
short_command(0x42, address, register)
|
||||
}
|
||||
|
||||
pub fn read_register_all(register: u8) -> [u8; 7] {
|
||||
short_command(0x52, 0, register)
|
||||
}
|
||||
|
||||
pub fn write_register(address: u8, register: u8, value: u32) -> [u8; 11] {
|
||||
long_command(0x41, address, register, value)
|
||||
}
|
||||
|
||||
pub fn write_register_all(register: u8, value: u32) -> [u8; 11] {
|
||||
long_command(0x51, 0, register, value)
|
||||
}
|
||||
|
||||
/// Raw header fields in BM1362 wire order. The caller owns work-ID allocation
|
||||
/// and must supply roots and hashes in the order established by its capture.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Job {
|
||||
pub work_id: u8,
|
||||
pub num_midstates: u8,
|
||||
pub start_nonce: u32,
|
||||
pub nbits: u32,
|
||||
pub ntime: u32,
|
||||
pub merkle_root: [u8; 32],
|
||||
pub previous_hash: [u8; 32],
|
||||
pub version: u32,
|
||||
}
|
||||
|
||||
/// Encode the 88-byte SEND_JOB form with the true-length tag observed on wire.
|
||||
pub fn encode_job(job: &Job) -> [u8; JOB_BYTES] {
|
||||
let mut frame = [0_u8; JOB_BYTES];
|
||||
frame[..6].copy_from_slice(&[0x55, 0xaa, 0x21, 0x56, job.work_id, job.num_midstates]);
|
||||
frame[6..10].copy_from_slice(&job.start_nonce.to_le_bytes());
|
||||
frame[10..14].copy_from_slice(&job.nbits.to_le_bytes());
|
||||
frame[14..18].copy_from_slice(&job.ntime.to_le_bytes());
|
||||
frame[18..50].copy_from_slice(&job.merkle_root);
|
||||
frame[50..82].copy_from_slice(&job.previous_hash);
|
||||
frame[82..86].copy_from_slice(&job.version.to_le_bytes());
|
||||
let checksum = crc16(&frame[2..86]);
|
||||
frame[86..88].copy_from_slice(&checksum.to_be_bytes());
|
||||
frame
|
||||
}
|
||||
|
||||
/// Encode one nonce-zero pool header in the observed raw-header job layout.
|
||||
/// This covers work delivery; chain initialization still needs board evidence.
|
||||
pub fn encode_work(header: &[u8; 80], work_id: u8) -> Option<[u8; JOB_BYTES]> {
|
||||
if header[76..80] != [0; 4] || work_id & 7 != 0 {
|
||||
return None;
|
||||
}
|
||||
Some(encode_job(&Job {
|
||||
work_id,
|
||||
num_midstates: 1,
|
||||
start_nonce: 0,
|
||||
nbits: u32::from_le_bytes(header[72..76].try_into().expect("nbits")),
|
||||
ntime: u32::from_le_bytes(header[68..72].try_into().expect("ntime")),
|
||||
merkle_root: reverse_words(&header[36..68]),
|
||||
previous_hash: reverse_words(&header[4..36]),
|
||||
version: u32::from_le_bytes(header[..4].try_into().expect("version")),
|
||||
}))
|
||||
}
|
||||
|
||||
/// BT8D for a 25 MHz input clock with BCLK_SEL=0. A model must still choose
|
||||
/// the actual target baud and confirm switching on silicon.
|
||||
pub fn bt8d_for_baud(baud: u32) -> Option<u8> {
|
||||
if baud == 0 || baud > 3_125_000 {
|
||||
return None;
|
||||
}
|
||||
let divider = 25_000_000_u64 / (8 * u64::from(baud));
|
||||
u8::try_from(divider - 1).ok()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn captured_command_frames() {
|
||||
assert_eq!(chain_inactive(), [0x55, 0xaa, 0x53, 5, 0, 0, 3]);
|
||||
assert_eq!(set_chip_address(0), [0x55, 0xaa, 0x40, 5, 0, 0, 0x1c]);
|
||||
assert_eq!(set_chip_address(8), [0x55, 0xaa, 0x40, 5, 8, 0, 7]);
|
||||
assert_eq!(read_register_all(0), [0x55, 0xaa, 0x52, 5, 0, 0, 0x0a]);
|
||||
assert_eq!(
|
||||
read_register(0x40, 0x1c),
|
||||
[0x55, 0xaa, 0x42, 5, 0x40, 0x1c, 0x0b]
|
||||
);
|
||||
assert_eq!(
|
||||
write_register_all(0x80, 0),
|
||||
[0x55, 0xaa, 0x51, 9, 0, 0x80, 0, 0, 0, 0, 0x1c]
|
||||
);
|
||||
assert_eq!(
|
||||
write_register(0x40, 0x18, 0x7a31),
|
||||
[0x55, 0xaa, 0x41, 9, 0x40, 0x18, 0, 0, 0x7a, 0x31, 0x11]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_address_limits() {
|
||||
assert_eq!(ModelGeometry::new(0, 0), None);
|
||||
assert_eq!(ModelGeometry::new(129, 0), None);
|
||||
assert_eq!(
|
||||
ModelGeometry::new(128, 0).unwrap().chip_addresses().last(),
|
||||
Some(0xfe)
|
||||
);
|
||||
assert_eq!(S19J_PRO.chip_addresses().last(), Some(0xfa));
|
||||
assert_eq!(S19J.chip_addresses().last(), Some(0xd6));
|
||||
assert_eq!(S19_88.chip_addresses().last(), Some(0xae));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn job_frame_layout() {
|
||||
let mut merkle_root = [0_u8; 32];
|
||||
let mut previous_hash = [0_u8; 32];
|
||||
for index in 0..32 {
|
||||
merkle_root[index] = 0xa0 + index as u8;
|
||||
previous_hash[index] = 0x10 + index as u8;
|
||||
}
|
||||
let frame = encode_job(&Job {
|
||||
work_id: 8,
|
||||
num_midstates: 1,
|
||||
start_nonce: 0,
|
||||
nbits: 0x1a1f_2c34,
|
||||
ntime: 0x5e9b_3cd4,
|
||||
merkle_root,
|
||||
previous_hash,
|
||||
version: 0x2000_0000,
|
||||
});
|
||||
assert_eq!(
|
||||
&frame[..18],
|
||||
&[
|
||||
0x55, 0xaa, 0x21, 0x56, 8, 1, 0, 0, 0, 0, 0x34, 0x2c, 0x1f, 0x1a, 0xd4, 0x3c, 0x9b,
|
||||
0x5e
|
||||
]
|
||||
);
|
||||
assert_eq!(&frame[18..50], &merkle_root);
|
||||
assert_eq!(&frame[50..82], &previous_hash);
|
||||
assert_eq!(&frame[82..86], &[0, 0, 0, 0x20]);
|
||||
assert_eq!(&frame[86..88], &[0xc2, 0xbd]);
|
||||
assert_eq!(
|
||||
u16::from_be_bytes([frame[86], frame[87]]),
|
||||
crc16(&frame[2..86])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn baud_dividers() {
|
||||
assert_eq!(bt8d_for_baud(0), None);
|
||||
assert_eq!(bt8d_for_baud(3_000_000), Some(0));
|
||||
assert_eq!(bt8d_for_baud(115_200), Some(26));
|
||||
assert_eq!(bt8d_for_baud(1), None);
|
||||
assert_eq!(bt8d_for_baud(3_125_001), None);
|
||||
assert_eq!(bt8d_for_baud(u32::MAX), None);
|
||||
}
|
||||
}
|
||||
@@ -1,120 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! BM1366 work and response framing. Nonces only come from a device or replay.
|
||||
|
||||
pub const WORK_BYTES: usize = 88;
|
||||
pub const REPORT_BYTES: usize = 11;
|
||||
|
||||
pub use crate::bm13xx::crc16;
|
||||
use crate::bm13xx::{crc5, reverse_words};
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct NonceReport {
|
||||
pub nonce: u32,
|
||||
pub work_id: u8,
|
||||
pub version_field: u16,
|
||||
pub chip_address: u8,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ReportError {
|
||||
Length,
|
||||
Preamble,
|
||||
RegisterResponse,
|
||||
Checksum,
|
||||
}
|
||||
|
||||
/// Encode a nonce-zero Bitcoin header for the observed 88-byte SEND_JOB form.
|
||||
/// The low three work-ID bits are reserved by the BM1366 response format.
|
||||
pub fn encode_work(header: &[u8; 80], work_id: u8) -> Option<[u8; WORK_BYTES]> {
|
||||
if header[76..80] != [0; 4] || work_id & 7 != 0 {
|
||||
return None;
|
||||
}
|
||||
let mut frame = [0_u8; WORK_BYTES];
|
||||
frame[..4].copy_from_slice(&[0x55, 0xaa, 0x21, 0x54]);
|
||||
frame[4] = work_id;
|
||||
// The captured 88-byte on-die-midstate job uses one midstate.
|
||||
frame[5] = 1;
|
||||
frame[10..14].copy_from_slice(&header[72..76]);
|
||||
frame[14..18].copy_from_slice(&header[68..72]);
|
||||
frame[18..50].copy_from_slice(&reverse_words(&header[36..68]));
|
||||
frame[50..82].copy_from_slice(&reverse_words(&header[4..36]));
|
||||
frame[82..86].copy_from_slice(&header[..4]);
|
||||
let checksum = crc16(&frame[2..86]);
|
||||
frame[86..88].copy_from_slice(&checksum.to_be_bytes());
|
||||
Some(frame)
|
||||
}
|
||||
|
||||
/// Parse an observed nonce report; register replies must use a separate path.
|
||||
pub fn decode_nonce_report(frame: &[u8]) -> Result<NonceReport, ReportError> {
|
||||
if frame.len() != REPORT_BYTES {
|
||||
return Err(ReportError::Length);
|
||||
}
|
||||
if frame[..2] != [0xaa, 0x55] {
|
||||
return Err(ReportError::Preamble);
|
||||
}
|
||||
if frame[10] & 0x80 == 0 {
|
||||
return Err(ReportError::RegisterResponse);
|
||||
}
|
||||
if crc5(&frame[2..]) != 0 {
|
||||
return Err(ReportError::Checksum);
|
||||
}
|
||||
Ok(NonceReport {
|
||||
nonce: u32::from_le_bytes(frame[2..6].try_into().expect("four-byte nonce")),
|
||||
chip_address: frame[6],
|
||||
work_id: frame[7] & 0xf8,
|
||||
version_field: u16::from_be_bytes(frame[8..10].try_into().expect("version field")),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn crc16_reference_vector() {
|
||||
assert_eq!(crc16(b"123456789"), 0x29b1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_work_and_response() {
|
||||
let header: [u8; 80] = hex_header();
|
||||
let frame = encode_work(&header, 0x18).unwrap();
|
||||
assert_eq!(&frame[..5], &[0x55, 0xaa, 0x21, 0x54, 0x18]);
|
||||
assert_eq!(frame[5], 1);
|
||||
assert_eq!(
|
||||
crc16(&frame[2..86]),
|
||||
u16::from_be_bytes([frame[86], frame[87]])
|
||||
);
|
||||
assert_eq!(&frame[10..14], &header[72..76]);
|
||||
assert_eq!(&frame[82..86], &header[..4]);
|
||||
assert!(encode_work(&header, 0x19).is_none());
|
||||
let mut with_nonce = header;
|
||||
with_nonce[76] = 1;
|
||||
assert!(encode_work(&with_nonce, 0x18).is_none());
|
||||
|
||||
let report = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
let parsed = decode_nonce_report(&report).unwrap();
|
||||
assert_eq!(parsed.nonce, 0xedad_ff38);
|
||||
assert_eq!(parsed.work_id, 0x18);
|
||||
assert_eq!(parsed.version_field, 0x04b3);
|
||||
let mut corrupt = report;
|
||||
corrupt[4] ^= 1;
|
||||
assert_eq!(decode_nonce_report(&corrupt), Err(ReportError::Checksum));
|
||||
}
|
||||
|
||||
fn hex_header() -> [u8; 80] {
|
||||
let input = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a43ae1052ebd44443068fe178e2c61ca4994846fd133addb04aab2b382c5",
|
||||
"b4c74c1012e6a8f06021700000000"
|
||||
);
|
||||
let mut header = [0_u8; 80];
|
||||
for (index, bytes) in input.as_bytes().chunks_exact(2).enumerate() {
|
||||
let pair = std::str::from_utf8(bytes).unwrap();
|
||||
header[index] = u8::from_str_radix(pair, 16).unwrap();
|
||||
}
|
||||
header
|
||||
}
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Shared BM13xx wire checksums. This module never generates mining nonces.
|
||||
|
||||
/// Reverse the eight 32-bit header words for the observed SEND_JOB layout.
|
||||
pub(crate) fn reverse_words(input: &[u8]) -> [u8; 32] {
|
||||
let mut output = [0_u8; 32];
|
||||
for index in 0..8 {
|
||||
output[index * 4..index * 4 + 4].copy_from_slice(&input[(7 - index) * 4..(8 - index) * 4]);
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
/// CRC5 used by command and nonce-report frames, initial value 0x1f.
|
||||
pub fn crc5(bytes: &[u8]) -> u8 {
|
||||
let mut state = 0x1f_u8;
|
||||
for &byte in bytes {
|
||||
for bit in (0..8).rev() {
|
||||
let feedback = ((state >> 4) ^ (byte >> bit)) & 1;
|
||||
state = ((state << 1) | feedback) & 0x1f;
|
||||
state ^= feedback << 2;
|
||||
}
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
/// CRC16-CCITT-FALSE used by 88-byte SEND_JOB frames.
|
||||
pub fn crc16(bytes: &[u8]) -> u16 {
|
||||
let mut state = 0xffff_u16;
|
||||
for &byte in bytes {
|
||||
state ^= u16::from(byte) << 8;
|
||||
for _ in 0..8 {
|
||||
state = if state & 0x8000 == 0 {
|
||||
state << 1
|
||||
} else {
|
||||
(state << 1) ^ 0x1021
|
||||
};
|
||||
}
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn captured_command_checksums() {
|
||||
let vectors: &[(&[u8], u8)] = &[
|
||||
(&[0x53, 0x05, 0, 0], 0x03),
|
||||
(&[0x40, 0x05, 0, 0], 0x1c),
|
||||
(&[0x52, 0x05, 0, 0], 0x0a),
|
||||
(&[0x40, 0x05, 8, 0], 0x07),
|
||||
(&[0x42, 0x05, 0x40, 0x1c], 0x0b),
|
||||
(&[0x51, 0x09, 0, 0x80, 0, 0, 0, 0], 0x1c),
|
||||
(&[0x41, 0x09, 0x40, 0x18, 0, 0, 0x7a, 0x31], 0x11),
|
||||
];
|
||||
for &(body, expected) in vectors {
|
||||
assert_eq!(crc5(body), expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn standard_crc16_check() {
|
||||
assert_eq!(crc16(b"123456789"), 0x29b1);
|
||||
}
|
||||
}
|
||||
@@ -1,120 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Exact Bitcoin Stratum share target conversion; no floating point or nonce search.
|
||||
|
||||
use serde_json::Number;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum DifficultyError {
|
||||
Invalid,
|
||||
OutOfRange,
|
||||
}
|
||||
|
||||
/// A positive decimal difficulty represented exactly as numerator/denominator.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct PoolDifficulty {
|
||||
numerator: u64,
|
||||
denominator: u64,
|
||||
}
|
||||
|
||||
impl PoolDifficulty {
|
||||
pub fn from_json_number(number: &Number) -> Result<Self, DifficultyError> {
|
||||
let text = number.as_str();
|
||||
if text.len() > 128 || text.starts_with('-') {
|
||||
return Err(DifficultyError::OutOfRange);
|
||||
}
|
||||
let (mantissa, exponent) = match text.split_once(['e', 'E']) {
|
||||
Some((base, exponent)) => (
|
||||
base,
|
||||
exponent
|
||||
.parse::<i32>()
|
||||
.map_err(|_| DifficultyError::OutOfRange)?,
|
||||
),
|
||||
None => (text, 0),
|
||||
};
|
||||
let mut digits = Vec::with_capacity(mantissa.len());
|
||||
let mut fractional = 0_i32;
|
||||
let mut after_dot = false;
|
||||
for byte in mantissa.bytes() {
|
||||
match byte {
|
||||
b'.' if !after_dot => after_dot = true,
|
||||
b'0'..=b'9' => {
|
||||
digits.push(byte - b'0');
|
||||
if after_dot {
|
||||
fractional += 1;
|
||||
}
|
||||
}
|
||||
_ => return Err(DifficultyError::Invalid),
|
||||
}
|
||||
}
|
||||
let first = digits
|
||||
.iter()
|
||||
.position(|digit| *digit != 0)
|
||||
.ok_or(DifficultyError::Invalid)?;
|
||||
let last = digits
|
||||
.iter()
|
||||
.rposition(|digit| *digit != 0)
|
||||
.expect("nonzero digit");
|
||||
let trailing = (digits.len() - last - 1) as i32;
|
||||
let mut numerator = 0_u64;
|
||||
for digit in &digits[first..=last] {
|
||||
numerator = numerator
|
||||
.checked_mul(10)
|
||||
.and_then(|value| value.checked_add(u64::from(*digit)))
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
}
|
||||
let shift = exponent
|
||||
.checked_sub(fractional)
|
||||
.and_then(|value| value.checked_add(trailing))
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
if !(-19..=19).contains(&shift) {
|
||||
return Err(DifficultyError::OutOfRange);
|
||||
}
|
||||
let mut denominator = 1_u64;
|
||||
if shift >= 0 {
|
||||
for _ in 0..shift {
|
||||
numerator = numerator
|
||||
.checked_mul(10)
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
}
|
||||
} else {
|
||||
for _ in 0..-shift {
|
||||
denominator = denominator
|
||||
.checked_mul(10)
|
||||
.ok_or(DifficultyError::OutOfRange)?;
|
||||
}
|
||||
}
|
||||
Ok(Self {
|
||||
numerator,
|
||||
denominator,
|
||||
})
|
||||
}
|
||||
|
||||
/// floor((0xFFFF << 208) / difficulty), capped at the 256-bit maximum.
|
||||
/// The 320-bit intermediate permits all supported decimal denominators.
|
||||
pub fn target_le(self) -> [u8; 32] {
|
||||
let mut product = [0_u8; 40];
|
||||
let mut carry = 0_u128;
|
||||
for (index, byte) in product.iter_mut().enumerate() {
|
||||
let diff_one_byte = if index == 26 || index == 27 { 0xff } else { 0 };
|
||||
let value = (diff_one_byte as u128) * u128::from(self.denominator) + carry;
|
||||
*byte = value as u8;
|
||||
carry = value >> 8;
|
||||
}
|
||||
debug_assert_eq!(carry, 0);
|
||||
|
||||
let mut quotient = [0_u8; 40];
|
||||
let mut remainder = 0_u128;
|
||||
for index in (0..320).rev() {
|
||||
let bit = (product[index / 8] >> (index % 8)) & 1;
|
||||
remainder = (remainder << 1) | u128::from(bit);
|
||||
if remainder >= u128::from(self.numerator) {
|
||||
remainder -= u128::from(self.numerator);
|
||||
quotient[index / 8] |= 1 << (index % 8);
|
||||
}
|
||||
}
|
||||
if quotient[32..].iter().any(|byte| *byte != 0) {
|
||||
return [0xff; 32];
|
||||
}
|
||||
quotient[..32].try_into().expect("256-bit quotient")
|
||||
}
|
||||
}
|
||||
@@ -1,405 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Versioned local wire contract between Alkane OS and an SDK hardware backend.
|
||||
|
||||
use crate::HardwareBackend;
|
||||
use std::fmt;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::Shutdown;
|
||||
use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
|
||||
use std::os::unix::ffi::OsStrExt;
|
||||
use std::os::unix::net::UnixStream;
|
||||
use std::path::Path;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const MAGIC: [u8; 4] = *b"ALKH";
|
||||
const VERSION: u8 = 1;
|
||||
const RESPONSE: u16 = 1;
|
||||
const HEADER_LEN: usize = 16;
|
||||
const MAX_PAYLOAD: usize = 4096;
|
||||
const IO_TIMEOUT: Duration = Duration::from_secs(2);
|
||||
|
||||
const SEND_FRAME: u8 = 1;
|
||||
const RECEIVE_FRAME: u8 = 2;
|
||||
const SET_CHAIN_RESET: u8 = 3;
|
||||
const SET_FAN_TARGET: u8 = 4;
|
||||
const READ_TEMPERATURE: u8 = 5;
|
||||
const SET_PSU_ENABLED: u8 = 6;
|
||||
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
compile_error!("Alkane HAL sockets require Linux");
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod sys {
|
||||
pub use std::ffi::{c_char as CChar, c_int as CInt, c_void as CVoid};
|
||||
pub type SaFamily = u16;
|
||||
pub type SocklenT = u32;
|
||||
|
||||
pub const AF_UNIX: CInt = 1;
|
||||
pub const SOCK_STREAM: CInt = 1;
|
||||
pub const SOCK_NONBLOCK: CInt = 0x800;
|
||||
pub const SOCK_CLOEXEC: CInt = 0x80000;
|
||||
pub const SOL_SOCKET: CInt = 1;
|
||||
pub const SO_ERROR: CInt = 4;
|
||||
pub const POLLOUT: i16 = 4;
|
||||
pub const EAGAIN: CInt = 11;
|
||||
pub const EISCONN: CInt = 106;
|
||||
pub const EINPROGRESS: CInt = 115;
|
||||
|
||||
#[repr(C)]
|
||||
pub struct SockaddrUn {
|
||||
pub sun_family: SaFamily,
|
||||
pub sun_path: [CChar; 108],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct PollFd {
|
||||
pub fd: CInt,
|
||||
pub events: i16,
|
||||
pub revents: i16,
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
pub fn socket(domain: CInt, socket_type: CInt, protocol: CInt) -> CInt;
|
||||
pub fn connect(fd: CInt, address: *const CVoid, length: SocklenT) -> CInt;
|
||||
pub fn poll(fds: *mut PollFd, count: usize, timeout_ms: CInt) -> CInt;
|
||||
pub fn getsockopt(
|
||||
fd: CInt,
|
||||
level: CInt,
|
||||
name: CInt,
|
||||
value: *mut CVoid,
|
||||
length: *mut SocklenT,
|
||||
) -> CInt;
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum HalError {
|
||||
Io(io::Error),
|
||||
Protocol(&'static str),
|
||||
Device(u8),
|
||||
FrameTooLong,
|
||||
InvalidFanPercent,
|
||||
}
|
||||
|
||||
impl fmt::Display for HalError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Io(error) => write!(f, "HAL I/O: {error}"),
|
||||
Self::Protocol(message) => write!(f, "HAL protocol: {message}"),
|
||||
Self::Device(code) => write!(f, "HAL device error: {code}"),
|
||||
Self::FrameTooLong => f.write_str("HAL frame exceeds the wire limit"),
|
||||
Self::InvalidFanPercent => f.write_str("HAL fan target exceeds 100 percent"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for HalError {}
|
||||
|
||||
impl From<io::Error> for HalError {
|
||||
fn from(error: io::Error) -> Self {
|
||||
Self::Io(error)
|
||||
}
|
||||
}
|
||||
|
||||
/// Local client for the privileged board backend supplied by the SDK image.
|
||||
pub struct HalClient {
|
||||
stream: UnixStream,
|
||||
sequence: u32,
|
||||
poisoned: bool,
|
||||
}
|
||||
|
||||
impl HalClient {
|
||||
fn poison(&mut self) {
|
||||
self.poisoned = true;
|
||||
let _ = self.stream.shutdown(Shutdown::Both);
|
||||
}
|
||||
|
||||
pub fn connect(path: impl AsRef<Path>) -> Result<Self, HalError> {
|
||||
let stream = connect_until(path.as_ref(), Instant::now() + IO_TIMEOUT)?;
|
||||
Self::from_stream(stream)
|
||||
}
|
||||
|
||||
pub fn from_stream(stream: UnixStream) -> Result<Self, HalError> {
|
||||
stream.set_read_timeout(Some(IO_TIMEOUT))?;
|
||||
stream.set_write_timeout(Some(IO_TIMEOUT))?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
sequence: 0,
|
||||
poisoned: false,
|
||||
})
|
||||
}
|
||||
|
||||
fn exchange(&mut self, opcode: u8, payload: &[u8]) -> Result<Vec<u8>, HalError> {
|
||||
if self.poisoned {
|
||||
return Err(HalError::Protocol("connection is unusable"));
|
||||
}
|
||||
if payload.len() > MAX_PAYLOAD {
|
||||
return Err(HalError::FrameTooLong);
|
||||
}
|
||||
let result = self.exchange_inner(opcode, payload);
|
||||
if let Err(ref error) = result {
|
||||
if !matches!(error, HalError::Device(_)) {
|
||||
self.poison();
|
||||
// A backend power lease must expire on disconnect. Reusing a
|
||||
// desynchronized stream could silently discard an off request.
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn exchange_inner(&mut self, opcode: u8, payload: &[u8]) -> Result<Vec<u8>, HalError> {
|
||||
let deadline = Instant::now() + IO_TIMEOUT;
|
||||
self.sequence = self.sequence.wrapping_add(1);
|
||||
let sequence = self.sequence;
|
||||
let mut header = [0_u8; HEADER_LEN];
|
||||
header[..4].copy_from_slice(&MAGIC);
|
||||
header[4] = VERSION;
|
||||
header[5] = opcode;
|
||||
header[8..12].copy_from_slice(&sequence.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&(payload.len() as u32).to_le_bytes());
|
||||
write_all_until(&mut self.stream, &header, deadline)?;
|
||||
write_all_until(&mut self.stream, payload, deadline)?;
|
||||
|
||||
read_exact_until(&mut self.stream, &mut header, deadline)?;
|
||||
if header[..4] != MAGIC || header[4] != VERSION || header[5] != opcode {
|
||||
return Err(HalError::Protocol("response identity mismatch"));
|
||||
}
|
||||
if u16::from_le_bytes([header[6], header[7]]) != RESPONSE {
|
||||
return Err(HalError::Protocol("response flag missing"));
|
||||
}
|
||||
if u32::from_le_bytes(header[8..12].try_into().unwrap()) != sequence {
|
||||
return Err(HalError::Protocol("response sequence mismatch"));
|
||||
}
|
||||
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
||||
if !(1..=MAX_PAYLOAD).contains(&length) {
|
||||
return Err(HalError::Protocol("invalid response length"));
|
||||
}
|
||||
let mut body = vec![0_u8; length];
|
||||
read_exact_until(&mut self.stream, &mut body, deadline)?;
|
||||
if body[0] != 0 {
|
||||
if !matches!(body[0], 1..=3) || body.len() != 1 {
|
||||
return Err(HalError::Protocol("invalid error response"));
|
||||
}
|
||||
return Err(HalError::Device(body[0]));
|
||||
}
|
||||
Ok(body[1..].to_vec())
|
||||
}
|
||||
|
||||
fn empty_reply(&mut self, opcode: u8, payload: &[u8]) -> Result<(), HalError> {
|
||||
if !self.exchange(opcode, payload)?.is_empty() {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("unexpected response data"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn timeout_error() -> io::Error {
|
||||
io::Error::new(io::ErrorKind::TimedOut, "HAL operation timed out")
|
||||
}
|
||||
|
||||
fn remaining(deadline: Instant) -> io::Result<Duration> {
|
||||
deadline
|
||||
.checked_duration_since(Instant::now())
|
||||
.filter(|duration| !duration.is_zero())
|
||||
.ok_or_else(timeout_error)
|
||||
}
|
||||
|
||||
fn write_all_until(stream: &mut UnixStream, mut data: &[u8], deadline: Instant) -> io::Result<()> {
|
||||
while !data.is_empty() {
|
||||
stream.set_write_timeout(Some(remaining(deadline)?))?;
|
||||
match stream.write(data) {
|
||||
Ok(0) => {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::WriteZero,
|
||||
"HAL socket closed",
|
||||
))
|
||||
}
|
||||
Ok(count) => data = &data[count..],
|
||||
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_exact_until(
|
||||
stream: &mut UnixStream,
|
||||
mut data: &mut [u8],
|
||||
deadline: Instant,
|
||||
) -> io::Result<()> {
|
||||
while !data.is_empty() {
|
||||
stream.set_read_timeout(Some(remaining(deadline)?))?;
|
||||
match stream.read(data) {
|
||||
Ok(0) => {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::UnexpectedEof,
|
||||
"HAL socket closed",
|
||||
))
|
||||
}
|
||||
Ok(count) => data = &mut data[count..],
|
||||
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn connect_until(path: &Path, deadline: Instant) -> io::Result<UnixStream> {
|
||||
let bytes = path.as_os_str().as_bytes();
|
||||
let max_path =
|
||||
std::mem::size_of::<sys::SockaddrUn>() - std::mem::offset_of!(sys::SockaddrUn, sun_path);
|
||||
if bytes.is_empty() || bytes.len() >= max_path || bytes.contains(&0) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"invalid HAL socket path",
|
||||
));
|
||||
}
|
||||
let raw = unsafe {
|
||||
sys::socket(
|
||||
sys::AF_UNIX,
|
||||
sys::SOCK_STREAM | sys::SOCK_NONBLOCK | sys::SOCK_CLOEXEC,
|
||||
0,
|
||||
)
|
||||
};
|
||||
if raw < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let fd = unsafe { OwnedFd::from_raw_fd(raw) };
|
||||
let mut address: sys::SockaddrUn = unsafe { std::mem::zeroed() };
|
||||
address.sun_family = sys::AF_UNIX as sys::SaFamily;
|
||||
for (destination, source) in address.sun_path.iter_mut().zip(bytes) {
|
||||
*destination = *source as sys::CChar;
|
||||
}
|
||||
let length =
|
||||
(std::mem::offset_of!(sys::SockaddrUn, sun_path) + bytes.len() + 1) as sys::SocklenT;
|
||||
loop {
|
||||
let result = unsafe {
|
||||
sys::connect(
|
||||
fd.as_raw_fd(),
|
||||
&address as *const _ as *const sys::CVoid,
|
||||
length,
|
||||
)
|
||||
};
|
||||
if result == 0 {
|
||||
break;
|
||||
}
|
||||
let error = io::Error::last_os_error();
|
||||
if error.raw_os_error() == Some(sys::EISCONN) {
|
||||
break;
|
||||
}
|
||||
if !matches!(
|
||||
error.raw_os_error(),
|
||||
Some(sys::EINPROGRESS) | Some(sys::EAGAIN)
|
||||
) {
|
||||
return Err(error);
|
||||
}
|
||||
let mut poll_fd = sys::PollFd {
|
||||
fd: fd.as_raw_fd(),
|
||||
events: sys::POLLOUT,
|
||||
revents: 0,
|
||||
};
|
||||
let wait = remaining(deadline)?.as_millis().min(i32::MAX as u128) as i32;
|
||||
let polled = unsafe { sys::poll(&mut poll_fd, 1, wait.max(1)) };
|
||||
if polled < 0 {
|
||||
let error = io::Error::last_os_error();
|
||||
if error.kind() == io::ErrorKind::Interrupted {
|
||||
continue;
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
if polled == 0 {
|
||||
return Err(timeout_error());
|
||||
}
|
||||
let mut socket_error: sys::CInt = 0;
|
||||
let mut socket_error_len = std::mem::size_of_val(&socket_error) as sys::SocklenT;
|
||||
if unsafe {
|
||||
sys::getsockopt(
|
||||
fd.as_raw_fd(),
|
||||
sys::SOL_SOCKET,
|
||||
sys::SO_ERROR,
|
||||
&mut socket_error as *mut _ as *mut sys::CVoid,
|
||||
&mut socket_error_len,
|
||||
)
|
||||
} < 0
|
||||
{
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if socket_error != 0 {
|
||||
return Err(io::Error::from_raw_os_error(socket_error));
|
||||
}
|
||||
if error.raw_os_error() == Some(sys::EINPROGRESS) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let stream = UnixStream::from(fd);
|
||||
stream.set_nonblocking(false)?;
|
||||
Ok(stream)
|
||||
}
|
||||
|
||||
impl HardwareBackend for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
fn send_frame(&mut self, chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
if frame.len() > MAX_PAYLOAD - 3 {
|
||||
return Err(HalError::FrameTooLong);
|
||||
}
|
||||
let mut body = Vec::with_capacity(frame.len() + 3);
|
||||
body.push(chain);
|
||||
body.extend_from_slice(&(frame.len() as u16).to_le_bytes());
|
||||
body.extend_from_slice(frame);
|
||||
self.empty_reply(SEND_FRAME, &body)
|
||||
}
|
||||
|
||||
fn receive_frame(&mut self, chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
if frame.len() > MAX_PAYLOAD - 3 {
|
||||
return Err(HalError::FrameTooLong);
|
||||
}
|
||||
let mut request = [0_u8; 3];
|
||||
request[0] = chain;
|
||||
request[1..].copy_from_slice(&(frame.len() as u16).to_le_bytes());
|
||||
let body = self.exchange(RECEIVE_FRAME, &request)?;
|
||||
if body.len() < 2 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("missing receive length"));
|
||||
}
|
||||
let count = u16::from_le_bytes([body[0], body[1]]) as usize;
|
||||
if count > frame.len() || body.len() != count + 2 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid received frame size"));
|
||||
}
|
||||
frame[..count].copy_from_slice(&body[2..]);
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn set_chain_reset(&mut self, chain: u8, asserted: bool) -> Result<(), Self::Error> {
|
||||
self.empty_reply(SET_CHAIN_RESET, &[chain, u8::from(asserted)])
|
||||
}
|
||||
|
||||
fn set_fan_target(&mut self, fan: u8, percent: u8) -> Result<(), Self::Error> {
|
||||
if percent > 100 {
|
||||
return Err(HalError::InvalidFanPercent);
|
||||
}
|
||||
self.empty_reply(SET_FAN_TARGET, &[fan, percent])
|
||||
}
|
||||
|
||||
fn read_temperature_mc(&mut self, sensor: u8) -> Result<i32, Self::Error> {
|
||||
let body = self.exchange(READ_TEMPERATURE, &[sensor])?;
|
||||
let bytes: [u8; 4] = match body.try_into() {
|
||||
Ok(bytes) => bytes,
|
||||
Err(_) => {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid temperature response"));
|
||||
}
|
||||
};
|
||||
Ok(i32::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
let result = self.empty_reply(SET_PSU_ENABLED, &[u8::from(enabled)]);
|
||||
if !enabled && result.is_err() {
|
||||
self.poison();
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
@@ -1,241 +0,0 @@
|
||||
//! Board independent policy and hardware interfaces for Alkane OS.
|
||||
//!
|
||||
//! An entry in the target matrix is a development obligation, not a claim that
|
||||
//! the pairing already mines. Hardware backends are supplied by SDK images.
|
||||
|
||||
pub mod bm1362;
|
||||
pub mod bm1366;
|
||||
pub mod bm13xx;
|
||||
pub mod difficulty;
|
||||
pub mod hal_wire;
|
||||
pub mod management;
|
||||
pub mod miner;
|
||||
pub mod pow;
|
||||
pub mod scrypt_pow;
|
||||
pub mod stratum_client;
|
||||
pub mod stratum_session;
|
||||
pub mod stratum_submit;
|
||||
pub mod stratum_v1;
|
||||
pub mod stratum_wire;
|
||||
pub mod stratum_work;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum Vendor {
|
||||
Bitmain,
|
||||
Whatsminer,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum Algorithm {
|
||||
Sha256,
|
||||
Scrypt,
|
||||
Equihash,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ControlBoard {
|
||||
pub id: &'static str,
|
||||
pub vendor: Vendor,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct HashChip {
|
||||
pub id: &'static str,
|
||||
pub vendor: Vendor,
|
||||
pub algorithm: Algorithm,
|
||||
}
|
||||
|
||||
pub const CONTROL_BOARDS: [ControlBoard; 7] = [
|
||||
ControlBoard {
|
||||
id: "am335x-bb",
|
||||
vendor: Vendor::Bitmain,
|
||||
},
|
||||
ControlBoard {
|
||||
id: "zynq-7010",
|
||||
vendor: Vendor::Bitmain,
|
||||
},
|
||||
ControlBoard {
|
||||
id: "cv1835",
|
||||
vendor: Vendor::Bitmain,
|
||||
},
|
||||
ControlBoard {
|
||||
id: "a113d",
|
||||
vendor: Vendor::Bitmain,
|
||||
},
|
||||
ControlBoard {
|
||||
id: "allwinner-h3",
|
||||
vendor: Vendor::Whatsminer,
|
||||
},
|
||||
ControlBoard {
|
||||
id: "allwinner-h6",
|
||||
vendor: Vendor::Whatsminer,
|
||||
},
|
||||
ControlBoard {
|
||||
id: "allwinner-h616",
|
||||
vendor: Vendor::Whatsminer,
|
||||
},
|
||||
];
|
||||
|
||||
pub const HASH_CHIPS: [HashChip; 17] = [
|
||||
HashChip {
|
||||
id: "BM1384",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1387",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1360",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1362",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1366",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1368",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1370",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1396",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1397",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1398",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1489",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Scrypt,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1491",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Scrypt,
|
||||
},
|
||||
HashChip {
|
||||
id: "BM1746",
|
||||
vendor: Vendor::Bitmain,
|
||||
algorithm: Algorithm::Equihash,
|
||||
},
|
||||
HashChip {
|
||||
id: "KF1950",
|
||||
vendor: Vendor::Whatsminer,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "ID-1968",
|
||||
vendor: Vendor::Whatsminer,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "ID-1980",
|
||||
vendor: Vendor::Whatsminer,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
HashChip {
|
||||
id: "ID-1990",
|
||||
vendor: Vendor::Whatsminer,
|
||||
algorithm: Algorithm::Sha256,
|
||||
},
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Target {
|
||||
pub control: ControlBoard,
|
||||
pub chip: HashChip,
|
||||
}
|
||||
|
||||
impl Target {
|
||||
pub fn new(control: ControlBoard, chip: HashChip) -> Option<Self> {
|
||||
(control.vendor == chip.vendor).then_some(Self { control, chip })
|
||||
}
|
||||
}
|
||||
|
||||
/// Every same-vendor theoretical pairing is in scope for Alkane OS.
|
||||
pub fn target_matrix() -> impl Iterator<Item = Target> {
|
||||
CONTROL_BOARDS.into_iter().flat_map(|control| {
|
||||
HASH_CHIPS
|
||||
.into_iter()
|
||||
.filter_map(move |chip| Target::new(control, chip))
|
||||
})
|
||||
}
|
||||
|
||||
/// Hardware operations implemented by a board backend in the SDK image.
|
||||
/// The methods deliberately expose no assumed UART, FPGA or Bitmicro layout.
|
||||
pub trait HardwareBackend {
|
||||
type Error;
|
||||
|
||||
fn send_frame(&mut self, chain: u8, frame: &[u8]) -> Result<(), Self::Error>;
|
||||
fn receive_frame(&mut self, chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error>;
|
||||
fn set_chain_reset(&mut self, chain: u8, asserted: bool) -> Result<(), Self::Error>;
|
||||
fn set_fan_target(&mut self, fan: u8, percent: u8) -> Result<(), Self::Error>;
|
||||
fn read_temperature_mc(&mut self, sensor: u8) -> Result<i32, Self::Error>;
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error>;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum PowerDecision {
|
||||
Hold,
|
||||
Stop,
|
||||
}
|
||||
|
||||
/// A safe starting policy: no hashing while temperature is unknown or unsafe.
|
||||
/// Board-specific thresholds will come from measured, revision-specific data.
|
||||
pub fn power_decision(temperature_mc: Option<i32>, max_mc: i32) -> PowerDecision {
|
||||
match temperature_mc {
|
||||
Some(value) if value < max_mc => PowerDecision::Hold,
|
||||
_ => PowerDecision::Stop,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn all_theoretical_same_vendor_targets_are_included() {
|
||||
let targets: Vec<_> = target_matrix().collect();
|
||||
assert_eq!(targets.len(), 4 * 13 + 3 * 4);
|
||||
assert!(targets.iter().all(|t| t.control.vendor == t.chip.vendor));
|
||||
for control in CONTROL_BOARDS {
|
||||
for chip in HASH_CHIPS {
|
||||
assert_eq!(
|
||||
targets.contains(&Target { control, chip }),
|
||||
control.vendor == chip.vendor
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_or_hot_sensor_stops_power() {
|
||||
assert_eq!(power_decision(None, 80_000), PowerDecision::Stop);
|
||||
assert_eq!(power_decision(Some(80_000), 80_000), PowerDecision::Stop);
|
||||
assert_eq!(power_decision(Some(79_999), 80_000), PowerDecision::Hold);
|
||||
}
|
||||
}
|
||||
@@ -1,107 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::management::{bind_local, serve, MiningStatus};
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel};
|
||||
use alkane_os::stratum_client::{PoolConnection, PoolEvent};
|
||||
use alkane_os::target_matrix;
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
fn sim_mine(mut args: impl Iterator<Item = String>) -> Result<(), Box<dyn Error>> {
|
||||
let socket = args.next().ok_or("missing HAL socket")?;
|
||||
let address: SocketAddr = args.next().ok_or("missing pool address")?.parse()?;
|
||||
let worker = args.next().ok_or("missing pool worker")?;
|
||||
let chip = match args.next().as_deref() {
|
||||
Some("BM1362") => ChipModel::Bm1362,
|
||||
Some("BM1366") => ChipModel::Bm1366,
|
||||
_ => return Err("select BM1362 or BM1366".into()),
|
||||
};
|
||||
let max_accepts: Option<u64> = args.next().map(|value| value.parse()).transpose()?;
|
||||
if args.next().is_some() || worker.is_empty() || max_accepts == Some(0) {
|
||||
return Err("invalid simulator mining arguments".into());
|
||||
}
|
||||
let password = std::env::var("ALKANE_POOL_PASSWORD")
|
||||
.map_err(|_| "set ALKANE_POOL_PASSWORD in the environment")?;
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
if let Ok(bind) = std::env::var("ALKANE_API_LISTEN") {
|
||||
let listener = bind_local(bind.parse()?)?;
|
||||
let snapshot = Arc::clone(&status);
|
||||
std::thread::spawn(move || {
|
||||
if let Err(error) = serve(listener, snapshot) {
|
||||
eprintln!("management API stopped: {error}");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Connect to the pool before enabling power. The SDK HAL server owns the
|
||||
// power lease and cuts power if this process stalls or disconnects.
|
||||
let mut pool = PoolConnection::connect(
|
||||
address,
|
||||
concat!("alkane-os/", env!("CARGO_PKG_VERSION")),
|
||||
&worker,
|
||||
&password,
|
||||
Duration::from_secs(2),
|
||||
Duration::from_secs(5),
|
||||
)
|
||||
.map_err(|error| io::Error::other(format!("pool handshake: {error:?}")))?;
|
||||
let mut backend = HalClient::connect(socket)?;
|
||||
let mut miner = Bm1366Miner::new_for_chip(&mut backend, chip, 0, 0, 0, 100, 80_000)
|
||||
.ok_or("invalid simulator safety configuration")?;
|
||||
miner.start()?;
|
||||
status.set_running(true);
|
||||
let mut accepted = 0_u64;
|
||||
loop {
|
||||
let (event, reports) = pool
|
||||
.cycle(&mut miner)
|
||||
.map_err(|error| io::Error::other(format!("mining cycle: {error:?}")))?;
|
||||
match event {
|
||||
PoolEvent::ShareAccepted(_) => {
|
||||
accepted += 1;
|
||||
status.share_accepted();
|
||||
if max_accepts == Some(accepted) {
|
||||
miner.stop()?;
|
||||
status.set_running(false);
|
||||
println!("simulator shares accepted: {accepted}");
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
PoolEvent::ShareRejected(id) => {
|
||||
status.share_rejected();
|
||||
eprintln!("pool rejected share request {id}");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if matches!(event, PoolEvent::Idle) && reports.is_empty() {
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
match args.next().as_deref() {
|
||||
Some("--list-targets") => {
|
||||
println!("control_board,hash_chip,algorithm");
|
||||
for target in target_matrix() {
|
||||
println!(
|
||||
"{},{},{:?}",
|
||||
target.control.id, target.chip.id, target.chip.algorithm
|
||||
);
|
||||
}
|
||||
}
|
||||
Some("--version") => println!("alkane-os {}", env!("CARGO_PKG_VERSION")),
|
||||
Some("--mine-simulator") => {
|
||||
if let Err(error) = sim_mine(args) {
|
||||
eprintln!("simulator mining failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
eprintln!("usage: alkane-os --list-targets | --version | --mine-simulator HAL_SOCKET POOL_ADDRESS WORKER BM1362|BM1366 [MAX_ACCEPTS]");
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,249 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded, read-only cgminer-style status for a local management client.
|
||||
|
||||
use serde_json::{json, Value};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
|
||||
|
||||
const MAX_REQUEST_BYTES: usize = 2048;
|
||||
const CLIENT_TIMEOUT: Duration = Duration::from_millis(500);
|
||||
const REQUEST_DEADLINE: Duration = Duration::from_secs(2);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct MiningStatus {
|
||||
started: Instant,
|
||||
running: AtomicBool,
|
||||
accepted: AtomicU64,
|
||||
rejected: AtomicU64,
|
||||
}
|
||||
|
||||
impl Default for MiningStatus {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl MiningStatus {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
started: Instant::now(),
|
||||
running: AtomicBool::new(false),
|
||||
accepted: AtomicU64::new(0),
|
||||
rejected: AtomicU64::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_running(&self, running: bool) {
|
||||
self.running.store(running, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
pub fn share_accepted(&self) {
|
||||
self.accepted.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
pub fn share_rejected(&self) {
|
||||
self.rejected.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
fn response(&self, command: &str) -> Value {
|
||||
let now = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_secs();
|
||||
let (code, description, payload) = match command {
|
||||
"summary" => (
|
||||
"S",
|
||||
"Summary",
|
||||
json!({"SUMMARY": [{
|
||||
"Elapsed": self.started.elapsed().as_secs(),
|
||||
"Accepted": self.accepted.load(Ordering::Relaxed),
|
||||
"Rejected": self.rejected.load(Ordering::Relaxed),
|
||||
"Status": if self.running.load(Ordering::Relaxed) { "Mining" } else { "Stopped" }
|
||||
}]}),
|
||||
),
|
||||
"version" => (
|
||||
"S",
|
||||
"Version",
|
||||
json!({"VERSION": [{
|
||||
"Miner": concat!("alkane-os/", env!("CARGO_PKG_VERSION")),
|
||||
"API": "1.0"
|
||||
}]}),
|
||||
),
|
||||
_ => ("E", "Unknown command", json!({})),
|
||||
};
|
||||
let mut response = json!({"STATUS": [{
|
||||
"STATUS": code,
|
||||
"When": now,
|
||||
"Code": if code == "S" { 0 } else { 14 },
|
||||
"Msg": description,
|
||||
"Description": "alkane-os"
|
||||
}]});
|
||||
response
|
||||
.as_object_mut()
|
||||
.unwrap()
|
||||
.extend(payload.as_object().unwrap().clone());
|
||||
response
|
||||
}
|
||||
}
|
||||
|
||||
fn request_command(bytes: &[u8]) -> Option<&str> {
|
||||
let request = std::str::from_utf8(bytes).ok()?.trim();
|
||||
if request.starts_with('{') {
|
||||
let value: Value = serde_json::from_str(request).ok()?;
|
||||
let command = value.get("command")?.as_str()?;
|
||||
match command {
|
||||
"summary" => Some("summary"),
|
||||
"version" => Some("version"),
|
||||
_ => Some("unknown"),
|
||||
}
|
||||
} else {
|
||||
match request {
|
||||
"summary" => Some("summary"),
|
||||
"version" => Some("version"),
|
||||
_ => Some("unknown"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle(mut stream: TcpStream, status: &MiningStatus) -> io::Result<()> {
|
||||
stream.set_write_timeout(Some(CLIENT_TIMEOUT))?;
|
||||
let mut request = Vec::new();
|
||||
let mut chunk = [0_u8; 256];
|
||||
let deadline = Instant::now() + REQUEST_DEADLINE;
|
||||
loop {
|
||||
let remaining = deadline.saturating_duration_since(Instant::now());
|
||||
if remaining.is_zero() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::TimedOut,
|
||||
"management request deadline",
|
||||
));
|
||||
}
|
||||
stream.set_read_timeout(Some(CLIENT_TIMEOUT.min(remaining)))?;
|
||||
let count = match stream.read(&mut chunk) {
|
||||
Ok(count) => count,
|
||||
Err(error) if error.kind() == io::ErrorKind::TimedOut && !request.is_empty() => break,
|
||||
Err(error) if error.kind() == io::ErrorKind::WouldBlock && !request.is_empty() => break,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
if count == 0 {
|
||||
break;
|
||||
}
|
||||
if request.len() + count > MAX_REQUEST_BYTES {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"management request too large",
|
||||
));
|
||||
}
|
||||
request.extend_from_slice(&chunk[..count]);
|
||||
if request.contains(&b'\n') || request.contains(&0) {
|
||||
break;
|
||||
}
|
||||
if matches!(request_command(&request), Some("summary" | "version"))
|
||||
|| serde_json::from_slice::<Value>(&request).is_ok()
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
let end = request
|
||||
.iter()
|
||||
.position(|byte| *byte == 0 || *byte == b'\n')
|
||||
.unwrap_or(request.len());
|
||||
let command = request_command(&request[..end]).unwrap_or("unknown");
|
||||
let mut reply = serde_json::to_vec(&status.response(command)).map_err(io::Error::other)?;
|
||||
reply.push(0);
|
||||
stream.write_all(&reply)
|
||||
}
|
||||
|
||||
/// Bind only to loopback. The board management plane can be reached through SSH.
|
||||
pub fn bind_local(address: SocketAddr) -> io::Result<TcpListener> {
|
||||
if !address.ip().is_loopback() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"management API requires loopback address",
|
||||
));
|
||||
}
|
||||
TcpListener::bind(address)
|
||||
}
|
||||
|
||||
pub fn serve(listener: TcpListener, status: Arc<MiningStatus>) -> io::Result<()> {
|
||||
for stream in listener.incoming() {
|
||||
let stream = stream?;
|
||||
if let Err(error) = handle(stream, &status) {
|
||||
eprintln!("management request failed: {error}");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::net::TcpStream;
|
||||
|
||||
#[test]
|
||||
fn refuses_nonlocal_bind() {
|
||||
let address = "0.0.0.0:0".parse().unwrap();
|
||||
assert_eq!(
|
||||
bind_local(address).unwrap_err().kind(),
|
||||
io::ErrorKind::InvalidInput
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_only_observed_share_counts() {
|
||||
let status = MiningStatus::new();
|
||||
status.set_running(true);
|
||||
status.share_accepted();
|
||||
status.share_rejected();
|
||||
let reply = status.response("summary");
|
||||
assert_eq!(reply["SUMMARY"][0]["Accepted"], 1);
|
||||
assert_eq!(reply["SUMMARY"][0]["Rejected"], 1);
|
||||
assert_eq!(reply["SUMMARY"][0]["Status"], "Mining");
|
||||
assert!(reply["SUMMARY"][0].get("MHS av").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn local_socket_uses_nul_terminated_cgminer_envelope() {
|
||||
let listener = bind_local("127.0.0.1:0".parse().unwrap()).unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().unwrap();
|
||||
handle(stream, &status).unwrap();
|
||||
});
|
||||
let mut client = TcpStream::connect(address).unwrap();
|
||||
client.write_all(b"{\"command\":\"summary\"}\n").unwrap();
|
||||
let mut reply = Vec::new();
|
||||
client.read_to_end(&mut reply).unwrap();
|
||||
assert_eq!(reply.pop(), Some(0));
|
||||
let parsed: Value = serde_json::from_slice(&reply).unwrap();
|
||||
assert_eq!(parsed["STATUS"][0]["STATUS"], "S");
|
||||
assert_eq!(parsed["SUMMARY"][0]["Status"], "Stopped");
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fragmented_plain_command_is_not_answered_early() {
|
||||
let listener = bind_local("127.0.0.1:0".parse().unwrap()).unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().unwrap();
|
||||
handle(stream, &status).unwrap();
|
||||
});
|
||||
let mut client = TcpStream::connect(address).unwrap();
|
||||
client.write_all(b"sum").unwrap();
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
client.write_all(b"mary").unwrap();
|
||||
let mut reply = Vec::new();
|
||||
client.read_to_end(&mut reply).unwrap();
|
||||
assert_eq!(reply.pop(), Some(0));
|
||||
let parsed: Value = serde_json::from_slice(&reply).unwrap();
|
||||
assert_eq!(parsed["STATUS"][0]["STATUS"], "S");
|
||||
assert!(parsed.get("SUMMARY").is_some());
|
||||
worker.join().unwrap();
|
||||
}
|
||||
}
|
||||
@@ -1,327 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! One-chain BM13xx mining control built on the SDK hardware backend.
|
||||
//! This module never searches for nonces or chooses board safety thresholds.
|
||||
|
||||
use crate::bm1362;
|
||||
use crate::bm1366::{decode_nonce_report, encode_work, ReportError, REPORT_BYTES};
|
||||
use crate::pow::verify_sha256_report;
|
||||
use crate::{power_decision, HardwareBackend, PowerDecision};
|
||||
use std::fmt;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ChipModel {
|
||||
Bm1362,
|
||||
Bm1366,
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum MinerError<E> {
|
||||
Backend(E),
|
||||
AlreadyRunning,
|
||||
NotRunning,
|
||||
Faulted,
|
||||
WorkIdInUse(u8),
|
||||
UnsafeTemperature(i32),
|
||||
InvalidWork,
|
||||
InvalidReport(ReportError),
|
||||
StaleReport,
|
||||
BelowTarget,
|
||||
}
|
||||
|
||||
impl<E: fmt::Display> fmt::Display for MinerError<E> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Backend(error) => write!(f, "hardware backend: {error}"),
|
||||
Self::AlreadyRunning => f.write_str("miner is already running"),
|
||||
Self::NotRunning => f.write_str("miner is not running"),
|
||||
Self::Faulted => f.write_str("miner shutdown is unconfirmed"),
|
||||
Self::WorkIdInUse(id) => write!(f, "BM13xx work ID {id} is still in use"),
|
||||
Self::UnsafeTemperature(value) => write!(f, "unsafe temperature: {value} mC"),
|
||||
Self::InvalidWork => f.write_str("invalid BM13xx work"),
|
||||
Self::InvalidReport(error) => write!(f, "invalid BM13xx report: {error:?}"),
|
||||
Self::StaleReport => f.write_str("stale BM13xx work ID"),
|
||||
Self::BelowTarget => f.write_str("nonce is below the pool target"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: std::error::Error + 'static> std::error::Error for MinerError<E> {}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ValidShare {
|
||||
pub nonce: u32,
|
||||
pub work_id: u8,
|
||||
pub rolled_version: u32,
|
||||
pub hash_le: [u8; 32],
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct Work {
|
||||
header: [u8; 80],
|
||||
target_le: [u8; 32],
|
||||
id: u8,
|
||||
}
|
||||
|
||||
pub struct Bm1366Miner<'a, B: HardwareBackend> {
|
||||
backend: &'a mut B,
|
||||
chip: ChipModel,
|
||||
chain: u8,
|
||||
sensor: u8,
|
||||
fan: u8,
|
||||
fan_percent: u8,
|
||||
max_temperature_mc: i32,
|
||||
running: bool,
|
||||
faulted: bool,
|
||||
work: [Option<Work>; 32],
|
||||
used_work_ids: [bool; 32],
|
||||
}
|
||||
|
||||
impl<'a, B: HardwareBackend> Bm1366Miner<'a, B> {
|
||||
/// The caller supplies a threshold validated for this board revision.
|
||||
pub fn new(
|
||||
backend: &'a mut B,
|
||||
chain: u8,
|
||||
sensor: u8,
|
||||
fan: u8,
|
||||
fan_percent: u8,
|
||||
max_temperature_mc: i32,
|
||||
) -> Option<Self> {
|
||||
Self::new_for_chip(
|
||||
backend,
|
||||
ChipModel::Bm1366,
|
||||
chain,
|
||||
sensor,
|
||||
fan,
|
||||
fan_percent,
|
||||
max_temperature_mc,
|
||||
)
|
||||
}
|
||||
|
||||
/// Select the captured BM1362 or BM1366 work format explicitly.
|
||||
pub fn new_for_chip(
|
||||
backend: &'a mut B,
|
||||
chip: ChipModel,
|
||||
chain: u8,
|
||||
sensor: u8,
|
||||
fan: u8,
|
||||
fan_percent: u8,
|
||||
max_temperature_mc: i32,
|
||||
) -> Option<Self> {
|
||||
if fan_percent == 0 || fan_percent > 100 || max_temperature_mc <= 0 {
|
||||
return None;
|
||||
}
|
||||
Some(Self {
|
||||
backend,
|
||||
chip,
|
||||
chain,
|
||||
sensor,
|
||||
fan,
|
||||
fan_percent,
|
||||
max_temperature_mc,
|
||||
running: false,
|
||||
faulted: false,
|
||||
work: [None; 32],
|
||||
used_work_ids: [false; 32],
|
||||
})
|
||||
}
|
||||
|
||||
fn power_off(&mut self) -> Result<(), B::Error> {
|
||||
self.work = [None; 32];
|
||||
match self.backend.set_psu_enabled(false) {
|
||||
Ok(()) => {
|
||||
self.running = false;
|
||||
self.faulted = false;
|
||||
self.used_work_ids = [false; 32];
|
||||
Ok(())
|
||||
}
|
||||
Err(error) => {
|
||||
// The backend may have left power on. Drop retries shutdown.
|
||||
self.running = true;
|
||||
self.faulted = true;
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_temperature(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
let value = match self.backend.read_temperature_mc(self.sensor) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
};
|
||||
if power_decision(Some(value), self.max_temperature_mc) == PowerDecision::Stop {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::UnsafeTemperature(value));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn start(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
if self.running {
|
||||
return Err(MinerError::AlreadyRunning);
|
||||
}
|
||||
self.power_off().map_err(MinerError::Backend)?;
|
||||
self.check_temperature()?;
|
||||
self.backend
|
||||
.set_fan_target(self.fan, self.fan_percent)
|
||||
.map_err(MinerError::Backend)?;
|
||||
if let Err(error) = self.backend.set_psu_enabled(true) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
self.running = true;
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, true) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, false) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn stop(&mut self) -> Result<(), B::Error> {
|
||||
self.power_off()
|
||||
}
|
||||
|
||||
/// Flush the ASIC's in-flight work before reusing any work IDs. A reset
|
||||
/// failure shuts the PSU down because old reports may still arrive.
|
||||
pub fn reset_chain(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.work = [None; 32];
|
||||
self.check_temperature()?;
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, true) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
if let Err(error) = self.backend.set_chain_reset(self.chain, false) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
self.used_work_ids = [false; 32];
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn submit(
|
||||
&mut self,
|
||||
header: [u8; 80],
|
||||
target_le: [u8; 32],
|
||||
work_id: u8,
|
||||
) -> Result<(), MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.check_temperature()?;
|
||||
let frame = match self.chip {
|
||||
ChipModel::Bm1362 => bm1362::encode_work(&header, work_id),
|
||||
ChipModel::Bm1366 => encode_work(&header, work_id),
|
||||
}
|
||||
.ok_or(MinerError::InvalidWork)?;
|
||||
let slot = usize::from(work_id >> 3);
|
||||
if self.used_work_ids[slot] {
|
||||
return Err(MinerError::WorkIdInUse(work_id));
|
||||
}
|
||||
// A failed send may still have reached the ASIC, so reserve first.
|
||||
self.used_work_ids[slot] = true;
|
||||
if let Err(error) = self.backend.send_frame(self.chain, &frame) {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
self.work[slot] = Some(Work {
|
||||
header,
|
||||
target_le,
|
||||
id: work_id,
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Forget prior pool jobs after `clean_jobs`, while leaving the ASIC powered.
|
||||
/// Reports already in flight are then classified as stale. Their work IDs
|
||||
/// remain reserved until a confirmed chain reset or PSU shutdown.
|
||||
pub fn clear_work(&mut self) {
|
||||
self.work = [None; 32];
|
||||
}
|
||||
|
||||
pub fn poll(&mut self) -> Result<Option<ValidShare>, MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.check_temperature()?;
|
||||
let mut frame = [0_u8; REPORT_BYTES];
|
||||
let length = match self.backend.receive_frame(self.chain, &mut frame) {
|
||||
Ok(length) => length,
|
||||
Err(error) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::Backend(error));
|
||||
}
|
||||
};
|
||||
if length == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let report = match decode_nonce_report(&frame[..length.min(REPORT_BYTES)]) {
|
||||
Ok(report) if length == REPORT_BYTES => report,
|
||||
Ok(_) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::InvalidReport(ReportError::Length));
|
||||
}
|
||||
Err(error) => {
|
||||
let _ = self.power_off();
|
||||
return Err(MinerError::InvalidReport(error));
|
||||
}
|
||||
};
|
||||
let Some(work) = self.work[usize::from(report.work_id >> 3)] else {
|
||||
return Err(MinerError::StaleReport);
|
||||
};
|
||||
if report.work_id != work.id {
|
||||
return Err(MinerError::StaleReport);
|
||||
}
|
||||
let check = verify_sha256_report(
|
||||
&work.header,
|
||||
report.nonce,
|
||||
report.version_field,
|
||||
&work.target_le,
|
||||
);
|
||||
if !check.meets_target {
|
||||
return Err(MinerError::BelowTarget);
|
||||
}
|
||||
Ok(Some(ValidShare {
|
||||
nonce: report.nonce,
|
||||
work_id: report.work_id,
|
||||
rolled_version: check.rolled_version,
|
||||
hash_le: check.hash_le,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Keep thermal supervision active while pool share replies are pending.
|
||||
pub fn supervise(&mut self) -> Result<(), MinerError<B::Error>> {
|
||||
if !self.running {
|
||||
return Err(MinerError::NotRunning);
|
||||
}
|
||||
if self.faulted {
|
||||
return Err(MinerError::Faulted);
|
||||
}
|
||||
self.check_temperature()
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: HardwareBackend> Drop for Bm1366Miner<'_, B> {
|
||||
fn drop(&mut self) {
|
||||
if self.running {
|
||||
let _ = self.power_off();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,238 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Verify reported SHA-256d shares. This module does not search for nonces.
|
||||
|
||||
const BM1366_VERSION_BITS: u32 = 0x1FFF_E000;
|
||||
|
||||
const ROUND: [u32; 64] = [
|
||||
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
||||
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
||||
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
||||
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
||||
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
||||
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
||||
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
||||
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
|
||||
];
|
||||
|
||||
const INITIAL: [u32; 8] = [
|
||||
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
|
||||
];
|
||||
|
||||
fn compress(state: &mut [u32; 8], block: &[u8]) {
|
||||
let mut words = [0_u32; 64];
|
||||
for (index, part) in block.chunks_exact(4).enumerate() {
|
||||
words[index] = u32::from_be_bytes(part.try_into().expect("four-byte word"));
|
||||
}
|
||||
for index in 16..64 {
|
||||
let a = words[index - 15];
|
||||
let b = words[index - 2];
|
||||
let small_zero = a.rotate_right(7) ^ a.rotate_right(18) ^ (a >> 3);
|
||||
let small_one = b.rotate_right(17) ^ b.rotate_right(19) ^ (b >> 10);
|
||||
words[index] = words[index - 16]
|
||||
.wrapping_add(small_zero)
|
||||
.wrapping_add(words[index - 7])
|
||||
.wrapping_add(small_one);
|
||||
}
|
||||
|
||||
let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = *state;
|
||||
for index in 0..64 {
|
||||
let choose = (e & f) ^ (!e & g);
|
||||
let majority = (a & b) ^ (a & c) ^ (b & c);
|
||||
let big_one = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25);
|
||||
let big_zero = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22);
|
||||
let first = h
|
||||
.wrapping_add(big_one)
|
||||
.wrapping_add(choose)
|
||||
.wrapping_add(ROUND[index])
|
||||
.wrapping_add(words[index]);
|
||||
let second = big_zero.wrapping_add(majority);
|
||||
h = g;
|
||||
g = f;
|
||||
f = e;
|
||||
e = d.wrapping_add(first);
|
||||
d = c;
|
||||
c = b;
|
||||
b = a;
|
||||
a = first.wrapping_add(second);
|
||||
}
|
||||
for (current, result) in state.iter_mut().zip([a, b, c, d, e, f, g, h]) {
|
||||
*current = current.wrapping_add(result);
|
||||
}
|
||||
}
|
||||
|
||||
/// Compute SHA-256 for a message whose length fits the standard 64-bit field.
|
||||
pub fn sha256(message: &[u8]) -> [u8; 32] {
|
||||
let mut state = INITIAL;
|
||||
let chunks = message.chunks_exact(64);
|
||||
let remainder = chunks.remainder();
|
||||
for chunk in chunks {
|
||||
compress(&mut state, chunk);
|
||||
}
|
||||
let final_size = if remainder.len() >= 56 { 128 } else { 64 };
|
||||
let mut final_blocks = [0_u8; 128];
|
||||
final_blocks[..remainder.len()].copy_from_slice(remainder);
|
||||
final_blocks[remainder.len()] = 0x80;
|
||||
final_blocks[final_size - 8..final_size]
|
||||
.copy_from_slice(&((message.len() as u64).wrapping_mul(8)).to_be_bytes());
|
||||
for chunk in final_blocks[..final_size].chunks_exact(64) {
|
||||
compress(&mut state, chunk);
|
||||
}
|
||||
let mut digest = [0_u8; 32];
|
||||
for (word, bytes) in state.into_iter().zip(digest.chunks_exact_mut(4)) {
|
||||
bytes.copy_from_slice(&word.to_be_bytes());
|
||||
}
|
||||
digest
|
||||
}
|
||||
|
||||
/// Compute one double hash for verification, never for nonce search.
|
||||
pub fn sha256d(message: &[u8]) -> [u8; 32] {
|
||||
sha256(&sha256(message))
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ShareCheck {
|
||||
pub rolled_version: u32,
|
||||
pub hash_le: [u8; 32],
|
||||
pub meets_target: bool,
|
||||
}
|
||||
|
||||
/// Decode the raw BM1366 version extension against the version sent to the ASIC.
|
||||
/// The chip reports additional set bits; pool submission uses a separate mask.
|
||||
pub fn decode_bm1366_version(job_version: u32, version_field: u16) -> u32 {
|
||||
job_version | ((u32::from(version_field) << 13) & BM1366_VERSION_BITS)
|
||||
}
|
||||
|
||||
/// The BIP310 mask negotiated with a pool, limited to BM1366 rolling bits.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct VersionMask(u32);
|
||||
|
||||
impl VersionMask {
|
||||
pub fn new(mask: u32) -> Option<Self> {
|
||||
(mask & !BM1366_VERSION_BITS == 0).then_some(Self(mask))
|
||||
}
|
||||
|
||||
pub fn apply_submission_bits(self, base_version: u32, version_bits: u32) -> Option<u32> {
|
||||
(version_bits & !self.0 == 0).then_some((base_version & !self.0) | version_bits)
|
||||
}
|
||||
|
||||
pub fn bits(self) -> u32 {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
/// Check one ASIC-reported nonce against a little-endian 256-bit pool target.
|
||||
pub fn verify_sha256_report(
|
||||
nonce_zero_header: &[u8; 80],
|
||||
nonce: u32,
|
||||
version_field: u16,
|
||||
target_le: &[u8; 32],
|
||||
) -> ShareCheck {
|
||||
let mut header = *nonce_zero_header;
|
||||
let base_version = u32::from_le_bytes(header[..4].try_into().expect("version field"));
|
||||
let rolled_version = decode_bm1366_version(base_version, version_field);
|
||||
header[..4].copy_from_slice(&rolled_version.to_le_bytes());
|
||||
header[76..80].copy_from_slice(&nonce.to_le_bytes());
|
||||
let hash_le = sha256d(&header);
|
||||
let meets_target = hash_le.iter().rev().cmp(target_le.iter().rev()).is_le();
|
||||
ShareCheck {
|
||||
rolled_version,
|
||||
hash_le,
|
||||
meets_target,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn hex(bytes: &[u8]) -> String {
|
||||
bytes.iter().map(|byte| format!("{byte:02x}")).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sha256_matches_standard_padding_vectors() {
|
||||
let vectors: [(&[u8], &str); 6] = [
|
||||
(
|
||||
b"",
|
||||
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
|
||||
),
|
||||
(
|
||||
b"abc",
|
||||
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
|
||||
),
|
||||
(
|
||||
&(0_u8..55).collect::<Vec<_>>(),
|
||||
"463eb28e72f82e0a96c0a4cc53690c571281131f672aa229e0d45ae59b598b59",
|
||||
),
|
||||
(
|
||||
&(0_u8..56).collect::<Vec<_>>(),
|
||||
"da2ae4d6b36748f2a318f23e7ab1dfdf45acdc9d049bd80e59de82a60895f562",
|
||||
),
|
||||
(
|
||||
&(0_u8..64).collect::<Vec<_>>(),
|
||||
"fdeab9acf3710362bd2658cdc9a29e8f9c757fcf9811603a8c447cd1d9151108",
|
||||
),
|
||||
(
|
||||
&(0_u8..100).collect::<Vec<_>>(),
|
||||
"bce0aff19cf5aa6a7469a30d61d04e4376e4bbf6381052ee9e7f33925c954d52",
|
||||
),
|
||||
];
|
||||
for (message, expected) in vectors {
|
||||
assert_eq!(hex(&sha256(message)), expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_bm1366_report_meets_diff_one_only_with_rolled_version() {
|
||||
let header = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62,
|
||||
0x38, 0x9d, 0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b,
|
||||
0x57, 0xb6, 0xc2, 0x25, 0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4,
|
||||
0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78, 0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd,
|
||||
0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38, 0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01,
|
||||
0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
let mut diff_one = [0_u8; 32];
|
||||
diff_one[26..28].fill(0xff);
|
||||
let result = verify_sha256_report(&header, 0xEDAD_FF38, 0x04B3, &diff_one);
|
||||
assert_eq!(result.rolled_version, 0x2096_6000);
|
||||
assert_eq!(
|
||||
hex(&result.hash_le),
|
||||
"4b5e00850cf9de9809f822f8858eda39e49996d9d40f634f1043290000000000"
|
||||
);
|
||||
assert!(result.meets_target);
|
||||
assert!(!verify_sha256_report(&header, 0xEDAD_FF38, 0, &diff_one).meets_target);
|
||||
assert!(!verify_sha256_report(&header, 0xEDAD_FF39, 0x04B3, &diff_one).meets_target);
|
||||
assert!(verify_sha256_report(&header, 0xEDAD_FF38, 0x04B3, &[0xff; 32]).meets_target);
|
||||
assert!(!verify_sha256_report(&header, 0xEDAD_FF38, 0x04B3, &[0; 32]).meets_target);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raw_asic_version_preserves_bits_sent_to_chip() {
|
||||
assert_eq!(decode_bm1366_version(0x2100_0004, 1), 0x2100_2004);
|
||||
assert_eq!(decode_bm1366_version(0x2000_0000, 0), 0x2000_0000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_version_bits_replace_only_negotiated_mask() {
|
||||
let mask = VersionMask::new(0x0060_0000).expect("valid restricted mask");
|
||||
assert_eq!(
|
||||
mask.apply_submission_bits(0x2160_0004, 0x0020_0000),
|
||||
Some(0x2120_0004)
|
||||
);
|
||||
assert_eq!(mask.apply_submission_bits(0x2160_0004, 0x0080_0000), None);
|
||||
assert_eq!(
|
||||
VersionMask::new(0)
|
||||
.unwrap()
|
||||
.apply_submission_bits(0x2100_0004, 0),
|
||||
Some(0x2100_0004)
|
||||
);
|
||||
assert_eq!(
|
||||
VersionMask::new(BM1366_VERSION_BITS)
|
||||
.unwrap()
|
||||
.apply_submission_bits(0x2160_0004, 0),
|
||||
Some(0x2000_0004)
|
||||
);
|
||||
assert!(VersionMask::new(0x8000_0000).is_none());
|
||||
}
|
||||
}
|
||||
@@ -1,170 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Litecoin's fixed scrypt proof-of-work hash for validating reported shares.
|
||||
//! This module hashes one supplied header and never searches for a nonce.
|
||||
|
||||
use crate::pow::sha256;
|
||||
|
||||
const N: usize = 1024;
|
||||
|
||||
fn hmac_sha256(key: &[u8], message: &[u8]) -> [u8; 32] {
|
||||
let mut block = [0_u8; 64];
|
||||
if key.len() > block.len() {
|
||||
block[..32].copy_from_slice(&sha256(key));
|
||||
} else {
|
||||
block[..key.len()].copy_from_slice(key);
|
||||
}
|
||||
let mut inner = Vec::with_capacity(64 + message.len());
|
||||
inner.extend(block.iter().map(|byte| byte ^ 0x36));
|
||||
inner.extend_from_slice(message);
|
||||
let inner_hash = sha256(&inner);
|
||||
let mut outer = [0_u8; 96];
|
||||
for (destination, byte) in outer[..64].iter_mut().zip(block) {
|
||||
*destination = byte ^ 0x5c;
|
||||
}
|
||||
outer[64..].copy_from_slice(&inner_hash);
|
||||
sha256(&outer)
|
||||
}
|
||||
|
||||
// PBKDF2-HMAC-SHA256 with the fixed single iteration specified for scrypt.
|
||||
fn pbkdf2_one(password: &[u8], salt: &[u8], output: &mut [u8]) {
|
||||
let mut message = Vec::with_capacity(salt.len() + 4);
|
||||
message.extend_from_slice(salt);
|
||||
message.extend_from_slice(&[0_u8; 4]);
|
||||
for (index, chunk) in output.chunks_mut(32).enumerate() {
|
||||
let block = u32::try_from(index + 1).expect("fixed scrypt output fits u32");
|
||||
message[salt.len()..].copy_from_slice(&block.to_be_bytes());
|
||||
chunk.copy_from_slice(&hmac_sha256(password, &message)[..chunk.len()]);
|
||||
}
|
||||
}
|
||||
|
||||
fn salsa20_8(input: &mut [u32; 16]) {
|
||||
let original = *input;
|
||||
let mut x = original;
|
||||
for _ in 0..4 {
|
||||
x[4] ^= x[0].wrapping_add(x[12]).rotate_left(7);
|
||||
x[8] ^= x[4].wrapping_add(x[0]).rotate_left(9);
|
||||
x[12] ^= x[8].wrapping_add(x[4]).rotate_left(13);
|
||||
x[0] ^= x[12].wrapping_add(x[8]).rotate_left(18);
|
||||
x[9] ^= x[5].wrapping_add(x[1]).rotate_left(7);
|
||||
x[13] ^= x[9].wrapping_add(x[5]).rotate_left(9);
|
||||
x[1] ^= x[13].wrapping_add(x[9]).rotate_left(13);
|
||||
x[5] ^= x[1].wrapping_add(x[13]).rotate_left(18);
|
||||
x[14] ^= x[10].wrapping_add(x[6]).rotate_left(7);
|
||||
x[2] ^= x[14].wrapping_add(x[10]).rotate_left(9);
|
||||
x[6] ^= x[2].wrapping_add(x[14]).rotate_left(13);
|
||||
x[10] ^= x[6].wrapping_add(x[2]).rotate_left(18);
|
||||
x[3] ^= x[15].wrapping_add(x[11]).rotate_left(7);
|
||||
x[7] ^= x[3].wrapping_add(x[15]).rotate_left(9);
|
||||
x[11] ^= x[7].wrapping_add(x[3]).rotate_left(13);
|
||||
x[15] ^= x[11].wrapping_add(x[7]).rotate_left(18);
|
||||
|
||||
x[1] ^= x[0].wrapping_add(x[3]).rotate_left(7);
|
||||
x[2] ^= x[1].wrapping_add(x[0]).rotate_left(9);
|
||||
x[3] ^= x[2].wrapping_add(x[1]).rotate_left(13);
|
||||
x[0] ^= x[3].wrapping_add(x[2]).rotate_left(18);
|
||||
x[6] ^= x[5].wrapping_add(x[4]).rotate_left(7);
|
||||
x[7] ^= x[6].wrapping_add(x[5]).rotate_left(9);
|
||||
x[4] ^= x[7].wrapping_add(x[6]).rotate_left(13);
|
||||
x[5] ^= x[4].wrapping_add(x[7]).rotate_left(18);
|
||||
x[11] ^= x[10].wrapping_add(x[9]).rotate_left(7);
|
||||
x[8] ^= x[11].wrapping_add(x[10]).rotate_left(9);
|
||||
x[9] ^= x[8].wrapping_add(x[11]).rotate_left(13);
|
||||
x[10] ^= x[9].wrapping_add(x[8]).rotate_left(18);
|
||||
x[12] ^= x[15].wrapping_add(x[14]).rotate_left(7);
|
||||
x[13] ^= x[12].wrapping_add(x[15]).rotate_left(9);
|
||||
x[14] ^= x[13].wrapping_add(x[12]).rotate_left(13);
|
||||
x[15] ^= x[14].wrapping_add(x[13]).rotate_left(18);
|
||||
}
|
||||
for ((word, initial), mixed) in input.iter_mut().zip(original).zip(x) {
|
||||
*word = initial.wrapping_add(mixed);
|
||||
}
|
||||
}
|
||||
|
||||
fn block_mix(input: &[u32; 32]) -> [u32; 32] {
|
||||
let mut x: [u32; 16] = input[16..].try_into().expect("fixed block size");
|
||||
let mut output = [0_u32; 32];
|
||||
for (index, chunk) in input.chunks_exact(16).enumerate() {
|
||||
for (word, source) in x.iter_mut().zip(chunk) {
|
||||
*word ^= source;
|
||||
}
|
||||
salsa20_8(&mut x);
|
||||
output[index * 16..(index + 1) * 16].copy_from_slice(&x);
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
/// Hash one 80-byte Litecoin header with scrypt(N=1024, r=1, p=1, dkLen=32).
|
||||
/// The return value is the raw little-endian PoW digest.
|
||||
pub fn scrypt_1024_1_1_256(header: &[u8; 80]) -> [u8; 32] {
|
||||
let mut initial = [0_u8; 128];
|
||||
pbkdf2_one(header, header, &mut initial);
|
||||
let mut x = [0_u32; 32];
|
||||
for (word, bytes) in x.iter_mut().zip(initial.chunks_exact(4)) {
|
||||
*word = u32::from_le_bytes(bytes.try_into().expect("four-byte word"));
|
||||
}
|
||||
let mut memory = vec![[0_u32; 32]; N];
|
||||
for saved in &mut memory {
|
||||
*saved = x;
|
||||
x = block_mix(&x);
|
||||
}
|
||||
for _ in 0..N {
|
||||
let index = x[16] as usize & (N - 1);
|
||||
for (word, saved) in x.iter_mut().zip(memory[index]) {
|
||||
*word ^= saved;
|
||||
}
|
||||
x = block_mix(&x);
|
||||
}
|
||||
for (word, bytes) in x.iter().zip(initial.chunks_exact_mut(4)) {
|
||||
bytes.copy_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
let mut digest = [0_u8; 32];
|
||||
pbkdf2_one(header, &initial, &mut digest);
|
||||
digest
|
||||
}
|
||||
|
||||
/// Validate one supplied header against an exact little-endian pool target.
|
||||
pub fn verify_scrypt_header(header: &[u8; 80], target_le: &[u8; 32]) -> ([u8; 32], bool) {
|
||||
let digest = scrypt_1024_1_1_256(header);
|
||||
let meets_target = digest.iter().rev().cmp(target_le.iter().rev()).is_le();
|
||||
(digest, meets_target)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn litecoin_block_29255_matches_published_scrypt_pow() {
|
||||
let header_hex = concat!(
|
||||
"01000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f27",
|
||||
"9fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4",
|
||||
"ea78e011d012d59d4"
|
||||
);
|
||||
let mut header = [0_u8; 80];
|
||||
for (byte, pair) in header.iter_mut().zip(header_hex.as_bytes().chunks_exact(2)) {
|
||||
*byte = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
let expected_big = "0000000110c8357966576df46f3b802ca897deb7ad18b12f1c24ecff6386ebd9";
|
||||
let mut expected = [0_u8; 32];
|
||||
for (byte, pair) in expected
|
||||
.iter_mut()
|
||||
.rev()
|
||||
.zip(expected_big.as_bytes().chunks_exact(2))
|
||||
{
|
||||
*byte = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
let (digest, accepted) = verify_scrypt_header(&header, &expected);
|
||||
assert_eq!(digest, expected);
|
||||
assert!(accepted);
|
||||
assert!(!verify_scrypt_header(&header, &[0_u8; 32]).1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixed_header_matches_independent_openssl_scrypt() {
|
||||
let header = core::array::from_fn(|index| index as u8);
|
||||
let expected = "bc540a1a801df96e493005c71e010e2d387607fbf0fec416fd3c2645aa1ba9d2";
|
||||
let actual = scrypt_1024_1_1_256(&header);
|
||||
let actual_hex: String = actual.iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
assert_eq!(actual_hex, expected);
|
||||
}
|
||||
}
|
||||
@@ -1,510 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! One bounded pool connection with ordered jobs and verified share replies.
|
||||
|
||||
use crate::miner::{Bm1366Miner, MinerError, ValidShare};
|
||||
use crate::stratum_session::{DispatchError, IssuedWork, PoolSession, SessionError};
|
||||
use crate::stratum_v1::{parse_boolean_response, PoolMessageError};
|
||||
use crate::stratum_wire::{HandshakeError, PoolHandshake, StratumWire, WireError};
|
||||
use crate::HardwareBackend;
|
||||
use serde_json::Value;
|
||||
use std::collections::VecDeque;
|
||||
use std::net::SocketAddr;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const MAX_PENDING_SHARES: usize = 32;
|
||||
const SHARE_REPLY_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
const MAX_REPORTS_PER_CYCLE: usize = 256;
|
||||
const POOL_WRITE_DEADLINE: Duration = Duration::from_millis(100);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ClientError<E> {
|
||||
Wire(WireError),
|
||||
Pool(PoolMessageError),
|
||||
Session(SessionError),
|
||||
Dispatch(DispatchError<E>),
|
||||
UnexpectedResponse,
|
||||
TooManyPending,
|
||||
RequestIdsExhausted,
|
||||
ShareReplyTimeout,
|
||||
EmergencyShutdown(E),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum PoolEvent {
|
||||
Idle,
|
||||
Control,
|
||||
Work(IssuedWork),
|
||||
ShareAccepted(u64),
|
||||
ShareRejected(u64),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum ReportEvent {
|
||||
Stale,
|
||||
BelowTarget,
|
||||
Submitted(u64),
|
||||
Backpressured,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum CycleError<E> {
|
||||
Pool(ClientError<E>),
|
||||
Miner(MinerError<E>),
|
||||
Submit(ClientError<()>),
|
||||
EmergencyShutdown(E),
|
||||
}
|
||||
|
||||
pub struct PoolConnection {
|
||||
wire: StratumWire,
|
||||
session: PoolSession,
|
||||
worker: String,
|
||||
early: VecDeque<Vec<u8>>,
|
||||
next_request_id: u64,
|
||||
pending: Vec<PendingShare>,
|
||||
accepted: u64,
|
||||
rejected: u64,
|
||||
}
|
||||
|
||||
struct PendingShare {
|
||||
id: u64,
|
||||
sent_at: Instant,
|
||||
}
|
||||
|
||||
impl PoolConnection {
|
||||
pub fn connect(
|
||||
address: SocketAddr,
|
||||
agent: &str,
|
||||
worker: &str,
|
||||
password: &str,
|
||||
io_timeout: Duration,
|
||||
handshake_timeout: Duration,
|
||||
) -> Result<Self, HandshakeError> {
|
||||
let mut wire = StratumWire::connect(address, io_timeout).map_err(HandshakeError::Wire)?;
|
||||
let handshake = wire.handshake(agent, worker, password, handshake_timeout)?;
|
||||
Self::from_handshake(wire, handshake, worker)
|
||||
.map_err(|_| HandshakeError::Pool(PoolMessageError::InvalidField))
|
||||
}
|
||||
|
||||
fn from_handshake(
|
||||
mut wire: StratumWire,
|
||||
handshake: PoolHandshake,
|
||||
worker: &str,
|
||||
) -> Result<Self, SessionError> {
|
||||
let session = PoolSession::new(
|
||||
handshake.subscription,
|
||||
handshake.configure.version_mask,
|
||||
handshake.configure.subscribe_extranonce,
|
||||
)?;
|
||||
wire.cap_write_timeout(POOL_WRITE_DEADLINE);
|
||||
Ok(Self {
|
||||
wire,
|
||||
session,
|
||||
worker: worker.to_owned(),
|
||||
early: handshake.early_notifications.into(),
|
||||
next_request_id: 4,
|
||||
pending: Vec::new(),
|
||||
accepted: 0,
|
||||
rejected: 0,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn step<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
) -> Result<PoolEvent, ClientError<B::Error>> {
|
||||
let result = self.step_inner(miner);
|
||||
if result.is_err() {
|
||||
self.wire.close();
|
||||
if let Err(error) = miner.stop() {
|
||||
return Err(ClientError::EmergencyShutdown(error));
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn step_inner<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
) -> Result<PoolEvent, ClientError<B::Error>> {
|
||||
if self
|
||||
.pending
|
||||
.first()
|
||||
.is_some_and(|share| share.sent_at.elapsed() >= SHARE_REPLY_TIMEOUT)
|
||||
{
|
||||
return Err(ClientError::ShareReplyTimeout);
|
||||
}
|
||||
let line = if let Some(line) = self.early.pop_front() {
|
||||
line
|
||||
} else {
|
||||
match self.wire.try_read_line() {
|
||||
Ok(Some(line)) => line,
|
||||
Ok(None) => return Ok(PoolEvent::Idle),
|
||||
Err(error) => return Err(ClientError::Wire(error)),
|
||||
}
|
||||
};
|
||||
let message: Value =
|
||||
serde_json::from_slice(&line).map_err(|_| ClientError::Pool(PoolMessageError::Json))?;
|
||||
if let Some(id) = message.get("id").and_then(Value::as_u64) {
|
||||
if !self.pending.iter().any(|share| share.id == id) {
|
||||
return Err(ClientError::UnexpectedResponse);
|
||||
}
|
||||
let accepted = parse_boolean_response(&line, id).map_err(ClientError::Pool)?;
|
||||
self.pending.retain(|pending| pending.id != id);
|
||||
if accepted {
|
||||
self.accepted = self.accepted.saturating_add(1);
|
||||
return Ok(PoolEvent::ShareAccepted(id));
|
||||
}
|
||||
self.rejected = self.rejected.saturating_add(1);
|
||||
return Ok(PoolEvent::ShareRejected(id));
|
||||
}
|
||||
if !message.get("id").is_none_or(Value::is_null) {
|
||||
return Err(ClientError::Pool(PoolMessageError::WrongMessage));
|
||||
}
|
||||
match message.get("method").and_then(Value::as_str) {
|
||||
Some("mining.notify") => {
|
||||
let issued = match self.session.issue_to_miner(miner, &line) {
|
||||
Err(DispatchError::Session(SessionError::WorkIdsExhausted)) => {
|
||||
miner
|
||||
.reset_chain()
|
||||
.map_err(|error| ClientError::Dispatch(DispatchError::Miner(error)))?;
|
||||
self.after_hardware_reset(miner);
|
||||
self.session.issue_to_miner(miner, &line)
|
||||
}
|
||||
result => result,
|
||||
};
|
||||
issued.map(PoolEvent::Work).map_err(ClientError::Dispatch)
|
||||
}
|
||||
Some("mining.set_difficulty" | "mining.set_version_mask" | "mining.set_extranonce") => {
|
||||
self.session
|
||||
.control_with_miner(miner, &line)
|
||||
.map_err(ClientError::Session)?;
|
||||
Ok(PoolEvent::Control)
|
||||
}
|
||||
_ => Err(ClientError::Pool(PoolMessageError::WrongMessage)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Send only a nonce already verified by the miner and session. A sent
|
||||
/// request remains pending until its matching boolean pool reply arrives.
|
||||
pub fn submit_share(&mut self, share: ValidShare) -> Result<u64, ClientError<()>> {
|
||||
if self.pending.len() >= MAX_PENDING_SHARES {
|
||||
return Err(ClientError::TooManyPending);
|
||||
}
|
||||
let id = self.next_request_id;
|
||||
let next = id.checked_add(1).ok_or(ClientError::RequestIdsExhausted)?;
|
||||
let line = self
|
||||
.session
|
||||
.submission(share, &self.worker, id)
|
||||
.map_err(ClientError::Session)?;
|
||||
self.wire
|
||||
.send_line(line.as_bytes())
|
||||
.map_err(ClientError::Wire)?;
|
||||
self.next_request_id = next;
|
||||
self.pending.push(PendingShare {
|
||||
id,
|
||||
sent_at: Instant::now(),
|
||||
});
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
pub fn share_counts(&self) -> (u64, u64, usize) {
|
||||
(self.accepted, self.rejected, self.pending.len())
|
||||
}
|
||||
|
||||
/// Process one pool message, then drain a bounded burst of ASIC reports.
|
||||
/// A reported nonce is verified before sending. The caller must cycle
|
||||
/// continuously; hardware still requires an independent power watchdog.
|
||||
pub fn cycle<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
) -> Result<(PoolEvent, Vec<ReportEvent>), CycleError<B::Error>> {
|
||||
let pool = self.step(miner).map_err(CycleError::Pool)?;
|
||||
let mut reports = Vec::new();
|
||||
for _ in 0..MAX_REPORTS_PER_CYCLE {
|
||||
if self.pending.len() >= MAX_PENDING_SHARES {
|
||||
miner.supervise().map_err(CycleError::Miner)?;
|
||||
reports.push(ReportEvent::Backpressured);
|
||||
break;
|
||||
}
|
||||
let event = match miner.poll() {
|
||||
Ok(None) => break,
|
||||
Ok(Some(share)) => {
|
||||
let id = match self.submit_share(share) {
|
||||
Ok(id) => id,
|
||||
Err(error) => {
|
||||
self.wire.close();
|
||||
miner.stop().map_err(CycleError::EmergencyShutdown)?;
|
||||
return Err(CycleError::Submit(error));
|
||||
}
|
||||
};
|
||||
ReportEvent::Submitted(id)
|
||||
}
|
||||
Err(MinerError::StaleReport) => ReportEvent::Stale,
|
||||
Err(MinerError::BelowTarget) => ReportEvent::BelowTarget,
|
||||
Err(error) => return Err(CycleError::Miner(error)),
|
||||
};
|
||||
reports.push(event);
|
||||
}
|
||||
Ok((pool, reports))
|
||||
}
|
||||
|
||||
/// Call only after an actual chain reset flushes old hardware reports.
|
||||
pub fn after_hardware_reset<B: HardwareBackend>(&mut self, miner: &mut Bm1366Miner<'_, B>) {
|
||||
miner.clear_work();
|
||||
self.session.after_hardware_reset();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::stratum_v1::Subscription;
|
||||
use std::cell::Cell;
|
||||
use std::io::Write;
|
||||
use std::net::{TcpListener, TcpStream};
|
||||
use std::rc::Rc;
|
||||
use std::sync::mpsc;
|
||||
use std::thread;
|
||||
|
||||
#[derive(Default)]
|
||||
struct Backend {
|
||||
sent: Vec<Vec<u8>>,
|
||||
powered: Rc<Cell<bool>>,
|
||||
reports_remaining: usize,
|
||||
reset_assertions: usize,
|
||||
}
|
||||
|
||||
impl HardwareBackend for Backend {
|
||||
type Error = ();
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
self.sent.push(frame.to_vec());
|
||||
Ok(())
|
||||
}
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
if self.reports_remaining == 0 {
|
||||
return Ok(0);
|
||||
}
|
||||
self.reports_remaining -= 1;
|
||||
frame[..11].copy_from_slice(&[
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
]);
|
||||
Ok(11)
|
||||
}
|
||||
fn set_chain_reset(&mut self, _chain: u8, asserted: bool) -> Result<(), Self::Error> {
|
||||
if asserted {
|
||||
self.reset_assertions += 1;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
Ok(50_000)
|
||||
}
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
self.powered.set(enabled);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn test_link(input: &'static [u8]) -> (PoolConnection, thread::JoinHandle<()>) {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let (ready, received) = mpsc::channel();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.write_all(input).unwrap();
|
||||
ready.send(()).unwrap();
|
||||
});
|
||||
let stream = TcpStream::connect(address).unwrap();
|
||||
let wire = StratumWire::from_stream(stream, Duration::from_secs(2)).unwrap();
|
||||
received.recv_timeout(Duration::from_secs(2)).unwrap();
|
||||
let handshake = PoolHandshake {
|
||||
subscription: Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
configure: crate::stratum_v1::ConfigureResult {
|
||||
version_mask: None,
|
||||
subscribe_extranonce: false,
|
||||
},
|
||||
early_notifications: Vec::new(),
|
||||
};
|
||||
(
|
||||
PoolConnection::from_handshake(wire, handshake, "miner.worker").unwrap(),
|
||||
server,
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_controls_then_dispatches_one_synthetic_job() {
|
||||
let (mut link, server) = test_link(
|
||||
concat!(
|
||||
"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n",
|
||||
"{\"id\":null,\"method\":\"mining.notify\",\"params\":[\"job-1\",",
|
||||
"\"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\",",
|
||||
"\"616263\",\"78797a\",[],\"20000000\",\"1d00ffff\",\"66554433\",true]}\n"
|
||||
)
|
||||
.as_bytes(),
|
||||
);
|
||||
let mut backend = Backend::default();
|
||||
{
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert!(matches!(
|
||||
link.cycle(&mut miner).unwrap(),
|
||||
(PoolEvent::Control, reports) if reports.is_empty()
|
||||
));
|
||||
match link.cycle(&mut miner).unwrap() {
|
||||
(PoolEvent::Work(work), reports) if reports.is_empty() => {
|
||||
assert_eq!(work.work_id, 0)
|
||||
}
|
||||
_ => panic!("expected job"),
|
||||
}
|
||||
}
|
||||
assert_eq!(backend.sent.len(), 1);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn thirty_third_job_flushes_asic_before_reusing_work_id() {
|
||||
let (mut link, server) = test_link(b"");
|
||||
link.early.push_back(
|
||||
b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n".to_vec(),
|
||||
);
|
||||
let notify = concat!(
|
||||
"{\"id\":null,\"method\":\"mining.notify\",\"params\":[\"job\",",
|
||||
"\"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\",",
|
||||
"\"616263\",\"78797a\",[],\"20000000\",\"1d00ffff\",\"66554433\",true]}\n"
|
||||
);
|
||||
for _ in 0..33 {
|
||||
link.early.push_back(notify.as_bytes().to_vec());
|
||||
}
|
||||
let mut backend = Backend::default();
|
||||
let powered = Rc::clone(&backend.powered);
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert!(matches!(link.step(&mut miner), Ok(PoolEvent::Control)));
|
||||
let mut first_header = None;
|
||||
for index in 0..33 {
|
||||
let PoolEvent::Work(work) = link.step(&mut miner).unwrap() else {
|
||||
panic!("expected work");
|
||||
};
|
||||
if index == 0 {
|
||||
first_header = Some(work.header);
|
||||
}
|
||||
if index == 32 {
|
||||
assert_eq!(work.work_id, 0);
|
||||
assert_ne!(Some(work.header), first_header);
|
||||
}
|
||||
}
|
||||
assert!(powered.get());
|
||||
miner.stop().unwrap();
|
||||
drop(miner);
|
||||
assert_eq!(backend.reset_assertions, 2);
|
||||
assert_eq!(backend.sent.len(), 33);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_replies_match_pending_ids_and_count_accepts_separately() {
|
||||
let (mut link, server) = test_link(
|
||||
concat!(
|
||||
"{\"id\":4,\"result\":true,\"error\":null}\n",
|
||||
"{\"id\":5,\"result\":false,\"error\":[23,\"stale\"]}\n",
|
||||
"{\"id\":6,\"result\":true,\"error\":null}\n"
|
||||
)
|
||||
.as_bytes(),
|
||||
);
|
||||
link.pending.extend([4, 5].map(|id| PendingShare {
|
||||
id,
|
||||
sent_at: Instant::now(),
|
||||
}));
|
||||
let mut backend = Backend::default();
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert!(matches!(
|
||||
link.step(&mut miner).unwrap(),
|
||||
PoolEvent::ShareAccepted(4)
|
||||
));
|
||||
assert!(matches!(
|
||||
link.step(&mut miner).unwrap(),
|
||||
PoolEvent::ShareRejected(5)
|
||||
));
|
||||
assert_eq!(link.share_counts(), (1, 1, 0));
|
||||
assert!(matches!(
|
||||
link.step(&mut miner),
|
||||
Err(ClientError::UnexpectedResponse)
|
||||
));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn untracked_report_cannot_be_sent_to_pool() {
|
||||
let (mut link, server) = test_link(b"");
|
||||
let report = ValidShare {
|
||||
nonce: 1,
|
||||
work_id: 0,
|
||||
rolled_version: 0x2000_0000,
|
||||
hash_le: [0; 32],
|
||||
};
|
||||
assert!(matches!(
|
||||
link.submit_share(report),
|
||||
Err(ClientError::Session(SessionError::StaleShare))
|
||||
));
|
||||
assert_eq!(link.share_counts(), (0, 0, 0));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unanswered_share_closes_pool_connection() {
|
||||
let (mut link, server) = test_link(b"");
|
||||
link.pending.push(PendingShare {
|
||||
id: 4,
|
||||
sent_at: Instant::now() - SHARE_REPLY_TIMEOUT - Duration::from_secs(1),
|
||||
});
|
||||
let mut backend = Backend::default();
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert!(matches!(
|
||||
link.step(&mut miner),
|
||||
Err(ClientError::ShareReplyTimeout)
|
||||
));
|
||||
assert!(link.wire.is_closed());
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_pool_message_stops_miner_before_returning() {
|
||||
let (mut link, server) = test_link(b"{}\n");
|
||||
let mut backend = Backend::default();
|
||||
let powered = Rc::clone(&backend.powered);
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert!(powered.get());
|
||||
assert!(matches!(link.cycle(&mut miner), Err(CycleError::Pool(_))));
|
||||
assert!(!powered.get());
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_pool_does_not_limit_asic_report_burst_to_one() {
|
||||
let (mut link, server) =
|
||||
test_link(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n");
|
||||
let mut backend = Backend {
|
||||
reports_remaining: MAX_REPORTS_PER_CYCLE + 3,
|
||||
..Backend::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
let (pool, reports) = link.cycle(&mut miner).unwrap();
|
||||
assert!(matches!(pool, PoolEvent::Control));
|
||||
assert_eq!(reports.len(), MAX_REPORTS_PER_CYCLE);
|
||||
assert!(reports
|
||||
.iter()
|
||||
.all(|event| matches!(event, ReportEvent::Stale)));
|
||||
drop(miner);
|
||||
assert_eq!(backend.reports_remaining, 3);
|
||||
server.join().unwrap();
|
||||
}
|
||||
}
|
||||
@@ -1,378 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded pool-job bookkeeping for one BM1366 chain and one Stratum V1 session.
|
||||
|
||||
use crate::difficulty::PoolDifficulty;
|
||||
use crate::miner::{Bm1366Miner, MinerError, ValidShare};
|
||||
use crate::pow::{sha256d, VersionMask};
|
||||
use crate::stratum_submit::{format_submission, Submission, SubmitError};
|
||||
use crate::stratum_v1::{
|
||||
parse_control_notification, parse_notify, PoolMessageError, PoolNotification, Subscription,
|
||||
};
|
||||
use crate::stratum_work::JobError;
|
||||
use crate::HardwareBackend;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SessionError {
|
||||
InvalidSubscription,
|
||||
Pool(PoolMessageError),
|
||||
Work(JobError),
|
||||
MissingDifficulty,
|
||||
ExtranonceExhausted,
|
||||
WorkIdsExhausted,
|
||||
StaleShare,
|
||||
UnverifiedShare,
|
||||
Submit(SubmitError),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum DispatchError<E> {
|
||||
Session(SessionError),
|
||||
Miner(MinerError<E>),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct IssuedWork {
|
||||
pub work_id: u8,
|
||||
pub header: [u8; 80],
|
||||
pub target_le: [u8; 32],
|
||||
/// The hardware miner must forget prior work before submitting this job.
|
||||
pub clean_jobs: bool,
|
||||
}
|
||||
|
||||
struct TrackedWork {
|
||||
job_id: String,
|
||||
header: [u8; 80],
|
||||
target_le: [u8; 32],
|
||||
extranonce2: Vec<u8>,
|
||||
ntime: u32,
|
||||
base_version: u32,
|
||||
}
|
||||
|
||||
struct NonceSpace {
|
||||
template: [u8; 80],
|
||||
next: [u8; 32],
|
||||
exhausted: bool,
|
||||
}
|
||||
|
||||
const MAX_NONCE_SPACES: usize = 4096;
|
||||
|
||||
pub struct PoolSession {
|
||||
subscription: Subscription,
|
||||
version_mask: Option<VersionMask>,
|
||||
subscribe_extranonce: bool,
|
||||
pending_difficulty: Option<PoolDifficulty>,
|
||||
active_difficulty: Option<PoolDifficulty>,
|
||||
nonce_spaces: Vec<NonceSpace>,
|
||||
zero_extranonce_headers: Vec<[u8; 80]>,
|
||||
tracked: [Option<TrackedWork>; 32],
|
||||
next_slot: usize,
|
||||
}
|
||||
|
||||
impl PoolSession {
|
||||
pub fn new(
|
||||
subscription: Subscription,
|
||||
version_mask: Option<VersionMask>,
|
||||
subscribe_extranonce: bool,
|
||||
) -> Result<Self, SessionError> {
|
||||
if subscription.extranonce1.len() > 32 || subscription.extranonce2_size > 32 {
|
||||
return Err(SessionError::InvalidSubscription);
|
||||
}
|
||||
Ok(Self {
|
||||
subscription,
|
||||
version_mask,
|
||||
subscribe_extranonce,
|
||||
pending_difficulty: None,
|
||||
active_difficulty: None,
|
||||
nonce_spaces: Vec::new(),
|
||||
zero_extranonce_headers: Vec::new(),
|
||||
tracked: std::array::from_fn(|_| None),
|
||||
next_slot: 0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Apply a control message in wire order. A true result means the caller
|
||||
/// must call the hardware miner's `clear_work` before accepting reports.
|
||||
pub fn control(&mut self, line: &[u8]) -> Result<bool, SessionError> {
|
||||
let control = parse_control_notification(
|
||||
line,
|
||||
self.version_mask.is_some(),
|
||||
self.subscribe_extranonce,
|
||||
)
|
||||
.map_err(SessionError::Pool)?;
|
||||
match control {
|
||||
PoolNotification::SetDifficulty(difficulty) => {
|
||||
self.pending_difficulty = Some(difficulty);
|
||||
Ok(false)
|
||||
}
|
||||
PoolNotification::SetVersionMask(mask) => {
|
||||
if self.version_mask == Some(mask) {
|
||||
return Ok(false);
|
||||
}
|
||||
self.version_mask = Some(mask);
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
Ok(true)
|
||||
}
|
||||
PoolNotification::SetExtranonce(subscription) => {
|
||||
self.subscription = subscription;
|
||||
self.nonce_spaces.clear();
|
||||
self.zero_extranonce_headers.clear();
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply a pool control message and invalidate the hardware miner's work
|
||||
/// when an extranonce or version-mask change makes earlier jobs stale.
|
||||
pub fn control_with_miner<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
line: &[u8],
|
||||
) -> Result<(), SessionError> {
|
||||
if self.control(line)? {
|
||||
miner.clear_work();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Allocate one unique extranonce and ASIC work ID for a pool job. The
|
||||
/// caller must pass this header, target, and ID to `Bm1366Miner::submit`.
|
||||
/// On `clean_jobs`, clear the hardware miner's work first. Work IDs are
|
||||
/// never reused on the same chain without an explicit hardware reset.
|
||||
pub fn issue_notify(&mut self, line: &[u8]) -> Result<IssuedWork, SessionError> {
|
||||
let job = parse_notify(line, &self.subscription).map_err(SessionError::Pool)?;
|
||||
let difficulty = self
|
||||
.pending_difficulty
|
||||
.or(self.active_difficulty)
|
||||
.ok_or(SessionError::MissingDifficulty)?;
|
||||
if self.next_slot == self.tracked.len() {
|
||||
return Err(SessionError::WorkIdsExhausted);
|
||||
}
|
||||
let size = self.subscription.extranonce2_size;
|
||||
let template = if size == 0 {
|
||||
None
|
||||
} else {
|
||||
Some(
|
||||
job.work
|
||||
.nonce_zero_header(&vec![0; size], job.work.ntime)
|
||||
.map_err(SessionError::Work)?,
|
||||
)
|
||||
};
|
||||
let space_index = template.and_then(|header| {
|
||||
self.nonce_spaces
|
||||
.iter()
|
||||
.position(|space| space.template == header)
|
||||
});
|
||||
if size != 0 && space_index.is_none() && self.nonce_spaces.len() == MAX_NONCE_SPACES {
|
||||
return Err(SessionError::ExtranonceExhausted);
|
||||
}
|
||||
let extranonce2 = match space_index {
|
||||
Some(index) if self.nonce_spaces[index].exhausted => {
|
||||
return Err(SessionError::ExtranonceExhausted)
|
||||
}
|
||||
Some(index) => self.nonce_spaces[index].next[..size].to_vec(),
|
||||
None => vec![0; size],
|
||||
};
|
||||
let header = job
|
||||
.work
|
||||
.nonce_zero_header(&extranonce2, job.work.ntime)
|
||||
.map_err(SessionError::Work)?;
|
||||
if size == 0 && self.zero_extranonce_headers.contains(&header) {
|
||||
return Err(SessionError::ExtranonceExhausted);
|
||||
}
|
||||
let target_le = difficulty.target_le();
|
||||
if job.clean_jobs {
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
}
|
||||
self.active_difficulty = Some(difficulty);
|
||||
self.pending_difficulty = None;
|
||||
let slot = self.next_slot;
|
||||
self.next_slot += 1;
|
||||
self.tracked[slot] = Some(TrackedWork {
|
||||
job_id: job.id,
|
||||
header,
|
||||
target_le,
|
||||
extranonce2,
|
||||
ntime: job.work.ntime,
|
||||
base_version: job.work.version,
|
||||
});
|
||||
if size == 0 {
|
||||
self.zero_extranonce_headers.push(header);
|
||||
} else {
|
||||
let space = match space_index {
|
||||
Some(index) => &mut self.nonce_spaces[index],
|
||||
None => {
|
||||
self.nonce_spaces.push(NonceSpace {
|
||||
template: template.expect("nonzero extranonce has a template"),
|
||||
next: [0; 32],
|
||||
exhausted: false,
|
||||
});
|
||||
self.nonce_spaces.last_mut().expect("just pushed")
|
||||
}
|
||||
};
|
||||
let mut carry = true;
|
||||
for byte in space.next[..size].iter_mut().rev() {
|
||||
let (new, overflow) = byte.overflowing_add(u8::from(carry));
|
||||
*byte = new;
|
||||
carry = overflow;
|
||||
if !carry {
|
||||
break;
|
||||
}
|
||||
}
|
||||
space.exhausted = carry;
|
||||
}
|
||||
Ok(IssuedWork {
|
||||
work_id: (slot as u8) << 3,
|
||||
header,
|
||||
target_le,
|
||||
clean_jobs: job.clean_jobs,
|
||||
})
|
||||
}
|
||||
|
||||
/// Preserve pool-message order while dispatching one job to the hardware
|
||||
/// miner. A failed dispatch consumes its ASIC work ID to avoid ambiguity
|
||||
/// with any frame that may have reached the device before the error.
|
||||
pub fn issue_to_miner<B: HardwareBackend>(
|
||||
&mut self,
|
||||
miner: &mut Bm1366Miner<'_, B>,
|
||||
line: &[u8],
|
||||
) -> Result<IssuedWork, DispatchError<B::Error>> {
|
||||
let issued = self.issue_notify(line).map_err(DispatchError::Session)?;
|
||||
if issued.clean_jobs {
|
||||
miner.clear_work();
|
||||
}
|
||||
if let Err(error) = miner.submit(issued.header, issued.target_le, issued.work_id) {
|
||||
self.tracked[usize::from(issued.work_id >> 3)] = None;
|
||||
return Err(DispatchError::Miner(error));
|
||||
}
|
||||
Ok(issued)
|
||||
}
|
||||
|
||||
/// Recheck the hardware-reported share and format its pool submission.
|
||||
/// This method verifies one reported nonce; it never searches for one.
|
||||
pub fn submission(
|
||||
&self,
|
||||
share: ValidShare,
|
||||
worker: &str,
|
||||
request_id: u64,
|
||||
) -> Result<String, SessionError> {
|
||||
let tracked = self
|
||||
.tracked
|
||||
.get(usize::from(share.work_id >> 3))
|
||||
.and_then(Option::as_ref)
|
||||
.ok_or(SessionError::StaleShare)?;
|
||||
if share.work_id & 7 != 0 {
|
||||
return Err(SessionError::StaleShare);
|
||||
}
|
||||
let mut header = tracked.header;
|
||||
header[..4].copy_from_slice(&share.rolled_version.to_le_bytes());
|
||||
header[76..80].copy_from_slice(&share.nonce.to_le_bytes());
|
||||
let hash_le = sha256d(&header);
|
||||
if hash_le != share.hash_le
|
||||
|| hash_le
|
||||
.iter()
|
||||
.rev()
|
||||
.cmp(tracked.target_le.iter().rev())
|
||||
.is_gt()
|
||||
{
|
||||
return Err(SessionError::UnverifiedShare);
|
||||
}
|
||||
format_submission(&Submission {
|
||||
request_id,
|
||||
worker,
|
||||
job_id: &tracked.job_id,
|
||||
extranonce2: &tracked.extranonce2,
|
||||
ntime: tracked.ntime,
|
||||
nonce: share.nonce,
|
||||
base_version: tracked.base_version,
|
||||
rolled_version: share.rolled_version,
|
||||
version_mask: self.version_mask,
|
||||
})
|
||||
.map_err(SessionError::Submit)
|
||||
}
|
||||
|
||||
/// Call only after the chain has actually reset and prior reports cannot
|
||||
/// arrive. A pool `clean_jobs` notification alone is insufficient.
|
||||
pub fn after_hardware_reset(&mut self) {
|
||||
self.tracked = std::array::from_fn(|_| None);
|
||||
self.next_slot = 0;
|
||||
self.zero_extranonce_headers.clear();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn bytes(text: &str) -> Vec<u8> {
|
||||
text.as_bytes()
|
||||
.chunks_exact(2)
|
||||
.map(|part| u8::from_str_radix(std::str::from_utf8(part).unwrap(), 16).unwrap())
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_report_is_rechecked_and_formatted_for_pool() {
|
||||
let header: [u8; 80] = bytes(concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503",
|
||||
"b4213a43ae1052ebd44443068fe178e2c61ca4994846fd133addb04aab2b382c5",
|
||||
"b4c74c1012e6a8f06021700000000"
|
||||
))
|
||||
.try_into()
|
||||
.unwrap();
|
||||
let hash_le: [u8; 32] =
|
||||
bytes("4b5e00850cf9de9809f822f8858eda39e49996d9d40f634f1043290000000000")
|
||||
.try_into()
|
||||
.unwrap();
|
||||
let mut target_le = [0_u8; 32];
|
||||
target_le[26..28].fill(0xff);
|
||||
let mut session = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
VersionMask::new(0x1fff_e000),
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
session.tracked[3] = Some(TrackedWork {
|
||||
job_id: "captured-job".into(),
|
||||
header,
|
||||
target_le,
|
||||
extranonce2: vec![0, 0, 0, 1],
|
||||
ntime: u32::from_le_bytes(header[68..72].try_into().unwrap()),
|
||||
base_version: 0x2000_0000,
|
||||
});
|
||||
let share = ValidShare {
|
||||
nonce: 0xedad_ff38,
|
||||
work_id: 0x18,
|
||||
rolled_version: 0x2096_6000,
|
||||
hash_le,
|
||||
};
|
||||
let submit = session.submission(share, "miner.worker", 7).unwrap();
|
||||
assert!(submit.contains("\"mining.submit\""));
|
||||
assert!(submit.contains("\"captured-job\""));
|
||||
assert!(submit.contains("\"edadff38\",\"00966000\""));
|
||||
assert_eq!(
|
||||
session.submission(
|
||||
ValidShare {
|
||||
hash_le: [0; 32],
|
||||
..share
|
||||
},
|
||||
"miner.worker",
|
||||
8
|
||||
),
|
||||
Err(SessionError::UnverifiedShare)
|
||||
);
|
||||
assert_eq!(
|
||||
session.control(
|
||||
b"{\"id\":null,\"method\":\"mining.set_version_mask\",\"params\":[\"00002000\"]}"
|
||||
),
|
||||
Ok(true)
|
||||
);
|
||||
assert_eq!(
|
||||
session.submission(share, "miner.worker", 8),
|
||||
Err(SessionError::StaleShare)
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Format one verified share for Stratum V1 and negotiated BIP310 submission.
|
||||
//! Pool I/O and request tracking are owned by the caller.
|
||||
|
||||
use crate::pow::VersionMask;
|
||||
use std::fmt::Write;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SubmitError {
|
||||
EmptyWorker,
|
||||
EmptyJobId,
|
||||
FieldTooLong,
|
||||
ExtranonceTooLong,
|
||||
UnrepresentableVersion,
|
||||
}
|
||||
|
||||
pub struct Submission<'a> {
|
||||
pub request_id: u64,
|
||||
pub worker: &'a str,
|
||||
pub job_id: &'a str,
|
||||
pub extranonce2: &'a [u8],
|
||||
pub ntime: u32,
|
||||
pub nonce: u32,
|
||||
pub base_version: u32,
|
||||
pub rolled_version: u32,
|
||||
/// The last pool mask, only after version rolling was accepted.
|
||||
pub version_mask: Option<VersionMask>,
|
||||
}
|
||||
|
||||
fn json_string(out: &mut String, value: &str) {
|
||||
out.push('"');
|
||||
for ch in value.chars() {
|
||||
match ch {
|
||||
'"' => out.push_str("\\\""),
|
||||
'\\' => out.push_str("\\\\"),
|
||||
'\n' => out.push_str("\\n"),
|
||||
'\r' => out.push_str("\\r"),
|
||||
'\t' => out.push_str("\\t"),
|
||||
c if c <= '\u{001f}' => {
|
||||
write!(out, "\\u{:04x}", c as u32).expect("write to String");
|
||||
}
|
||||
c => out.push(c),
|
||||
}
|
||||
}
|
||||
out.push('"');
|
||||
}
|
||||
|
||||
/// Emit one newline-terminated JSON request. The caller must have checked the
|
||||
/// ASIC report against the pool target and retained the original job metadata.
|
||||
pub fn format_submission(share: &Submission<'_>) -> Result<String, SubmitError> {
|
||||
if share.worker.is_empty() {
|
||||
return Err(SubmitError::EmptyWorker);
|
||||
}
|
||||
if share.job_id.is_empty() {
|
||||
return Err(SubmitError::EmptyJobId);
|
||||
}
|
||||
if share.worker.len() > 128 || share.job_id.len() > 128 {
|
||||
return Err(SubmitError::FieldTooLong);
|
||||
}
|
||||
if share.extranonce2.len() > 32 {
|
||||
return Err(SubmitError::ExtranonceTooLong);
|
||||
}
|
||||
let version_bits = match share.version_mask {
|
||||
Some(mask) => {
|
||||
let bits = share.rolled_version & mask.bits();
|
||||
if mask.apply_submission_bits(share.base_version, bits) != Some(share.rolled_version) {
|
||||
return Err(SubmitError::UnrepresentableVersion);
|
||||
}
|
||||
Some(bits)
|
||||
}
|
||||
None if share.rolled_version == share.base_version => None,
|
||||
None => return Err(SubmitError::UnrepresentableVersion),
|
||||
};
|
||||
|
||||
let mut out = format!(
|
||||
"{{\"id\":{},\"method\":\"mining.submit\",\"params\":[",
|
||||
share.request_id
|
||||
);
|
||||
json_string(&mut out, share.worker);
|
||||
out.push(',');
|
||||
json_string(&mut out, share.job_id);
|
||||
out.push_str(",\"");
|
||||
for byte in share.extranonce2 {
|
||||
write!(out, "{byte:02x}").expect("write to String");
|
||||
}
|
||||
write!(out, "\",\"{:08x}\",\"{:08x}\"", share.ntime, share.nonce).expect("write to String");
|
||||
if let Some(bits) = version_bits {
|
||||
write!(out, ",\"{bits:08x}\"").expect("write to String");
|
||||
}
|
||||
out.push_str("]}\n");
|
||||
Ok(out)
|
||||
}
|
||||
@@ -1,308 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded decoding of Bitcoin Stratum V1 subscription and job messages.
|
||||
//! The network client must enforce a line limit before passing data here.
|
||||
|
||||
use crate::difficulty::PoolDifficulty;
|
||||
use crate::pow::VersionMask;
|
||||
use crate::stratum_work::{JobError, Sha256Job};
|
||||
use serde_json::Value;
|
||||
|
||||
pub const MAX_POOL_LINE_BYTES: usize = 131_072;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum PoolMessageError {
|
||||
TooLarge,
|
||||
Json,
|
||||
WrongMessage,
|
||||
Unnegotiated,
|
||||
InvalidField,
|
||||
InvalidHex,
|
||||
InvalidWork(JobError),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub struct Subscription {
|
||||
pub extranonce1: Vec<u8>,
|
||||
pub extranonce2_size: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ConfigureResult {
|
||||
pub version_mask: Option<VersionMask>,
|
||||
pub subscribe_extranonce: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum PoolNotification {
|
||||
SetDifficulty(PoolDifficulty),
|
||||
SetExtranonce(Subscription),
|
||||
SetVersionMask(VersionMask),
|
||||
}
|
||||
|
||||
pub struct PoolJob {
|
||||
pub id: String,
|
||||
pub clean_jobs: bool,
|
||||
pub work: Sha256Job,
|
||||
}
|
||||
|
||||
fn parse_json(line: &[u8]) -> Result<Value, PoolMessageError> {
|
||||
if line.len() > MAX_POOL_LINE_BYTES {
|
||||
return Err(PoolMessageError::TooLarge);
|
||||
}
|
||||
serde_json::from_slice(line).map_err(|_| PoolMessageError::Json)
|
||||
}
|
||||
|
||||
fn hex_bytes(text: &str) -> Result<Vec<u8>, PoolMessageError> {
|
||||
let bytes = text.as_bytes();
|
||||
if bytes.len() & 1 != 0 {
|
||||
return Err(PoolMessageError::InvalidHex);
|
||||
}
|
||||
let mut result = Vec::with_capacity(bytes.len() / 2);
|
||||
for pair in bytes.chunks_exact(2) {
|
||||
let high = (pair[0] as char)
|
||||
.to_digit(16)
|
||||
.ok_or(PoolMessageError::InvalidHex)?;
|
||||
let low = (pair[1] as char)
|
||||
.to_digit(16)
|
||||
.ok_or(PoolMessageError::InvalidHex)?;
|
||||
result.push(((high << 4) | low) as u8);
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn hex_fixed<const N: usize>(field: &Value) -> Result<[u8; N], PoolMessageError> {
|
||||
let text = field.as_str().ok_or(PoolMessageError::InvalidField)?;
|
||||
if text.len() != N * 2 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
hex_bytes(text)?
|
||||
.try_into()
|
||||
.map_err(|_| PoolMessageError::InvalidField)
|
||||
}
|
||||
|
||||
fn hex_u32(field: &Value) -> Result<u32, PoolMessageError> {
|
||||
let text = field.as_str().ok_or(PoolMessageError::InvalidField)?;
|
||||
if text.len() != 8 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
u32::from_str_radix(text, 16).map_err(|_| PoolMessageError::InvalidHex)
|
||||
}
|
||||
|
||||
fn valid_subscription(
|
||||
extranonce1: Vec<u8>,
|
||||
extranonce2_size: u64,
|
||||
) -> Result<Subscription, PoolMessageError> {
|
||||
if extranonce1.len() > 32 || extranonce2_size > 32 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
Ok(Subscription {
|
||||
extranonce1,
|
||||
extranonce2_size: extranonce2_size as usize,
|
||||
})
|
||||
}
|
||||
|
||||
/// Parse the response to a matching `mining.subscribe` request.
|
||||
pub fn parse_subscription(line: &[u8], request_id: u64) -> Result<Subscription, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("id").and_then(Value::as_u64) != Some(request_id)
|
||||
|| !message.get("error").is_none_or(Value::is_null)
|
||||
{
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let result = message
|
||||
.get("result")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
if result.len() != 3 || !result[0].is_array() {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let extranonce1 = hex_bytes(result[1].as_str().ok_or(PoolMessageError::InvalidField)?)?;
|
||||
let extranonce2_size = result[2].as_u64().ok_or(PoolMessageError::InvalidField)?;
|
||||
valid_subscription(extranonce1, extranonce2_size)
|
||||
}
|
||||
|
||||
/// Decode the response to a BIP310 configure request that offered version
|
||||
/// rolling. A pool mask outside this ASIC's changeable bits is unusable: the
|
||||
/// pool would reconstruct a different block version for submitted shares.
|
||||
pub fn parse_configure_response(
|
||||
line: &[u8],
|
||||
request_id: u64,
|
||||
) -> Result<Option<VersionMask>, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("id").and_then(Value::as_u64) != Some(request_id)
|
||||
|| !message.get("error").is_none_or(Value::is_null)
|
||||
{
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let result = message
|
||||
.get("result")
|
||||
.and_then(Value::as_object)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
match result.get("version-rolling") {
|
||||
Some(Value::Bool(false) | Value::String(_)) => Ok(None),
|
||||
Some(Value::Bool(true)) => {
|
||||
let mask = hex_u32(
|
||||
result
|
||||
.get("version-rolling.mask")
|
||||
.ok_or(PoolMessageError::InvalidField)?,
|
||||
)?;
|
||||
VersionMask::new(mask)
|
||||
.map(Some)
|
||||
.ok_or(PoolMessageError::InvalidField)
|
||||
}
|
||||
_ => Err(PoolMessageError::InvalidField),
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode both offered BIP310 extensions. An omitted extranonce extension is
|
||||
/// unsupported; its notifications cannot be used without an explicit grant.
|
||||
pub fn parse_configure_result(
|
||||
line: &[u8],
|
||||
request_id: u64,
|
||||
) -> Result<ConfigureResult, PoolMessageError> {
|
||||
let version_mask = parse_configure_response(line, request_id)?;
|
||||
let message = parse_json(line)?;
|
||||
let result = message
|
||||
.get("result")
|
||||
.and_then(Value::as_object)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
let subscribe_extranonce = match result.get("subscribe-extranonce") {
|
||||
Some(Value::Bool(value)) => *value,
|
||||
Some(Value::String(_)) | None => false,
|
||||
_ => return Err(PoolMessageError::InvalidField),
|
||||
};
|
||||
Ok(ConfigureResult {
|
||||
version_mask,
|
||||
subscribe_extranonce,
|
||||
})
|
||||
}
|
||||
|
||||
/// Decode a matching authorization or share-submission result. A false
|
||||
/// result is an ordinary pool rejection and must not count as an accept.
|
||||
pub fn parse_boolean_response(line: &[u8], request_id: u64) -> Result<bool, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("id").and_then(Value::as_u64) != Some(request_id) {
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
match message.get("result") {
|
||||
Some(Value::Bool(true)) if message.get("error").is_none_or(Value::is_null) => Ok(true),
|
||||
Some(Value::Bool(false)) => Ok(false),
|
||||
Some(Value::Null) if !message.get("error").is_none_or(Value::is_null) => Ok(false),
|
||||
_ => Err(PoolMessageError::InvalidField),
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode pool control notifications. The caller applies them in stream order:
|
||||
/// difficulty to the next job, extranonce to subsequent work, and the version
|
||||
/// mask immediately to all pending submissions.
|
||||
pub fn parse_control_notification(
|
||||
line: &[u8],
|
||||
version_rolling: bool,
|
||||
subscribe_extranonce: bool,
|
||||
) -> Result<PoolNotification, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if !message.get("id").is_none_or(Value::is_null) {
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let method = message
|
||||
.get("method")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(PoolMessageError::WrongMessage)?;
|
||||
let params = message
|
||||
.get("params")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
match method {
|
||||
"mining.set_difficulty" if params.len() == 1 => {
|
||||
let number = params[0]
|
||||
.as_number()
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
let difficulty = PoolDifficulty::from_json_number(number)
|
||||
.map_err(|_| PoolMessageError::InvalidField)?;
|
||||
Ok(PoolNotification::SetDifficulty(difficulty))
|
||||
}
|
||||
"mining.set_version_mask" if params.len() == 1 => {
|
||||
if !version_rolling {
|
||||
return Err(PoolMessageError::Unnegotiated);
|
||||
}
|
||||
let mask = hex_u32(¶ms[0])?;
|
||||
let mask = VersionMask::new(mask).ok_or(PoolMessageError::InvalidField)?;
|
||||
Ok(PoolNotification::SetVersionMask(mask))
|
||||
}
|
||||
"mining.set_extranonce" if params.len() == 2 => {
|
||||
if !subscribe_extranonce {
|
||||
return Err(PoolMessageError::Unnegotiated);
|
||||
}
|
||||
let extranonce1 = hex_bytes(params[0].as_str().ok_or(PoolMessageError::InvalidField)?)?;
|
||||
let size = params[1].as_u64().ok_or(PoolMessageError::InvalidField)?;
|
||||
Ok(PoolNotification::SetExtranonce(valid_subscription(
|
||||
extranonce1,
|
||||
size,
|
||||
)?))
|
||||
}
|
||||
"mining.set_difficulty" | "mining.set_version_mask" | "mining.set_extranonce" => {
|
||||
Err(PoolMessageError::InvalidField)
|
||||
}
|
||||
_ => Err(PoolMessageError::WrongMessage),
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse exactly the nine Bitcoin `mining.notify` parameters into work.
|
||||
pub fn parse_notify(line: &[u8], subscription: &Subscription) -> Result<PoolJob, PoolMessageError> {
|
||||
let message = parse_json(line)?;
|
||||
if message.get("method").and_then(Value::as_str) != Some("mining.notify")
|
||||
|| !message.get("id").is_none_or(Value::is_null)
|
||||
{
|
||||
return Err(PoolMessageError::WrongMessage);
|
||||
}
|
||||
let params = message
|
||||
.get("params")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(PoolMessageError::InvalidField)?;
|
||||
if params.len() != 9 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let id = params[0].as_str().ok_or(PoolMessageError::InvalidField)?;
|
||||
if id.is_empty() || id.len() > 128 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let branches = params[4].as_array().ok_or(PoolMessageError::InvalidField)?;
|
||||
if branches.len() > 64 {
|
||||
return Err(PoolMessageError::InvalidField);
|
||||
}
|
||||
let mut merkle_branches = Vec::with_capacity(branches.len());
|
||||
for branch in branches {
|
||||
merkle_branches.push(hex_fixed::<32>(branch)?);
|
||||
}
|
||||
let work = Sha256Job {
|
||||
prevhash_stratum: hex_fixed::<32>(¶ms[1])?,
|
||||
coinb1: hex_bytes(params[2].as_str().ok_or(PoolMessageError::InvalidField)?)?,
|
||||
coinb2: hex_bytes(params[3].as_str().ok_or(PoolMessageError::InvalidField)?)?,
|
||||
merkle_branches,
|
||||
version: hex_u32(¶ms[5])?,
|
||||
nbits: hex_u32(¶ms[6])?,
|
||||
ntime: hex_u32(¶ms[7])?,
|
||||
extranonce1: subscription.extranonce1.clone(),
|
||||
extranonce2_size: subscription.extranonce2_size,
|
||||
};
|
||||
work.validate().map_err(PoolMessageError::InvalidWork)?;
|
||||
let clean_jobs = params[8].as_bool().ok_or(PoolMessageError::InvalidField)?;
|
||||
Ok(PoolJob {
|
||||
id: id.to_owned(),
|
||||
clean_jobs,
|
||||
work,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod configure_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn omitted_extranonce_extension_is_unsupported() {
|
||||
let line = br#"{"id":1,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000"},"error":null}"#;
|
||||
let result = parse_configure_result(line, 1).unwrap();
|
||||
assert!(result.version_mask.is_some());
|
||||
assert!(!result.subscribe_extranonce);
|
||||
}
|
||||
}
|
||||
@@ -1,408 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded newline-framed TCP transport for Bitcoin Stratum V1 pools.
|
||||
|
||||
use crate::stratum_v1::MAX_POOL_LINE_BYTES;
|
||||
use crate::stratum_v1::{
|
||||
parse_boolean_response, parse_configure_result, parse_subscription, ConfigureResult,
|
||||
PoolMessageError, Subscription,
|
||||
};
|
||||
use serde_json::json;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{Shutdown, SocketAddr, TcpStream};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const MAX_EARLY_NOTIFICATIONS: usize = 32;
|
||||
const MAX_EARLY_NOTIFICATION_BYTES: usize = 262_144;
|
||||
const READ_SLICE: Duration = Duration::from_millis(1);
|
||||
const MAX_PARTIAL_AGE: Duration = Duration::from_secs(2);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum WireError {
|
||||
InvalidRequest,
|
||||
LineTooLong,
|
||||
Timeout,
|
||||
Eof,
|
||||
Closed,
|
||||
Io(io::Error),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum HandshakeError {
|
||||
Wire(WireError),
|
||||
Pool(PoolMessageError),
|
||||
Rejected,
|
||||
TooManyNotifications,
|
||||
}
|
||||
|
||||
pub struct PoolHandshake {
|
||||
pub subscription: Subscription,
|
||||
pub configure: ConfigureResult,
|
||||
/// Notifications received during negotiation, in original wire order.
|
||||
pub early_notifications: Vec<Vec<u8>>,
|
||||
}
|
||||
|
||||
pub struct StratumWire {
|
||||
stream: TcpStream,
|
||||
buffered: Vec<u8>,
|
||||
partial_started: Option<Instant>,
|
||||
timeout: Duration,
|
||||
write_timeout: Duration,
|
||||
closed: bool,
|
||||
}
|
||||
|
||||
impl StratumWire {
|
||||
pub fn connect(address: SocketAddr, timeout: Duration) -> Result<Self, WireError> {
|
||||
if timeout.is_zero() || Instant::now().checked_add(timeout).is_none() {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
let stream = TcpStream::connect_timeout(&address, timeout).map_err(WireError::Io)?;
|
||||
stream.set_nodelay(true).map_err(WireError::Io)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffered: Vec::new(),
|
||||
partial_started: None,
|
||||
timeout,
|
||||
write_timeout: timeout,
|
||||
closed: false,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn from_stream(stream: TcpStream, timeout: Duration) -> Result<Self, WireError> {
|
||||
if timeout.is_zero() || Instant::now().checked_add(timeout).is_none() {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
stream.set_nodelay(true).map_err(WireError::Io)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffered: Vec::new(),
|
||||
partial_started: None,
|
||||
timeout,
|
||||
write_timeout: timeout,
|
||||
closed: false,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn close(&mut self) {
|
||||
self.closed = true;
|
||||
let _ = self.stream.shutdown(Shutdown::Both);
|
||||
}
|
||||
|
||||
pub fn is_closed(&self) -> bool {
|
||||
self.closed
|
||||
}
|
||||
|
||||
pub(crate) fn cap_write_timeout(&mut self, limit: Duration) {
|
||||
self.write_timeout = self.write_timeout.min(limit);
|
||||
}
|
||||
|
||||
fn remaining(deadline: Instant) -> Result<Duration, WireError> {
|
||||
deadline
|
||||
.checked_duration_since(Instant::now())
|
||||
.filter(|remaining| !remaining.is_zero())
|
||||
.ok_or(WireError::Timeout)
|
||||
}
|
||||
|
||||
fn transport_error(error: io::Error) -> WireError {
|
||||
match error.kind() {
|
||||
io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock => WireError::Timeout,
|
||||
_ => WireError::Io(error),
|
||||
}
|
||||
}
|
||||
|
||||
fn read_line_before(&mut self, deadline: Instant) -> Result<Vec<u8>, WireError> {
|
||||
if self.closed {
|
||||
return Err(WireError::Closed);
|
||||
}
|
||||
loop {
|
||||
if let Some(end) = self.buffered.iter().position(|byte| *byte == b'\n') {
|
||||
if end + 1 > MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
let line = self.buffered.drain(..=end).collect();
|
||||
self.partial_started = if self.buffered.is_empty() {
|
||||
None
|
||||
} else {
|
||||
self.partial_started.or_else(|| Some(Instant::now()))
|
||||
};
|
||||
return Ok(line);
|
||||
}
|
||||
if self.buffered.len() >= MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
let remaining = match Self::remaining(deadline) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
if !self.buffered.is_empty() {
|
||||
self.close();
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if let Err(error) = self.stream.set_read_timeout(Some(remaining)) {
|
||||
self.close();
|
||||
return Err(WireError::Io(error));
|
||||
}
|
||||
let mut chunk = [0_u8; 4096];
|
||||
match self.stream.read(&mut chunk) {
|
||||
Ok(0) => {
|
||||
self.close();
|
||||
return Err(WireError::Eof);
|
||||
}
|
||||
Ok(length) => {
|
||||
if self.buffered.is_empty() {
|
||||
self.partial_started = Some(Instant::now());
|
||||
}
|
||||
self.buffered.extend_from_slice(&chunk[..length]);
|
||||
}
|
||||
Err(error) => {
|
||||
let error = Self::transport_error(error);
|
||||
if !matches!(error, WireError::Timeout) || !self.buffered.is_empty() {
|
||||
self.close();
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_line(&mut self) -> Result<Vec<u8>, WireError> {
|
||||
self.read_line_before(Instant::now() + self.timeout)
|
||||
}
|
||||
|
||||
/// Check one socket slice without coupling ASIC polling to pool silence.
|
||||
/// An unfinished line has its own absolute deadline across calls.
|
||||
pub fn try_read_line(&mut self) -> Result<Option<Vec<u8>>, WireError> {
|
||||
if self.closed {
|
||||
return Err(WireError::Closed);
|
||||
}
|
||||
if let Some(line) = self.try_read_line_buffered()? {
|
||||
return Ok(Some(line));
|
||||
}
|
||||
if self
|
||||
.partial_started
|
||||
.is_some_and(|start| start.elapsed() >= MAX_PARTIAL_AGE)
|
||||
{
|
||||
self.close();
|
||||
return Err(WireError::Timeout);
|
||||
}
|
||||
self.stream
|
||||
.set_read_timeout(Some(READ_SLICE))
|
||||
.map_err(WireError::Io)?;
|
||||
let mut chunk = [0_u8; 4096];
|
||||
match self.stream.read(&mut chunk) {
|
||||
Ok(0) => {
|
||||
self.close();
|
||||
Err(WireError::Eof)
|
||||
}
|
||||
Ok(length) => {
|
||||
if self.buffered.is_empty() {
|
||||
self.partial_started = Some(Instant::now());
|
||||
}
|
||||
self.buffered.extend_from_slice(&chunk[..length]);
|
||||
self.try_read_line_buffered()
|
||||
}
|
||||
Err(error)
|
||||
if matches!(
|
||||
error.kind(),
|
||||
io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock
|
||||
) =>
|
||||
{
|
||||
Ok(None)
|
||||
}
|
||||
Err(error) => {
|
||||
self.close();
|
||||
Err(WireError::Io(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn try_read_line_buffered(&mut self) -> Result<Option<Vec<u8>>, WireError> {
|
||||
if let Some(end) = self.buffered.iter().position(|byte| *byte == b'\n') {
|
||||
if end + 1 > MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
let line = self.buffered.drain(..=end).collect();
|
||||
self.partial_started = if self.buffered.is_empty() {
|
||||
None
|
||||
} else {
|
||||
self.partial_started.or_else(|| Some(Instant::now()))
|
||||
};
|
||||
return Ok(Some(line));
|
||||
}
|
||||
if self.buffered.len() >= MAX_POOL_LINE_BYTES {
|
||||
self.close();
|
||||
return Err(WireError::LineTooLong);
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn send_line_before(&mut self, line: &[u8], deadline: Instant) -> Result<(), WireError> {
|
||||
if self.closed {
|
||||
return Err(WireError::Closed);
|
||||
}
|
||||
if line.is_empty()
|
||||
|| line.len() > MAX_POOL_LINE_BYTES
|
||||
|| line.last() != Some(&b'\n')
|
||||
|| line[..line.len() - 1].contains(&b'\n')
|
||||
{
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
let mut sent = 0;
|
||||
while sent < line.len() {
|
||||
let remaining = match Self::remaining(deadline) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
self.close();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if let Err(error) = self.stream.set_write_timeout(Some(remaining)) {
|
||||
self.close();
|
||||
return Err(WireError::Io(error));
|
||||
}
|
||||
match self.stream.write(&line[sent..]) {
|
||||
Ok(0) => {
|
||||
self.close();
|
||||
return Err(WireError::Eof);
|
||||
}
|
||||
Ok(length) => sent += length,
|
||||
Err(error) => {
|
||||
self.close();
|
||||
return Err(Self::transport_error(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn send_line(&mut self, line: &[u8]) -> Result<(), WireError> {
|
||||
self.send_line_before(line, Instant::now() + self.write_timeout)
|
||||
}
|
||||
|
||||
fn read_reply(
|
||||
&mut self,
|
||||
request_id: u64,
|
||||
deadline: Instant,
|
||||
early: &mut Vec<Vec<u8>>,
|
||||
early_bytes: &mut usize,
|
||||
) -> Result<Vec<u8>, HandshakeError> {
|
||||
loop {
|
||||
let line = self
|
||||
.read_line_before(deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let message: serde_json::Value = serde_json::from_slice(&line)
|
||||
.map_err(|_| HandshakeError::Pool(PoolMessageError::Json))?;
|
||||
if message.get("id").and_then(serde_json::Value::as_u64) == Some(request_id) {
|
||||
return Ok(line);
|
||||
}
|
||||
if !message.get("id").is_none_or(serde_json::Value::is_null)
|
||||
|| !matches!(
|
||||
message.get("method").and_then(serde_json::Value::as_str),
|
||||
Some(
|
||||
"mining.set_difficulty"
|
||||
| "mining.set_version_mask"
|
||||
| "mining.set_extranonce"
|
||||
| "mining.notify"
|
||||
)
|
||||
)
|
||||
{
|
||||
return Err(HandshakeError::Pool(PoolMessageError::WrongMessage));
|
||||
}
|
||||
*early_bytes += line.len();
|
||||
if early.len() >= MAX_EARLY_NOTIFICATIONS || *early_bytes > MAX_EARLY_NOTIFICATION_BYTES
|
||||
{
|
||||
return Err(HandshakeError::TooManyNotifications);
|
||||
}
|
||||
early.push(line);
|
||||
}
|
||||
}
|
||||
|
||||
/// Negotiate BIP310, subscribe, and authorize in that order. The entire
|
||||
/// handshake shares one absolute deadline; early notifications are kept
|
||||
/// for the caller to apply before reading new pool lines.
|
||||
pub fn handshake(
|
||||
&mut self,
|
||||
agent: &str,
|
||||
worker: &str,
|
||||
password: &str,
|
||||
timeout: Duration,
|
||||
) -> Result<PoolHandshake, HandshakeError> {
|
||||
let result = self.handshake_inner(agent, worker, password, timeout);
|
||||
if result.is_err() {
|
||||
self.close();
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn handshake_inner(
|
||||
&mut self,
|
||||
agent: &str,
|
||||
worker: &str,
|
||||
password: &str,
|
||||
timeout: Duration,
|
||||
) -> Result<PoolHandshake, HandshakeError> {
|
||||
let deadline = Instant::now()
|
||||
.checked_add(timeout)
|
||||
.filter(|_| !timeout.is_zero())
|
||||
.ok_or(HandshakeError::Wire(WireError::InvalidRequest))?;
|
||||
let subscribe = subscribe_request(2, agent).map_err(HandshakeError::Wire)?;
|
||||
let authorize = authorize_request(3, worker, password).map_err(HandshakeError::Wire)?;
|
||||
let mut early_notifications = Vec::new();
|
||||
let mut early_bytes = 0;
|
||||
self.send_line_before(configure_request(1).as_bytes(), deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let configure = self.read_reply(1, deadline, &mut early_notifications, &mut early_bytes)?;
|
||||
let configure = parse_configure_result(&configure, 1).map_err(HandshakeError::Pool)?;
|
||||
self.send_line_before(subscribe.as_bytes(), deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let subscription =
|
||||
self.read_reply(2, deadline, &mut early_notifications, &mut early_bytes)?;
|
||||
let subscription = parse_subscription(&subscription, 2).map_err(HandshakeError::Pool)?;
|
||||
self.send_line_before(authorize.as_bytes(), deadline)
|
||||
.map_err(HandshakeError::Wire)?;
|
||||
let authorized =
|
||||
self.read_reply(3, deadline, &mut early_notifications, &mut early_bytes)?;
|
||||
if !parse_boolean_response(&authorized, 3).map_err(HandshakeError::Pool)? {
|
||||
return Err(HandshakeError::Rejected);
|
||||
}
|
||||
Ok(PoolHandshake {
|
||||
subscription,
|
||||
configure,
|
||||
early_notifications,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Offer BIP310 version rolling and extranonce updates before subscribing.
|
||||
pub fn configure_request(id: u64) -> String {
|
||||
json!({
|
||||
"id": id,
|
||||
"method": "mining.configure",
|
||||
"params": [
|
||||
["version-rolling", "subscribe-extranonce"],
|
||||
{"version-rolling.mask": "1fffe000", "version-rolling.min-bit-count": 0}
|
||||
]
|
||||
})
|
||||
.to_string()
|
||||
+ "\n"
|
||||
}
|
||||
|
||||
pub fn subscribe_request(id: u64, agent: &str) -> Result<String, WireError> {
|
||||
if agent.is_empty() || agent.len() > 128 {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
Ok(json!({"id": id, "method": "mining.subscribe", "params": [agent]}).to_string() + "\n")
|
||||
}
|
||||
|
||||
pub fn authorize_request(id: u64, worker: &str, password: &str) -> Result<String, WireError> {
|
||||
if worker.is_empty() || worker.len() > 128 || password.len() > 256 {
|
||||
return Err(WireError::InvalidRequest);
|
||||
}
|
||||
Ok(
|
||||
json!({"id": id, "method": "mining.authorize", "params": [worker, password]}).to_string()
|
||||
+ "\n",
|
||||
)
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Construct SHA-256 Stratum V1 work after a protocol client decodes notify.
|
||||
//! This module assembles headers; it never searches for nonces.
|
||||
|
||||
use crate::pow::sha256d;
|
||||
|
||||
const MAX_COINBASE_BYTES: usize = 65_536;
|
||||
const MAX_MERKLE_BRANCHES: usize = 64;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum JobError {
|
||||
InvalidExtranonceSize,
|
||||
CoinbaseTooLarge,
|
||||
TooManyMerkleBranches,
|
||||
ExtranonceLength,
|
||||
}
|
||||
|
||||
/// Binary fields from `mining.notify`, plus `mining.subscribe` extranonce data.
|
||||
/// `prevhash_stratum` is the eight word-swapped 32-bit words sent on the wire.
|
||||
pub struct Sha256Job {
|
||||
pub prevhash_stratum: [u8; 32],
|
||||
pub coinb1: Vec<u8>,
|
||||
pub coinb2: Vec<u8>,
|
||||
pub merkle_branches: Vec<[u8; 32]>,
|
||||
pub version: u32,
|
||||
pub nbits: u32,
|
||||
pub ntime: u32,
|
||||
pub extranonce1: Vec<u8>,
|
||||
pub extranonce2_size: usize,
|
||||
}
|
||||
|
||||
impl Sha256Job {
|
||||
pub fn validate(&self) -> Result<(), JobError> {
|
||||
if self.extranonce1.len() > 32 || self.extranonce2_size > 32 {
|
||||
return Err(JobError::InvalidExtranonceSize);
|
||||
}
|
||||
let total = self
|
||||
.coinb1
|
||||
.len()
|
||||
.checked_add(self.extranonce1.len())
|
||||
.and_then(|sum| sum.checked_add(self.extranonce2_size))
|
||||
.and_then(|sum| sum.checked_add(self.coinb2.len()));
|
||||
if total.is_none_or(|sum| sum > MAX_COINBASE_BYTES) {
|
||||
return Err(JobError::CoinbaseTooLarge);
|
||||
}
|
||||
if self.merkle_branches.len() > MAX_MERKLE_BRANCHES {
|
||||
return Err(JobError::TooManyMerkleBranches);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn nonce_zero_header(&self, extranonce2: &[u8], ntime: u32) -> Result<[u8; 80], JobError> {
|
||||
self.validate()?;
|
||||
if extranonce2.len() != self.extranonce2_size {
|
||||
return Err(JobError::ExtranonceLength);
|
||||
}
|
||||
let mut coinbase = Vec::with_capacity(
|
||||
self.coinb1.len() + self.extranonce1.len() + extranonce2.len() + self.coinb2.len(),
|
||||
);
|
||||
coinbase.extend_from_slice(&self.coinb1);
|
||||
coinbase.extend_from_slice(&self.extranonce1);
|
||||
coinbase.extend_from_slice(extranonce2);
|
||||
coinbase.extend_from_slice(&self.coinb2);
|
||||
let mut root = sha256d(&coinbase);
|
||||
for branch in &self.merkle_branches {
|
||||
let mut pair = [0_u8; 64];
|
||||
pair[..32].copy_from_slice(&root);
|
||||
pair[32..].copy_from_slice(branch);
|
||||
root = sha256d(&pair);
|
||||
}
|
||||
let mut header = [0_u8; 80];
|
||||
header[..4].copy_from_slice(&self.version.to_le_bytes());
|
||||
for (index, word) in self.prevhash_stratum.chunks_exact(4).enumerate() {
|
||||
for (offset, byte) in word.iter().rev().enumerate() {
|
||||
header[4 + index * 4 + offset] = *byte;
|
||||
}
|
||||
}
|
||||
header[36..68].copy_from_slice(&root);
|
||||
header[68..72].copy_from_slice(&ntime.to_le_bytes());
|
||||
header[72..76].copy_from_slice(&self.nbits.to_le_bytes());
|
||||
Ok(header)
|
||||
}
|
||||
}
|
||||
@@ -1,469 +0,0 @@
|
||||
use alkane_os::bm1362::{
|
||||
bt8d_for_baud, chain_inactive, encode_job, encode_work as encode_bm1362_work, read_register,
|
||||
read_register_all, set_chip_address, write_register, write_register_all, Job, S19J_PRO,
|
||||
};
|
||||
use alkane_os::bm1366::{decode_nonce_report, encode_work};
|
||||
use alkane_os::bm13xx::{crc16, crc5};
|
||||
use alkane_os::difficulty::PoolDifficulty;
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::miner::Bm1366Miner;
|
||||
use alkane_os::pow::verify_sha256_report;
|
||||
use alkane_os::pow::VersionMask;
|
||||
use alkane_os::scrypt_pow::verify_scrypt_header;
|
||||
use alkane_os::stratum_session::PoolSession;
|
||||
use alkane_os::stratum_submit::{format_submission, Submission};
|
||||
use alkane_os::stratum_v1::{
|
||||
parse_boolean_response, parse_configure_result, parse_control_notification, parse_notify,
|
||||
parse_subscription, Subscription,
|
||||
};
|
||||
use alkane_os::stratum_wire::{
|
||||
authorize_request, configure_request, subscribe_request, StratumWire,
|
||||
};
|
||||
use alkane_os::stratum_work::Sha256Job;
|
||||
use alkane_os::{power_decision, target_matrix, HardwareBackend};
|
||||
use std::hint::black_box;
|
||||
use std::io::{Read, Write};
|
||||
use std::net::TcpListener;
|
||||
use std::os::unix::net::UnixStream;
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn sample(iterations: u64, f: &mut impl FnMut()) -> Duration {
|
||||
let started = Instant::now();
|
||||
for _ in 0..iterations {
|
||||
f();
|
||||
}
|
||||
started.elapsed()
|
||||
}
|
||||
|
||||
fn measure(name: &str, minimum_iterations: u64, mut f: impl FnMut()) {
|
||||
for _ in 0..minimum_iterations.min(1000) {
|
||||
f();
|
||||
}
|
||||
let mut iterations = minimum_iterations.max(1);
|
||||
while sample(iterations, &mut f) < Duration::from_millis(20) && iterations < 100_000_000 {
|
||||
iterations = (iterations * 2).min(100_000_000);
|
||||
}
|
||||
let mut measurements = [0_f64; 7];
|
||||
for value in &mut measurements {
|
||||
*value = sample(iterations, &mut f).as_nanos() as f64 / iterations as f64;
|
||||
}
|
||||
measurements.sort_by(f64::total_cmp);
|
||||
let ns = measurements[measurements.len() / 2];
|
||||
println!("BENCH {name} {ns:.3} ns/op");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_target_matrix() {
|
||||
measure("target_matrix", 20_000, || {
|
||||
black_box(
|
||||
target_matrix()
|
||||
.filter(|target| black_box(target.chip.algorithm) == alkane_os::Algorithm::Sha256)
|
||||
.count(),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_power_policy() {
|
||||
measure("power_policy", 100_000, || {
|
||||
black_box(power_decision(black_box(Some(64_000)), 80_000));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm13xx_crc5() {
|
||||
let command = [0x53, 0x05, 0, 0];
|
||||
measure("bm13xx_crc5", 100_000, || {
|
||||
black_box(crc5(black_box(&command)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm13xx_crc16() {
|
||||
let job = [0x21_u8; 84];
|
||||
measure("bm13xx_crc16", 20_000, || {
|
||||
black_box(crc16(black_box(&job)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_share_verification() {
|
||||
let header = [0_u8; 80];
|
||||
let target = [0xff_u8; 32];
|
||||
measure("share_verification", 20_000, || {
|
||||
black_box(verify_sha256_report(
|
||||
black_box(&header),
|
||||
black_box(0xEDAD_FF38),
|
||||
black_box(0x04B3),
|
||||
black_box(&target),
|
||||
));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_scrypt_share_verification() {
|
||||
let header = [0_u8; 80];
|
||||
let target = [0xff_u8; 32];
|
||||
measure("scrypt_share_verification", 4, || {
|
||||
black_box(verify_scrypt_header(black_box(&header), black_box(&target)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_work_encoding() {
|
||||
let header = [0_u8; 80];
|
||||
measure("bm1366_work_encoding", 20_000, || {
|
||||
black_box(encode_work(black_box(&header), black_box(0x18)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1362_commands() {
|
||||
measure("bm1362_commands", 20_000, || {
|
||||
black_box(chain_inactive());
|
||||
black_box(set_chip_address(black_box(8)));
|
||||
black_box(read_register(black_box(0x40), 0x1c));
|
||||
black_box(read_register_all(0));
|
||||
black_box(write_register(black_box(0x40), 0x18, 0x7a31));
|
||||
black_box(write_register_all(0x80, 0));
|
||||
black_box(bt8d_for_baud(black_box(115_200)));
|
||||
black_box(S19J_PRO.chip_addresses().last());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1362_job_encoding() {
|
||||
let job = Job {
|
||||
work_id: 8,
|
||||
num_midstates: 1,
|
||||
start_nonce: 0,
|
||||
nbits: 0x1a1f_2c34,
|
||||
ntime: 0x5e9b_3cd4,
|
||||
merkle_root: [0xa5; 32],
|
||||
previous_hash: [0x5a; 32],
|
||||
version: 0x2000_0000,
|
||||
};
|
||||
measure("bm1362_job_encoding", 20_000, || {
|
||||
black_box(encode_job(black_box(&job)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1362_work_encoding() {
|
||||
let header = [0_u8; 80];
|
||||
measure("bm1362_work_encoding", 20_000, || {
|
||||
black_box(encode_bm1362_work(black_box(&header), black_box(8)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_report_decode() {
|
||||
let report = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
measure("bm1366_report_decode", 100_000, || {
|
||||
let _ = black_box(decode_nonce_report(black_box(&report)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_header() {
|
||||
let job = Sha256Job {
|
||||
prevhash_stratum: [0; 32],
|
||||
coinb1: vec![0; 48],
|
||||
coinb2: vec![0; 64],
|
||||
merkle_branches: vec![[0; 32]; 4],
|
||||
version: 0x2000_0000,
|
||||
nbits: 0x1d00_ffff,
|
||||
ntime: 0x6655_4433,
|
||||
extranonce1: vec![0; 4],
|
||||
extranonce2_size: 8,
|
||||
};
|
||||
measure("stratum_header", 5_000, || {
|
||||
black_box(
|
||||
job.nonce_zero_header(black_box(&[0; 8]), job.ntime)
|
||||
.unwrap(),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_submission() {
|
||||
let share = Submission {
|
||||
request_id: 1,
|
||||
worker: "miner.worker",
|
||||
job_id: "job-123",
|
||||
extranonce2: &[0; 8],
|
||||
ntime: 0x680f_6a2e,
|
||||
nonce: 0xedad_ff38,
|
||||
base_version: 0x2000_0000,
|
||||
rolled_version: 0x2096_6000,
|
||||
version_mask: Some(VersionMask::new(0x1fff_e000).unwrap()),
|
||||
};
|
||||
measure("stratum_submission", 20_000, || {
|
||||
black_box(format_submission(black_box(&share)).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_authorize_format() {
|
||||
measure("stratum_authorize_format", 20_000, || {
|
||||
black_box(authorize_request(black_box(3), "miner.worker", "password").unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_configure_format() {
|
||||
measure("stratum_configure_format", 20_000, || {
|
||||
black_box(configure_request(black_box(1)));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_subscribe_format() {
|
||||
measure("stratum_subscribe_format", 20_000, || {
|
||||
black_box(subscribe_request(black_box(2), "alkane-os/0.1").unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_subscription_parse() {
|
||||
let line = br#"{"id":1,"result":[[["mining.notify","session"]],"01020304",4],"error":null}"#;
|
||||
measure("stratum_subscription_parse", 20_000, || {
|
||||
black_box(parse_subscription(black_box(line), black_box(1)).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_accept_parse() {
|
||||
let line = br#"{"id":5,"result":true,"error":null}"#;
|
||||
measure("stratum_accept_parse", 20_000, || {
|
||||
black_box(parse_boolean_response(black_box(line), black_box(5)).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_notify_parse() {
|
||||
let line = serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
"job-1",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", true
|
||||
]
|
||||
})
|
||||
.to_string();
|
||||
let subscription = Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
};
|
||||
measure("stratum_notify_parse", 20_000, || {
|
||||
black_box(parse_notify(black_box(line.as_bytes()), &subscription).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_control_parse() {
|
||||
let line = br#"{"id":null,"method":"mining.set_difficulty","params":[2048.5]}"#;
|
||||
measure("stratum_control_parse", 20_000, || {
|
||||
black_box(parse_control_notification(black_box(line), false, false).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_configure_parse() {
|
||||
let line = br#"{"id":1,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000","subscribe-extranonce":true},"error":null}"#;
|
||||
measure("stratum_configure_parse", 20_000, || {
|
||||
black_box(parse_configure_result(black_box(line), 1).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_difficulty_target() {
|
||||
let number = serde_json::from_str("2048.5").unwrap();
|
||||
let difficulty = PoolDifficulty::from_json_number(&number).unwrap();
|
||||
measure("difficulty_target", 20_000, || {
|
||||
black_box(black_box(difficulty).target_le());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_job_issue() {
|
||||
let line = serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
"job-1", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", true
|
||||
]
|
||||
})
|
||||
.to_string();
|
||||
let mut session = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
None,
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
session
|
||||
.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
measure("stratum_job_issue", 5_000, || {
|
||||
session.after_hardware_reset();
|
||||
black_box(session.issue_notify(black_box(line.as_bytes())).unwrap());
|
||||
});
|
||||
}
|
||||
|
||||
struct BenchBackend {
|
||||
report: Option<[u8; 11]>,
|
||||
}
|
||||
|
||||
impl HardwareBackend for BenchBackend {
|
||||
type Error = ();
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
black_box(frame);
|
||||
Ok(())
|
||||
}
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
if let Some(report) = self.report {
|
||||
frame[..report.len()].copy_from_slice(&report);
|
||||
Ok(report.len())
|
||||
} else {
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
fn set_chain_reset(&mut self, _chain: u8, _asserted: bool) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
Ok(50_000)
|
||||
}
|
||||
fn set_psu_enabled(&mut self, _enabled: bool) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_session_cycle() {
|
||||
let header = [0_u8; 80];
|
||||
let target = [0xff_u8; 32];
|
||||
measure("bm1366_session_cycle", 20_000, || {
|
||||
let mut backend = BenchBackend { report: None };
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner
|
||||
.submit(black_box(header), black_box(target), 0x18)
|
||||
.unwrap();
|
||||
black_box(miner.poll().unwrap());
|
||||
miner.stop().unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_bm1366_captured_report_poll() {
|
||||
let header = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38,
|
||||
0x9d, 0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6,
|
||||
0xc2, 0x25, 0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06,
|
||||
0x8f, 0xe1, 0x78, 0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0,
|
||||
0x4a, 0xab, 0x2b, 0x38, 0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02,
|
||||
0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
let report = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
let mut target = [0_u8; 32];
|
||||
target[26..28].fill(0xff);
|
||||
let mut backend = BenchBackend {
|
||||
report: Some(report),
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(header, target, 0x18).unwrap();
|
||||
measure("bm1366_captured_report_poll", 20_000, || {
|
||||
let share = miner.poll().unwrap().unwrap();
|
||||
assert_eq!(black_box(share).nonce, 0xedad_ff38);
|
||||
});
|
||||
miner.stop().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_hal_socket_exchange() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
let mut payload = [0_u8; 2];
|
||||
while server.read_exact(&mut header).is_ok() {
|
||||
assert_eq!(&header[..6], b"ALKH\x01\x04");
|
||||
assert_eq!(u32::from_le_bytes(header[12..16].try_into().unwrap()), 2);
|
||||
server.read_exact(&mut payload).unwrap();
|
||||
assert_eq!(payload, [0, 80]);
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
||||
server.write_all(&header).unwrap();
|
||||
server.write_all(&[0]).unwrap();
|
||||
}
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
measure("hal_socket_exchange", 100, || {
|
||||
backend.set_fan_target(black_box(0), black_box(80)).unwrap();
|
||||
});
|
||||
drop(backend);
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "microbenchmark"]
|
||||
fn bench_stratum_socket_round_trip() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let (mut server, _) = listener.accept().unwrap();
|
||||
let mut request = [0_u8; 3];
|
||||
while server.read_exact(&mut request).is_ok() {
|
||||
assert_eq!(&request, b"{}\n");
|
||||
server.write_all(b"{}\n").unwrap();
|
||||
}
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
measure("stratum_socket_round_trip", 100, || {
|
||||
wire.send_line(black_box(b"{}\n")).unwrap();
|
||||
black_box(wire.read_line().unwrap());
|
||||
});
|
||||
drop(wire);
|
||||
worker.join().unwrap();
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::difficulty::{DifficultyError, PoolDifficulty};
|
||||
|
||||
fn target(decimal: &str) -> String {
|
||||
let number = serde_json::from_str(decimal).unwrap();
|
||||
PoolDifficulty::from_json_number(&number)
|
||||
.unwrap()
|
||||
.target_le()
|
||||
.iter()
|
||||
.rev()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_share_targets_match_integer_reference() {
|
||||
for (difficulty, expected) in [
|
||||
(
|
||||
"1",
|
||||
"00000000ffff0000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"2",
|
||||
"000000007fff8000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"0.5",
|
||||
"00000001fffe0000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"1.25",
|
||||
"00000000cccc0000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"2048.5",
|
||||
"00000000001ffde021fde021fde021fde021fde021fde021fde021fde021fde0",
|
||||
),
|
||||
(
|
||||
"0.000001",
|
||||
"000f4230bdc00000000000000000000000000000000000000000000000000000",
|
||||
),
|
||||
(
|
||||
"1000000000000000000",
|
||||
"000000000000000000000012724b5f7471d95d3bbefee5e602a7b17261180d8e",
|
||||
),
|
||||
] {
|
||||
assert_eq!(target(difficulty), expected, "difficulty {difficulty}");
|
||||
}
|
||||
assert_eq!(target("1.2e3"), target("1200"));
|
||||
assert_eq!(target("1e-19"), "ff".repeat(32));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_or_unrepresentable_difficulty_is_rejected() {
|
||||
let zero = serde_json::from_str("0").unwrap();
|
||||
assert_eq!(
|
||||
PoolDifficulty::from_json_number(&zero),
|
||||
Err(DifficultyError::Invalid)
|
||||
);
|
||||
let negative = serde_json::from_str("-1").unwrap();
|
||||
assert_eq!(
|
||||
PoolDifficulty::from_json_number(&negative),
|
||||
Err(DifficultyError::OutOfRange)
|
||||
);
|
||||
for value in ["1e20", "1e-20", "1.00000000000000000001"] {
|
||||
let number = serde_json::from_str(value).unwrap();
|
||||
assert_eq!(
|
||||
PoolDifficulty::from_json_number(&number),
|
||||
Err(DifficultyError::OutOfRange),
|
||||
"difficulty {value}"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,214 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::hal_wire::{HalClient, HalError};
|
||||
use alkane_os::HardwareBackend;
|
||||
use std::io::{Read, Write};
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn reply(socket: &mut UnixStream, request: &[u8; 16], body: &[u8]) {
|
||||
let mut header = *request;
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
socket.write_all(&header).unwrap();
|
||||
socket.write_all(body).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sdk_backend_round_trip_and_safety_limits() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let expected = [
|
||||
(1, vec![2, 3, 0, 0x55, 0xaa, 0x21], vec![0]),
|
||||
(2, vec![2, 8, 0], vec![0, 3, 0, 0xaa, 0x55, 0x01]),
|
||||
(3, vec![2, 1], vec![0]),
|
||||
(4, vec![0, 90], vec![0]),
|
||||
(
|
||||
5,
|
||||
vec![1],
|
||||
[vec![0], 72_500_i32.to_le_bytes().to_vec()].concat(),
|
||||
),
|
||||
(6, vec![1], vec![0]),
|
||||
];
|
||||
for (index, (opcode, request_body, response_body)) in expected.iter().enumerate() {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
assert_eq!(&header[..4], b"ALKH");
|
||||
assert_eq!(header[4], 1);
|
||||
assert_eq!(header[5], *opcode);
|
||||
assert_eq!(
|
||||
u32::from_le_bytes(header[8..12].try_into().unwrap()),
|
||||
index as u32 + 1
|
||||
);
|
||||
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
||||
let mut body = vec![0_u8; length];
|
||||
server.read_exact(&mut body).unwrap();
|
||||
assert_eq!(&body, request_body);
|
||||
reply(&mut server, &header, response_body);
|
||||
}
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
backend.send_frame(2, &[0x55, 0xaa, 0x21]).unwrap();
|
||||
let mut buffer = [0_u8; 8];
|
||||
assert_eq!(backend.receive_frame(2, &mut buffer).unwrap(), 3);
|
||||
assert_eq!(&buffer[..3], &[0xaa, 0x55, 0x01]);
|
||||
backend.set_chain_reset(2, true).unwrap();
|
||||
backend.set_fan_target(0, 90).unwrap();
|
||||
assert_eq!(backend.read_temperature_mc(1).unwrap(), 72_500);
|
||||
backend.set_psu_enabled(true).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_fan_target(0, 101),
|
||||
Err(HalError::InvalidFanPercent)
|
||||
));
|
||||
assert!(matches!(
|
||||
backend.send_frame(0, &[0_u8; 4094]),
|
||||
Err(HalError::FrameTooLong)
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_wrong_response_sequence() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut body = [0_u8; 1];
|
||||
server.read_exact(&mut body).unwrap();
|
||||
header[8..12].copy_from_slice(&2_u32.to_le_bytes());
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
||||
server.write_all(&header).unwrap();
|
||||
let mut one = [0_u8; 1];
|
||||
assert_eq!(server.read(&mut one).unwrap(), 0);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("response sequence mismatch"))
|
||||
));
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("connection is unusable"))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_power_off_ends_backend_power_lease() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut body = [0_u8; 1];
|
||||
server.read_exact(&mut body).unwrap();
|
||||
assert_eq!(header[5], 6);
|
||||
assert_eq!(body, [0]);
|
||||
reply(&mut server, &header, &[3]);
|
||||
assert_eq!(server.read(&mut body).unwrap(), 0);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(false),
|
||||
Err(HalError::Device(3))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_temperature_response_disconnects_power_lease() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
assert_eq!(header[5], 5);
|
||||
reply(&mut server, &header, &[0, 1]);
|
||||
assert_eq!(server.read(&mut request).unwrap(), 0);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.read_temperature_mc(1),
|
||||
Err(HalError::Protocol("invalid temperature response"))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_malformed_error_response_and_poisoned_connection() {
|
||||
for body in [&[4_u8][..], &[3_u8, 99][..]] {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let response = body.to_vec();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
reply(&mut server, &header, &response);
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("invalid error response"))
|
||||
));
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Protocol("connection is unusable"))
|
||||
));
|
||||
worker.join().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn slow_partial_response_hits_absolute_exchange_deadline() {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
||||
for byte in header.into_iter().chain([0]) {
|
||||
if server.write_all(&[byte]).is_err() {
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(250));
|
||||
}
|
||||
});
|
||||
let mut backend = HalClient::from_stream(client).unwrap();
|
||||
let start = Instant::now();
|
||||
assert!(matches!(
|
||||
backend.set_psu_enabled(true),
|
||||
Err(HalError::Io(_))
|
||||
));
|
||||
assert!(start.elapsed() < Duration::from_secs(4));
|
||||
drop(backend);
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connects_to_a_local_backend_socket() {
|
||||
let path = std::env::temp_dir().join(format!(
|
||||
"alkane-hal-{}-{}.sock",
|
||||
std::process::id(),
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_nanos()
|
||||
));
|
||||
let listener = UnixListener::bind(&path).unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let (mut server, _) = listener.accept().unwrap();
|
||||
let mut header = [0_u8; 16];
|
||||
server.read_exact(&mut header).unwrap();
|
||||
let mut request = [0_u8; 1];
|
||||
server.read_exact(&mut request).unwrap();
|
||||
reply(&mut server, &header, &[0]);
|
||||
});
|
||||
let mut backend = HalClient::connect(&path).unwrap();
|
||||
backend.set_psu_enabled(true).unwrap();
|
||||
worker.join().unwrap();
|
||||
std::fs::remove_file(path).unwrap();
|
||||
}
|
||||
@@ -1,360 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::bm1366::REPORT_BYTES;
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel, MinerError};
|
||||
use alkane_os::HardwareBackend;
|
||||
|
||||
const HEADER: [u8; 80] = [
|
||||
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38, 0x9d,
|
||||
0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6, 0xc2, 0x25,
|
||||
0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06, 0x8f, 0xe1, 0x78,
|
||||
0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0, 0x4a, 0xab, 0x2b, 0x38,
|
||||
0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02, 0x17, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
const REPORT: [u8; REPORT_BYTES] = [
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
];
|
||||
|
||||
fn diff_one() -> [u8; 32] {
|
||||
let mut target = [0_u8; 32];
|
||||
target[26..28].fill(0xff);
|
||||
target
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct FakeBackend {
|
||||
events: Vec<&'static str>,
|
||||
temperatures: Vec<i32>,
|
||||
powered: bool,
|
||||
fail_off_call: usize,
|
||||
off_calls: usize,
|
||||
fail_reset_call: usize,
|
||||
reset_calls: usize,
|
||||
report: Option<[u8; REPORT_BYTES]>,
|
||||
additional_reports: Vec<[u8; REPORT_BYTES]>,
|
||||
sent: Vec<u8>,
|
||||
}
|
||||
|
||||
impl HardwareBackend for FakeBackend {
|
||||
type Error = &'static str;
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
assert!(self.powered);
|
||||
self.events.push("send");
|
||||
self.sent = frame.to_vec();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
self.events.push("receive");
|
||||
if let Some(report) = self.report.take().or_else(|| self.additional_reports.pop()) {
|
||||
frame[..REPORT_BYTES].copy_from_slice(&report);
|
||||
Ok(REPORT_BYTES)
|
||||
} else {
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
|
||||
fn set_chain_reset(&mut self, _chain: u8, asserted: bool) -> Result<(), Self::Error> {
|
||||
assert!(self.powered);
|
||||
self.reset_calls += 1;
|
||||
if self.reset_calls == self.fail_reset_call {
|
||||
return Err("reset failed");
|
||||
}
|
||||
self.events
|
||||
.push(if asserted { "reset-on" } else { "reset-off" });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_fan_target(&mut self, _fan: u8, percent: u8) -> Result<(), Self::Error> {
|
||||
assert!(percent > 0);
|
||||
self.events.push("fan");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
self.events.push("temperature");
|
||||
if self.temperatures.is_empty() {
|
||||
return Err("sensor unavailable");
|
||||
}
|
||||
Ok(self.temperatures.remove(0))
|
||||
}
|
||||
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
self.events.push(if enabled { "psu-on" } else { "psu-off" });
|
||||
if !enabled {
|
||||
self.off_calls += 1;
|
||||
if self.off_calls == self.fail_off_call {
|
||||
return Err("power-off did not complete");
|
||||
}
|
||||
}
|
||||
self.powered = enabled;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_nonce_passes_a_started_miner() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 50_000],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
{
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
let share = miner.poll().unwrap().unwrap();
|
||||
assert_eq!(share.nonce, 0xedad_ff38);
|
||||
assert_eq!(share.work_id, 0x18);
|
||||
assert_eq!(share.rolled_version, 0x2096_6000);
|
||||
miner.stop().unwrap();
|
||||
}
|
||||
assert!(!backend.powered);
|
||||
assert_eq!(&backend.sent[..5], &[0x55, 0xaa, 0x21, 0x54, 0x18]);
|
||||
assert_eq!(
|
||||
&backend.events[..6],
|
||||
&[
|
||||
"psu-off",
|
||||
"temperature",
|
||||
"fan",
|
||||
"psu-on",
|
||||
"reset-on",
|
||||
"reset-off"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real_bm1362_capture_uses_its_job_format_and_shared_report() {
|
||||
// SDK capture bm1362-real-nonces.txt: one real-silicon pool-accepted share.
|
||||
// This checks host framing and proof only; board initialization is separate.
|
||||
let header_hex = concat!(
|
||||
"00000020fc3ab8d43021f45eb662389d0f791f657dbf75a5cb93670b57b6c22503b4213a",
|
||||
"0503969b7384e1215aace8cfc65dae22d8493ad48fec0b7ac3b0ad7b4e7fb0c5",
|
||||
"c0012e6a8f06021700000000"
|
||||
);
|
||||
let mut header = [0_u8; 80];
|
||||
for (byte, pair) in header.iter_mut().zip(header_hex.as_bytes().chunks_exact(2)) {
|
||||
*byte = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
let report = [
|
||||
0xaa, 0x55, 0x33, 0x25, 0x0b, 0x63, 0x00, 0x18, 0x67, 0x6b, 0x95,
|
||||
];
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 3],
|
||||
report: Some(report),
|
||||
..Default::default()
|
||||
};
|
||||
{
|
||||
let mut miner =
|
||||
Bm1366Miner::new_for_chip(&mut backend, ChipModel::Bm1362, 0, 0, 0, 100, 80_000)
|
||||
.unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(header, diff_one(), 0x18).unwrap();
|
||||
let share = miner.poll().unwrap().unwrap();
|
||||
assert_eq!(share.nonce, 0x630b_2533);
|
||||
assert_eq!(share.work_id, 0x18);
|
||||
assert_eq!(share.rolled_version, 0x2ced_6000);
|
||||
miner.stop().unwrap();
|
||||
}
|
||||
assert!(!backend.powered);
|
||||
assert_eq!(&backend.sent[..6], &[0x55, 0xaa, 0x21, 0x56, 0x18, 1]);
|
||||
assert_eq!(&backend.sent[10..14], &header[72..76]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hot_or_missing_sensor_stops_power() {
|
||||
let mut hot = FakeBackend {
|
||||
temperatures: vec![80_000],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut hot, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert_eq!(miner.start(), Err(MinerError::UnsafeTemperature(80_000)));
|
||||
drop(miner);
|
||||
assert!(!hot.powered);
|
||||
assert!(!hot.events.contains(&"psu-on"));
|
||||
|
||||
let mut missing = FakeBackend::default();
|
||||
let mut miner = Bm1366Miner::new(&mut missing, 0, 0, 0, 100, 80_000).unwrap();
|
||||
assert_eq!(
|
||||
miner.start(),
|
||||
Err(MinerError::Backend("sensor unavailable"))
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!missing.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn temperature_rise_stops_power_and_stale_reports_preserve_mining() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 90_000],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::UnsafeTemperature(90_000)));
|
||||
assert_eq!(miner.poll(), Err(MinerError::NotRunning));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 5],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x20).unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::StaleReport));
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(miner.poll(), Ok(None));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn earlier_in_flight_job_is_checked_against_its_own_target() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 5],
|
||||
report: Some(REPORT),
|
||||
additional_reports: vec![REPORT],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
miner.submit(HEADER, [0; 32], 0x20).unwrap();
|
||||
assert_eq!(miner.poll().unwrap().unwrap().work_id, 0x18);
|
||||
miner.clear_work();
|
||||
assert_eq!(miner.poll(), Err(MinerError::StaleReport));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn below_target_is_rejected_without_misreporting_a_share() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 50_000],
|
||||
report: Some(REPORT),
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, [0; 32], 0x18).unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::BelowTarget));
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_power_off_is_retried_on_drop() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000],
|
||||
fail_off_call: 2,
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert_eq!(miner.stop(), Err("power-off did not complete"));
|
||||
drop(miner);
|
||||
assert_eq!(backend.off_calls, 3);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_chain_flush_powers_off_before_work_id_reuse() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000],
|
||||
fail_reset_call: 3,
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert_eq!(
|
||||
miner.reset_chain(),
|
||||
Err(MinerError::Backend("reset failed"))
|
||||
);
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0),
|
||||
Err(MinerError::NotRunning)
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn work_id_stays_reserved_until_confirmed_chain_reset() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000; 6],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0x18),
|
||||
Err(MinerError::WorkIdInUse(0x18))
|
||||
);
|
||||
miner.clear_work();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0x18),
|
||||
Err(MinerError::WorkIdInUse(0x18))
|
||||
);
|
||||
miner.reset_chain().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
miner.stop().unwrap();
|
||||
drop(miner);
|
||||
assert_eq!(
|
||||
backend
|
||||
.events
|
||||
.iter()
|
||||
.filter(|event| **event == "send")
|
||||
.count(),
|
||||
2
|
||||
);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_work_request_still_checks_temperature() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000, 50_000, 90_000],
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
miner.submit(HEADER, diff_one(), 0x18).unwrap();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0x18),
|
||||
Err(MinerError::UnsafeTemperature(90_000))
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unconfirmed_power_off_blocks_mining_until_shutdown_retries() {
|
||||
let mut backend = FakeBackend {
|
||||
temperatures: vec![50_000],
|
||||
fail_off_call: 2,
|
||||
..Default::default()
|
||||
};
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
assert_eq!(miner.stop(), Err("power-off did not complete"));
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0),
|
||||
Err(MinerError::Faulted)
|
||||
);
|
||||
assert_eq!(miner.poll(), Err(MinerError::Faulted));
|
||||
assert_eq!(miner.reset_chain(), Err(MinerError::Faulted));
|
||||
miner.stop().unwrap();
|
||||
assert_eq!(
|
||||
miner.submit(HEADER, diff_one(), 0),
|
||||
Err(MinerError::NotRunning)
|
||||
);
|
||||
drop(miner);
|
||||
assert!(!backend.powered);
|
||||
}
|
||||
@@ -1,260 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::miner::{Bm1366Miner, MinerError, ValidShare};
|
||||
use alkane_os::pow::VersionMask;
|
||||
use alkane_os::stratum_session::{DispatchError, PoolSession, SessionError};
|
||||
use alkane_os::stratum_v1::Subscription;
|
||||
use alkane_os::HardwareBackend;
|
||||
|
||||
fn session() -> PoolSession {
|
||||
PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
},
|
||||
Some(VersionMask::new(0x1fff_e000).unwrap()),
|
||||
true,
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn notify(id: &str, clean: bool) -> String {
|
||||
serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
id,
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", clean
|
||||
]
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn difficulty_changes_on_next_job_and_old_work_keeps_its_target() {
|
||||
let mut pool = session();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("early", true).as_bytes()).err(),
|
||||
Some(SessionError::MissingDifficulty)
|
||||
);
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
let first = pool.issue_notify(notify("first", true).as_bytes()).unwrap();
|
||||
assert!(first.clean_jobs);
|
||||
assert_eq!(first.work_id, 0);
|
||||
assert_eq!(&first.target_le[26..28], &[0xff, 0xff]);
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[2]}"#)
|
||||
.unwrap();
|
||||
let second = pool
|
||||
.issue_notify(notify("second", false).as_bytes())
|
||||
.unwrap();
|
||||
assert!(!second.clean_jobs);
|
||||
assert_eq!(second.work_id, 8);
|
||||
assert_eq!(&second.target_le[26..28], &[0xff, 0x7f]);
|
||||
assert_ne!(first.header, second.header);
|
||||
assert_eq!(
|
||||
pool.control(br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#),
|
||||
Ok(true)
|
||||
);
|
||||
assert_eq!(
|
||||
pool.submission(
|
||||
ValidShare {
|
||||
nonce: 0xedad_ff38,
|
||||
work_id: first.work_id,
|
||||
rolled_version: 0x2000_0000,
|
||||
hash_le: [0; 32],
|
||||
},
|
||||
"worker",
|
||||
10,
|
||||
),
|
||||
Err(SessionError::StaleShare)
|
||||
);
|
||||
assert_eq!(
|
||||
pool.control(br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#),
|
||||
Ok(false)
|
||||
);
|
||||
let clean = pool.issue_notify(notify("third", true).as_bytes()).unwrap();
|
||||
assert!(clean.clean_jobs);
|
||||
assert_eq!(clean.work_id, 16);
|
||||
let old = ValidShare {
|
||||
nonce: 0xedad_ff38,
|
||||
work_id: first.work_id,
|
||||
rolled_version: 0x2000_0000,
|
||||
hash_le: [0; 32],
|
||||
};
|
||||
assert_eq!(
|
||||
pool.submission(old, "worker", 10),
|
||||
Err(SessionError::StaleShare)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extranonce_change_invalidates_jobs_without_reusing_asic_ids() {
|
||||
let mut pool = session();
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
let old = pool.issue_notify(notify("old", true).as_bytes()).unwrap();
|
||||
assert!(pool
|
||||
.control(br#"{"id":null,"method":"mining.set_extranonce","params":["aabbccdd",4]}"#)
|
||||
.unwrap());
|
||||
let new = pool.issue_notify(notify("new", false).as_bytes()).unwrap();
|
||||
assert_eq!(new.work_id, 8);
|
||||
assert_ne!(old.header, new.header);
|
||||
for index in 2..32 {
|
||||
let work = pool.issue_notify(notify("more", false).as_bytes()).unwrap();
|
||||
assert_eq!(work.work_id, (index as u8) << 3);
|
||||
}
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("exhausted", false).as_bytes())
|
||||
.err(),
|
||||
Some(SessionError::WorkIdsExhausted)
|
||||
);
|
||||
pool.after_hardware_reset();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("after-reset", false).as_bytes())
|
||||
.unwrap()
|
||||
.work_id,
|
||||
0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_length_extranonce_requires_distinct_header_until_hardware_reset() {
|
||||
let mut pool = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1],
|
||||
extranonce2_size: 0,
|
||||
},
|
||||
None,
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
pool.issue_notify(notify("one", true).as_bytes()).unwrap();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("two", false).as_bytes()).err(),
|
||||
Some(SessionError::ExtranonceExhausted)
|
||||
);
|
||||
let distinct = notify("two", true).replace("66554433", "66554434");
|
||||
pool.issue_notify(distinct.as_bytes()).unwrap();
|
||||
pool.after_hardware_reset();
|
||||
pool.issue_notify(notify("three", true).as_bytes()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_byte_extranonce_restarts_only_for_a_distinct_header_template() {
|
||||
let mut pool = PoolSession::new(
|
||||
Subscription {
|
||||
extranonce1: vec![1],
|
||||
extranonce2_size: 1,
|
||||
},
|
||||
None,
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
pool.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
|
||||
.unwrap();
|
||||
for index in 0..256 {
|
||||
if index != 0 && index % 32 == 0 {
|
||||
pool.after_hardware_reset();
|
||||
}
|
||||
pool.issue_notify(notify("same", false).as_bytes()).unwrap();
|
||||
}
|
||||
pool.after_hardware_reset();
|
||||
assert_eq!(
|
||||
pool.issue_notify(notify("same", false).as_bytes()).err(),
|
||||
Some(SessionError::ExtranonceExhausted)
|
||||
);
|
||||
let distinct = notify("new", false).replace("66554433", "66554434");
|
||||
pool.issue_notify(distinct.as_bytes()).unwrap();
|
||||
pool.after_hardware_reset();
|
||||
for index in 0..256_u32 {
|
||||
if index != 0 && index % 32 == 0 {
|
||||
pool.after_hardware_reset();
|
||||
}
|
||||
let ntime = format!("{index:08x}");
|
||||
let next = notify("fresh", false).replace("66554433", &ntime);
|
||||
pool.issue_notify(next.as_bytes()).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
struct FakeBackend {
|
||||
powered: bool,
|
||||
sent: usize,
|
||||
report: Option<[u8; 11]>,
|
||||
}
|
||||
|
||||
impl HardwareBackend for FakeBackend {
|
||||
type Error = &'static str;
|
||||
|
||||
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
|
||||
assert!(self.powered);
|
||||
assert_eq!(&frame[..4], &[0x55, 0xaa, 0x21, 0x54]);
|
||||
self.sent += 1;
|
||||
Ok(())
|
||||
}
|
||||
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
|
||||
match self.report.take() {
|
||||
Some(report) => {
|
||||
frame[..11].copy_from_slice(&report);
|
||||
Ok(11)
|
||||
}
|
||||
None => Ok(0),
|
||||
}
|
||||
}
|
||||
fn set_chain_reset(&mut self, _chain: u8, _asserted: bool) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
|
||||
Ok(50_000)
|
||||
}
|
||||
fn set_psu_enabled(&mut self, enabled: bool) -> Result<(), Self::Error> {
|
||||
self.powered = enabled;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_job_dispatch_and_version_mask_invalidation_reach_the_miner() {
|
||||
let mut backend = FakeBackend {
|
||||
powered: false,
|
||||
sent: 0,
|
||||
report: Some([
|
||||
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
|
||||
]),
|
||||
};
|
||||
{
|
||||
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
|
||||
miner.start().unwrap();
|
||||
let mut pool = session();
|
||||
pool.control_with_miner(
|
||||
&mut miner,
|
||||
br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#,
|
||||
)
|
||||
.unwrap();
|
||||
for index in 0..4 {
|
||||
let work = pool
|
||||
.issue_to_miner(&mut miner, notify("job", index == 0).as_bytes())
|
||||
.unwrap();
|
||||
assert_eq!(work.work_id, (index as u8) << 3);
|
||||
}
|
||||
pool.control_with_miner(
|
||||
&mut miner,
|
||||
br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(miner.poll(), Err(MinerError::StaleReport));
|
||||
miner.stop().unwrap();
|
||||
assert_eq!(
|
||||
pool.issue_to_miner(&mut miner, notify("stopped", false).as_bytes())
|
||||
.err(),
|
||||
Some(DispatchError::Miner(MinerError::NotRunning))
|
||||
);
|
||||
}
|
||||
assert!(!backend.powered);
|
||||
assert_eq!(backend.sent, 4);
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::pow::VersionMask;
|
||||
use alkane_os::stratum_submit::{format_submission, Submission, SubmitError};
|
||||
|
||||
fn share() -> Submission<'static> {
|
||||
Submission {
|
||||
request_id: 7,
|
||||
worker: "miner.worker",
|
||||
job_id: "pool-job",
|
||||
extranonce2: &[0, 1, 0xfe, 0xff],
|
||||
ntime: 0x680f6a2e,
|
||||
nonce: 0xedadff38,
|
||||
base_version: 0x20000000,
|
||||
rolled_version: 0x20966000,
|
||||
version_mask: Some(VersionMask::new(0x1fffe000).unwrap()),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_bm1366_version_is_represented_under_negotiated_mask() {
|
||||
assert_eq!(
|
||||
format_submission(&share()).unwrap(),
|
||||
"{\"id\":7,\"method\":\"mining.submit\",\"params\":[\"miner.worker\",\"pool-job\",\"0001feff\",\"680f6a2e\",\"edadff38\",\"00966000\"]}\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unnegotiated_or_narrow_mask_rejects_rolled_share() {
|
||||
let mut value = share();
|
||||
value.version_mask = None;
|
||||
assert_eq!(
|
||||
format_submission(&value),
|
||||
Err(SubmitError::UnrepresentableVersion)
|
||||
);
|
||||
value.version_mask = Some(VersionMask::new(0x0060_0000).unwrap());
|
||||
assert_eq!(
|
||||
format_submission(&value),
|
||||
Err(SubmitError::UnrepresentableVersion)
|
||||
);
|
||||
value.rolled_version = value.base_version;
|
||||
value.version_mask = None;
|
||||
assert_eq!(
|
||||
format_submission(&value).unwrap(),
|
||||
"{\"id\":7,\"method\":\"mining.submit\",\"params\":[\"miner.worker\",\"pool-job\",\"0001feff\",\"680f6a2e\",\"edadff38\"]}\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pool_fields_are_escaped_and_bounded() {
|
||||
let mut value = share();
|
||||
value.worker = "worker\"\\\n";
|
||||
value.job_id = "job\t\u{0001}";
|
||||
let wire = format_submission(&value).unwrap();
|
||||
assert!(wire.contains("\"worker\\\"\\\\\\n\""));
|
||||
assert!(wire.contains("\"job\\t\\u0001\""));
|
||||
value.worker = "";
|
||||
assert_eq!(format_submission(&value), Err(SubmitError::EmptyWorker));
|
||||
value.worker = "worker";
|
||||
value.job_id = "";
|
||||
assert_eq!(format_submission(&value), Err(SubmitError::EmptyJobId));
|
||||
value.job_id = "job";
|
||||
value.extranonce2 = &[0; 33];
|
||||
assert_eq!(
|
||||
format_submission(&value),
|
||||
Err(SubmitError::ExtranonceTooLong)
|
||||
);
|
||||
}
|
||||
@@ -1,208 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::difficulty::PoolDifficulty;
|
||||
use alkane_os::stratum_v1::{
|
||||
parse_boolean_response, parse_configure_response, parse_configure_result,
|
||||
parse_control_notification, parse_notify, parse_subscription, PoolMessageError,
|
||||
PoolNotification, Subscription,
|
||||
};
|
||||
|
||||
const SUBSCRIBE: &str =
|
||||
r#"{"id":1,"result":[[["mining.notify","session"]],"01020304",4],"error":null}"#;
|
||||
fn notify() -> String {
|
||||
serde_json::json!({
|
||||
"id": null,
|
||||
"method": "mining.notify",
|
||||
"params": [
|
||||
"job-1",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
||||
"616263", "78797a",
|
||||
["202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"],
|
||||
"20000000", "1d00ffff", "66554433", true
|
||||
]
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subscribe_and_notify_construct_expected_asic_header() {
|
||||
let subscription = parse_subscription(SUBSCRIBE.as_bytes(), 1).unwrap();
|
||||
let line = notify();
|
||||
let job = parse_notify(line.as_bytes(), &subscription).unwrap();
|
||||
assert_eq!(job.id, "job-1");
|
||||
assert!(job.clean_jobs);
|
||||
let header = job
|
||||
.work
|
||||
.nonce_zero_header(&[5, 6, 7, 8], job.work.ntime)
|
||||
.unwrap();
|
||||
let hex: String = header.iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
assert_eq!(
|
||||
hex,
|
||||
concat!(
|
||||
"0000002003020100070605040b0a09080f0e0d0c13121110171615141b1a19181f1e1d1c",
|
||||
"9b9bc91f078af83ff63d00c6da09b5bc4dd26e2d8c0df8ab16b933a259a05881",
|
||||
"33445566ffff001d00000000"
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_pool_messages_fail_before_work_issuance() {
|
||||
assert!(matches!(
|
||||
parse_subscription(SUBSCRIBE.as_bytes(), 2),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
));
|
||||
let subscription = parse_subscription(SUBSCRIBE.as_bytes(), 1).unwrap();
|
||||
let malformed = notify().replace("66554433", "6655443g");
|
||||
assert!(matches!(
|
||||
parse_notify(malformed.as_bytes(), &subscription),
|
||||
Err(PoolMessageError::InvalidHex)
|
||||
));
|
||||
let wrong_method = notify().replace("mining.notify", "mining.submit");
|
||||
assert!(matches!(
|
||||
parse_notify(wrong_method.as_bytes(), &subscription),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
));
|
||||
let too_large = vec![b' '; 131_073];
|
||||
assert!(matches!(
|
||||
parse_notify(&too_large, &subscription),
|
||||
Err(PoolMessageError::TooLarge)
|
||||
));
|
||||
let too_large_coinbase = notify().replace("616263", &"aa".repeat(65_537));
|
||||
assert!(matches!(
|
||||
parse_notify(too_large_coinbase.as_bytes(), &subscription),
|
||||
Err(PoolMessageError::TooLarge)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn version_rolling_negotiation_and_immediate_mask_change() {
|
||||
let response = br#"{"id":3,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000"},"error":null}"#;
|
||||
let mask = parse_configure_response(response, 3).unwrap().unwrap();
|
||||
assert_eq!(mask.bits(), 0x1fff_e000);
|
||||
let update = br#"{"id":null,"method":"mining.set_version_mask","params":["00006000"]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(update, true, false).unwrap(),
|
||||
PoolNotification::SetVersionMask(alkane_os::pow::VersionMask::new(0x6000).unwrap())
|
||||
);
|
||||
assert_eq!(
|
||||
parse_control_notification(update, false, false),
|
||||
Err(PoolMessageError::Unnegotiated)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_configure_response(response, 4),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
);
|
||||
let declined = br#"{"id":3,"result":{"version-rolling":false},"error":null}"#;
|
||||
assert_eq!(parse_configure_response(declined, 3), Ok(None));
|
||||
let unsafe_mask = br#"{"id":3,"result":{"version-rolling":true,"version-rolling.mask":"ffffffff"},"error":null}"#;
|
||||
assert_eq!(
|
||||
parse_configure_response(unsafe_mask, 3),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
let absent_mask = br#"{"id":3,"result":{"version-rolling":true},"error":null}"#;
|
||||
assert_eq!(
|
||||
parse_configure_response(absent_mask, 3),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn both_bip310_extensions_and_boolean_responses_are_checked() {
|
||||
let accepted = br#"{"id":3,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000","subscribe-extranonce":true},"error":null}"#;
|
||||
let result = parse_configure_result(accepted, 3).unwrap();
|
||||
assert_eq!(result.version_mask.unwrap().bits(), 0x1fff_e000);
|
||||
assert!(result.subscribe_extranonce);
|
||||
let declined =
|
||||
br#"{"id":3,"result":{"version-rolling":false,"subscribe-extranonce":false},"error":null}"#;
|
||||
let result = parse_configure_result(declined, 3).unwrap();
|
||||
assert_eq!(result.version_mask, None);
|
||||
assert!(!result.subscribe_extranonce);
|
||||
let unavailable = br#"{"id":3,"result":{"version-rolling":"unavailable","subscribe-extranonce":"unsupported"},"error":null}"#;
|
||||
let result = parse_configure_result(unavailable, 3).unwrap();
|
||||
assert_eq!(result.version_mask, None);
|
||||
assert!(!result.subscribe_extranonce);
|
||||
assert_eq!(
|
||||
parse_configure_result(
|
||||
br#"{"id":3,"result":{"version-rolling":false},"error":null}"#,
|
||||
3
|
||||
),
|
||||
Ok(alkane_os::stratum_v1::ConfigureResult {
|
||||
version_mask: None,
|
||||
subscribe_extranonce: false,
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
parse_configure_result(
|
||||
br#"{"id":3,"result":{"version-rolling":false,"subscribe-extranonce":null},"error":null}"#,
|
||||
3
|
||||
),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":5,"result":true,"error":null}"#, 5),
|
||||
Ok(true)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":5,"result":false,"error":[23,"stale"]}"#, 5),
|
||||
Ok(false)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(
|
||||
br#"{"id":5,"result":null,"error":[21,"Job not found",null]}"#,
|
||||
5
|
||||
),
|
||||
Ok(false)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":5,"result":true,"error":[23,"stale"]}"#, 5),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_boolean_response(br#"{"id":6,"result":true,"error":null}"#, 5),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn difficulty_and_extranonce_notifications_validate_shape_and_negotiation() {
|
||||
let difficulty = br#"{"id":null,"method":"mining.set_difficulty","params":[2048.5]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(difficulty, false, false),
|
||||
Ok(PoolNotification::SetDifficulty(
|
||||
PoolDifficulty::from_json_number(&serde_json::from_str("2048.5").unwrap()).unwrap()
|
||||
))
|
||||
);
|
||||
let extranonce = br#"{"id":null,"method":"mining.set_extranonce","params":["aabbccdd",4]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(extranonce, false, true),
|
||||
Ok(PoolNotification::SetExtranonce(Subscription {
|
||||
extranonce1: vec![0xaa, 0xbb, 0xcc, 0xdd],
|
||||
extranonce2_size: 4,
|
||||
}))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_control_notification(extranonce, false, false),
|
||||
Err(PoolMessageError::Unnegotiated)
|
||||
);
|
||||
for value in ["0", "-1", "\"2\"", "null"] {
|
||||
let line =
|
||||
format!("{{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[{value}]}}");
|
||||
assert_eq!(
|
||||
parse_control_notification(line.as_bytes(), false, false),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
}
|
||||
let oversize = format!(
|
||||
"{{\"id\":null,\"method\":\"mining.set_extranonce\",\"params\":[\"{}\",1]}}",
|
||||
"ab".repeat(33)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_control_notification(oversize.as_bytes(), false, true),
|
||||
Err(PoolMessageError::InvalidField)
|
||||
);
|
||||
let response_id = br#"{"id":5,"method":"mining.set_difficulty","params":[2]}"#;
|
||||
assert_eq!(
|
||||
parse_control_notification(response_id, false, false),
|
||||
Err(PoolMessageError::WrongMessage)
|
||||
);
|
||||
}
|
||||
@@ -1,249 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::stratum_v1::MAX_POOL_LINE_BYTES;
|
||||
use alkane_os::stratum_wire::{
|
||||
authorize_request, configure_request, subscribe_request, HandshakeError, StratumWire, WireError,
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::io::{BufRead, BufReader, Read, Write};
|
||||
use std::net::TcpListener;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
#[test]
|
||||
fn request_frames_escape_pool_credentials_and_advertise_supported_bits() {
|
||||
let configure: Value = serde_json::from_str(&configure_request(1)).unwrap();
|
||||
assert_eq!(configure["method"], "mining.configure");
|
||||
assert_eq!(configure["params"][1]["version-rolling.mask"], "1fffe000");
|
||||
assert_eq!(configure["params"][0][1], "subscribe-extranonce");
|
||||
let subscribe: Value =
|
||||
serde_json::from_str(&subscribe_request(2, "alkane-os/0.1").unwrap()).unwrap();
|
||||
assert_eq!(subscribe["params"][0], "alkane-os/0.1");
|
||||
let authorized = authorize_request(3, "worker\"name", "secret\nvalue").unwrap();
|
||||
assert_eq!(authorized.as_bytes().last(), Some(&b'\n'));
|
||||
let authorize: Value = serde_json::from_str(&authorized).unwrap();
|
||||
assert_eq!(authorize["params"][0], "worker\"name");
|
||||
assert_eq!(authorize["params"][1], "secret\nvalue");
|
||||
assert!(matches!(
|
||||
subscribe_request(2, ""),
|
||||
Err(WireError::InvalidRequest)
|
||||
));
|
||||
assert!(matches!(
|
||||
authorize_request(3, "", "pass"),
|
||||
Err(WireError::InvalidRequest)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loopback_frames_preserve_pipelined_lines_and_reject_invalid_sends() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.write_all(b"{\"id\":1}\n{\"id\":2}\n").unwrap();
|
||||
let mut request = [0_u8; 3];
|
||||
stream.read_exact(&mut request).unwrap();
|
||||
assert_eq!(&request, b"{}\n");
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert_eq!(wire.read_line().unwrap(), b"{\"id\":1}\n");
|
||||
assert_eq!(wire.read_line().unwrap(), b"{\"id\":2}\n");
|
||||
assert!(matches!(
|
||||
wire.send_line(b"bad\nline\n"),
|
||||
Err(WireError::InvalidRequest)
|
||||
));
|
||||
wire.send_line(b"{}\n").unwrap();
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn oversized_pool_line_poison_closes_the_connection() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut line = vec![b'a'; MAX_POOL_LINE_BYTES];
|
||||
line.push(b'\n');
|
||||
let _ = stream.write_all(&line);
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert!(matches!(wire.read_line(), Err(WireError::LineTooLong)));
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trickled_pool_line_hits_the_absolute_deadline() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
for byte in b"{123}\n" {
|
||||
if stream.write_all(&[*byte]).is_err() {
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(60));
|
||||
}
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_millis(130)).unwrap();
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Timeout)));
|
||||
assert!(matches!(wire.send_line(b"{}\n"), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn buffered_complete_lines_do_not_extend_a_partial_line_deadline() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.write_all(b"first\nsecond\nunfinished").unwrap();
|
||||
thread::sleep(Duration::from_secs(3));
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
let first = loop {
|
||||
if let Some(line) = wire.try_read_line().unwrap() {
|
||||
break line;
|
||||
}
|
||||
};
|
||||
assert_eq!(first, b"first\n");
|
||||
thread::sleep(Duration::from_millis(1300));
|
||||
assert_eq!(wire.try_read_line().unwrap(), Some(b"second\n".to_vec()));
|
||||
thread::sleep(Duration::from_millis(800));
|
||||
assert!(matches!(wire.try_read_line(), Err(WireError::Timeout)));
|
||||
assert!(wire.is_closed());
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_timeout_keeps_connection_available_for_later_messages() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let (release, wait) = std::sync::mpsc::channel();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
wait.recv().unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_millis(130)).unwrap();
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Timeout)));
|
||||
release.send(()).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_slice::<Value>(&wire.read_line().unwrap()).unwrap()["method"],
|
||||
"mining.set_difficulty"
|
||||
);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handshake_preserves_early_notifications_and_authorizes_worker() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut input = BufReader::new(stream.try_clone().unwrap());
|
||||
let mut line = String::new();
|
||||
input.read_line(&mut line).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
||||
"mining.configure"
|
||||
);
|
||||
stream.write_all(b"{\"id\":1,\"result\":{\"version-rolling\":true,\"version-rolling.mask\":\"1fffe000\",\"subscribe-extranonce\":true},\"error\":null}\n").unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
||||
"mining.subscribe"
|
||||
);
|
||||
stream.write_all(b"{\"id\":null,\"method\":\"mining.set_difficulty\",\"params\":[1]}\n{\"id\":2,\"result\":[[],\"01020304\",4],\"error\":null}\n").unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&line).unwrap()["method"],
|
||||
"mining.authorize"
|
||||
);
|
||||
stream
|
||||
.write_all(b"{\"id\":3,\"result\":true,\"error\":null}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
let result = wire
|
||||
.handshake(
|
||||
"alkane-os/0.1",
|
||||
"miner.worker",
|
||||
"password",
|
||||
Duration::from_secs(2),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(result.subscription.extranonce1, [1, 2, 3, 4]);
|
||||
assert_eq!(result.subscription.extranonce2_size, 4);
|
||||
assert!(result.configure.subscribe_extranonce);
|
||||
assert_eq!(result.configure.version_mask.unwrap().bits(), 0x1fff_e000);
|
||||
assert_eq!(result.early_notifications.len(), 1);
|
||||
assert_eq!(
|
||||
serde_json::from_slice::<Value>(&result.early_notifications[0]).unwrap()["method"],
|
||||
"mining.set_difficulty"
|
||||
);
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_worker_closes_the_handshake_connection() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut input = BufReader::new(stream.try_clone().unwrap());
|
||||
let mut line = String::new();
|
||||
input.read_line(&mut line).unwrap();
|
||||
stream.write_all(b"{\"id\":1,\"result\":{\"version-rolling\":false,\"subscribe-extranonce\":false},\"error\":null}\n").unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":2,\"result\":[[],\"01020304\",4],\"error\":null}\n")
|
||||
.unwrap();
|
||||
line.clear();
|
||||
input.read_line(&mut line).unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":3,\"result\":false,\"error\":[24,\"unauthorized\"]}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert!(matches!(
|
||||
wire.handshake("alkane-os/0.1", "bad", "password", Duration::from_secs(2)),
|
||||
Err(HandshakeError::Rejected)
|
||||
));
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_handshake_reply_id_is_rejected_and_connection_closed() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
let mut line = String::new();
|
||||
BufReader::new(stream.try_clone().unwrap())
|
||||
.read_line(&mut line)
|
||||
.unwrap();
|
||||
stream
|
||||
.write_all(b"{\"id\":9,\"result\":true,\"error\":null}\n")
|
||||
.unwrap();
|
||||
});
|
||||
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
|
||||
assert!(matches!(
|
||||
wire.handshake(
|
||||
"alkane-os/0.1",
|
||||
"miner.worker",
|
||||
"password",
|
||||
Duration::from_secs(2)
|
||||
),
|
||||
Err(HandshakeError::Pool(
|
||||
alkane_os::stratum_v1::PoolMessageError::WrongMessage
|
||||
))
|
||||
));
|
||||
assert!(matches!(wire.read_line(), Err(WireError::Closed)));
|
||||
server.join().unwrap();
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::bm1366::encode_work;
|
||||
use alkane_os::stratum_work::{JobError, Sha256Job};
|
||||
|
||||
fn fixture() -> Sha256Job {
|
||||
let mut prevhash_stratum = [0_u8; 32];
|
||||
let mut branch = [0_u8; 32];
|
||||
for (index, byte) in prevhash_stratum.iter_mut().enumerate() {
|
||||
*byte = index as u8;
|
||||
}
|
||||
for (index, byte) in branch.iter_mut().enumerate() {
|
||||
*byte = (index + 32) as u8;
|
||||
}
|
||||
Sha256Job {
|
||||
prevhash_stratum,
|
||||
coinb1: b"abc".to_vec(),
|
||||
coinb2: b"xyz".to_vec(),
|
||||
merkle_branches: vec![branch],
|
||||
version: 0x2000_0000,
|
||||
nbits: 0x1d00_ffff,
|
||||
ntime: 0x6655_4433,
|
||||
extranonce1: vec![1, 2, 3, 4],
|
||||
extranonce2_size: 4,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_cross_checked_header_and_asic_work() {
|
||||
let job = fixture();
|
||||
let header = job.nonce_zero_header(&[5, 6, 7, 8], job.ntime).unwrap();
|
||||
let expected = concat!(
|
||||
"0000002003020100070605040b0a09080f0e0d0c13121110171615141b1a19181f1e1d1c",
|
||||
"9b9bc91f078af83ff63d00c6da09b5bc4dd26e2d8c0df8ab16b933a259a05881",
|
||||
"33445566ffff001d00000000"
|
||||
);
|
||||
let actual: String = header.iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
assert_eq!(actual, expected);
|
||||
let frame = encode_work(&header, 0x18).unwrap();
|
||||
assert_eq!(&frame[10..14], &header[72..76]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_pool_work_before_hashing() {
|
||||
let mut job = fixture();
|
||||
assert_eq!(
|
||||
job.nonce_zero_header(&[5, 6], job.ntime),
|
||||
Err(JobError::ExtranonceLength)
|
||||
);
|
||||
job.extranonce2_size = 33;
|
||||
assert_eq!(job.validate(), Err(JobError::InvalidExtranonceSize));
|
||||
job.extranonce2_size = 4;
|
||||
job.coinb1.resize(65_536, 0);
|
||||
assert_eq!(job.validate(), Err(JobError::CoinbaseTooLarge));
|
||||
job.coinb1 = b"abc".to_vec();
|
||||
job.merkle_branches.resize(65, [0; 32]);
|
||||
assert_eq!(job.validate(), Err(JobError::TooManyMerkleBranches));
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"e0165305f3b22a9ab4217a121f85379aa56c2675caa7afedc0a7468fc187600b",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"89c4f60223daf03217ea7c1e8879135b11d2554bd1e57dd9eff5c02f1adc7909","Cargo.lock":"1cd64090b8e883963bb08d91e6968cc1e83ffdba4f4b2f47651ce9d351a8a947","Cargo.toml":"894c215e4e7e973b556b0e9627bf9b6a719a043fac9b5af9838660816392a09f","Cargo.toml.orig":"44ca1ae5d9b48743305b57f3367051289512037e7836b8b3693b68d48dec0483","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"1305bd79675db0194915d9bc91bd0b3cf9487bc1126e05bf46b48ab43edce44b","benches/bench.rs":"29a0bdb973848007d681e571c57487e21e1bfb7aed5980c2190dba354498b154","src/lib.rs":"e962338e1886873aa7c3399ec89aa5378ccbfed712b9690f043628079390a34f","src/u128_ext.rs":"498cc94f13805e551248fd82f47cc318f51d953a5002a9f8698858cd12fbae3c","tests/test.rs":"b22f8a8ed89edcbb4140b74f5edd7f2adf3cb0e363990dd6010cd6ebe0dc36b7"},"package":"8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"git": {
|
||||
"sha1": "af77385d0daf4d0e949e81f2588be2e44f69f086"
|
||||
},
|
||||
"path_in_vcs": ""
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
github: dtolnay
|
||||
@@ -1,126 +0,0 @@
|
||||
name: CI
|
||||
|
||||
on:
|
||||
push:
|
||||
pull_request:
|
||||
workflow_dispatch:
|
||||
schedule: [cron: "40 1 * * *"]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
env:
|
||||
RUSTFLAGS: -Dwarnings
|
||||
|
||||
jobs:
|
||||
pre_ci:
|
||||
uses: dtolnay/.github/.github/workflows/pre_ci.yml@master
|
||||
|
||||
test:
|
||||
name: Rust ${{matrix.rust}}
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
rust: [nightly, beta, stable, 1.86.0]
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@master
|
||||
with:
|
||||
toolchain: ${{matrix.rust}}
|
||||
- name: Enable type layout randomization
|
||||
run: echo RUSTFLAGS=${RUSTFLAGS}\ -Zrandomize-layout >> $GITHUB_ENV
|
||||
if: matrix.rust == 'nightly'
|
||||
- run: cargo build
|
||||
- run: cargo test
|
||||
- run: cargo test --release
|
||||
- run: cargo build --no-default-features
|
||||
- run: cargo test --tests --no-default-features
|
||||
- run: cargo test --tests --no-default-features --release
|
||||
- run: cargo build --tests --features no-panic --release
|
||||
if: matrix.rust == 'nightly'
|
||||
- run: cargo bench --no-run
|
||||
if: matrix.rust == 'nightly'
|
||||
- uses: actions/upload-artifact@v6
|
||||
if: matrix.rust == 'nightly' && always()
|
||||
with:
|
||||
name: Cargo.lock
|
||||
path: Cargo.lock
|
||||
continue-on-error: true
|
||||
|
||||
msrv:
|
||||
name: Rust 1.68.0
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@1.68
|
||||
- run: cargo build
|
||||
- run: cargo build --no-default-features
|
||||
|
||||
doc:
|
||||
name: Documentation
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
env:
|
||||
RUSTDOCFLAGS: -Dwarnings
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@nightly
|
||||
- uses: dtolnay/install@cargo-docs-rs
|
||||
- run: cargo docs-rs
|
||||
|
||||
miri:
|
||||
name: Miri
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@miri
|
||||
- run: cargo miri setup
|
||||
- run: cargo miri test
|
||||
env:
|
||||
MIRIFLAGS: -Zmiri-strict-provenance
|
||||
|
||||
clippy:
|
||||
name: Clippy
|
||||
runs-on: ubuntu-latest
|
||||
if: github.event_name != 'pull_request'
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@clippy
|
||||
- run: cargo clippy --tests --benches -- -Dclippy::all -Dclippy::pedantic
|
||||
|
||||
fuzz:
|
||||
name: Fuzz
|
||||
needs: pre_ci
|
||||
if: needs.pre_ci.outputs.continue
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@nightly
|
||||
- uses: dtolnay/install@cargo-fuzz
|
||||
- run: cargo fuzz check
|
||||
|
||||
outdated:
|
||||
name: Outdated
|
||||
runs-on: ubuntu-latest
|
||||
if: github.event_name != 'pull_request'
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- uses: dtolnay/install@cargo-outdated
|
||||
- run: cargo outdated --workspace --exit-code 1
|
||||
- run: cargo outdated --manifest-path fuzz/Cargo.toml --exit-code 1
|
||||
@@ -1,460 +0,0 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "alloca"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
|
||||
dependencies = [
|
||||
"cc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anes"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
|
||||
|
||||
[[package]]
|
||||
name = "anstyle"
|
||||
version = "1.0.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
|
||||
|
||||
[[package]]
|
||||
name = "cast"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
|
||||
|
||||
[[package]]
|
||||
name = "cc"
|
||||
version = "1.2.57"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
|
||||
dependencies = [
|
||||
"find-msvc-tools",
|
||||
"shlex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"ciborium-ll",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-io"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-ll"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"half",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
|
||||
dependencies = [
|
||||
"clap_builder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_builder"
|
||||
version = "4.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
|
||||
dependencies = [
|
||||
"anstyle",
|
||||
"clap_lex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_lex"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
|
||||
|
||||
[[package]]
|
||||
name = "criterion"
|
||||
version = "0.8.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
|
||||
dependencies = [
|
||||
"alloca",
|
||||
"anes",
|
||||
"cast",
|
||||
"ciborium",
|
||||
"clap",
|
||||
"criterion-plot",
|
||||
"itertools",
|
||||
"num-traits",
|
||||
"oorandom",
|
||||
"page_size",
|
||||
"regex",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tinytemplate",
|
||||
"walkdir",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion-plot"
|
||||
version = "0.8.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
|
||||
dependencies = [
|
||||
"cast",
|
||||
"itertools",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crunchy"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
|
||||
|
||||
[[package]]
|
||||
name = "find-msvc-tools"
|
||||
version = "0.1.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "2.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crunchy",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"no-panic",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.183"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
|
||||
|
||||
[[package]]
|
||||
name = "no-panic"
|
||||
version = "0.1.36"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f967505aabc8af5752d098c34146544a43684817cdba8f9725b292530cabbf53"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "oorandom"
|
||||
version = "11.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
|
||||
|
||||
[[package]]
|
||||
name = "page_size"
|
||||
version = "0.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.106"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.45"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.12.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-automata"
|
||||
version = "0.4.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.8.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
|
||||
|
||||
[[package]]
|
||||
name = "same-file"
|
||||
version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
|
||||
dependencies = [
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.228"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.228"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.228"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.149"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
|
||||
dependencies = [
|
||||
"itoa 1.0.17",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shlex"
|
||||
version = "1.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.117"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinytemplate"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
|
||||
|
||||
[[package]]
|
||||
name = "walkdir"
|
||||
version = "2.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
|
||||
dependencies = [
|
||||
"same-file",
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi"
|
||||
version = "0.3.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
|
||||
dependencies = [
|
||||
"winapi-i686-pc-windows-gnu",
|
||||
"winapi-x86_64-pc-windows-gnu",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-i686-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-x86_64-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.61.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
|
||||