The short version, for everyone: In five days, eight Kisumu shops started taking bitcoin through kTown, a QR code that turns a Lightning payment into M-Pesa shillings. That closed the pilot. The next chapter is learning to contribute to Bitcoin's open-source code. To keep myself honest, a program checks every day of that plan against my public GitHub activity, misses included. This post covers both: the pilot, and how the tracker that grades me actually works.
I set out to bring one Kisumu merchant onto bitcoin every week. Between 8 and 12 November 2026, eight said yes.
That was the kTown pilot. This post closes it, thanks everyone who made it possible, and opens the next chapter: learning Bitcoin open source in public, with a tracker that proves every day from code.
altradits
/
altradits
YeBente is a free Bitcoin Lightning wallet for everyday people. Its AI agency now thinks with Meta Muse.
Altradits
The code behind altradits.com: free Bitcoin tools and learning for people new to Bitcoin, including Ye₿ente, a custodial Bitcoin Lightning wallet for everyday amounts, and the admin dashboard that runs the Lightning node behind it.
What lives here
-
server.mjs,api/: the website and its API (Node.js, no framework). -
lib/: shared code: wallets, Lightning, receipts, mail, security. -
yebente/: the Ye₿ente wallet app (React + Vite). The shipped build inyebente/appis committed with the source that produced it. -
assets/admin.js,admin.html: the node operator dashboard. -
test/: the test suite, including the build-stage security guard. -
docs/: manuals and guides (setup, Lightning, review process). -
deploy/,.github/: signed-merge tooling, deploy and CI.
Quick start
Requirements: Node.js 20 or newer (CI runs 24).
npm ci --ignore-scripts
cp .env.example .env
npm run dev
Open http://localhost:3000 (admin: /admin, token dev on a local machine only)…
Contents
- The pilot: 8 shops in 5 days
- What the pilot taught me
- The next chapter: a 234-day Builder Path
- Why a tracker that can't be ticked by hand
- Evidence 1: the learning log needs a file and a commit
- Evidence 2: reviews, dated by the review, not the PR
- Which day is it? Time zones decide verdicts
- Stronger work satisfies a weaker day
- Streaks, rest days, and late work
- Public data only, and links that can't be poisoned
- Caching against GitHub's rate limits
- The tests
- Where I actually am
- How you can help
The pilot: 8 shops in 5 days
kTown is a QR code that lets any shop take bitcoin. A customer pays in sats from any Lightning wallet and the shop receives shillings on M-Pesa. Nothing changes at the till.
| # | Shop | Type |
|---|---|---|
| 01 | Mama Jobu Hotel | physical |
| 02 | Kisumu Explorers | online, run by Zone01 Kisumu students |
| 03 | Austine Kicks | online, run by a Zone01 Kisumu student |
| 04 | Lake Basin Mall Hotel | physical |
| 05 | Mall Café | physical |
| 06 | Debs Beauty Hub | physical |
| 07 | Judphil Cyber | physical |
| 08 | Edu Shop | physical |
The six physical shops each got a QR poster: designed, printed, hot-press laminated so it survives rain, flour and busy hands, and carried across town to the counter. The two online shops use digital QR codes for now, because the first phase needed physical shops.
Each poster cost me about $1. Merchants paid nothing. I had no sponsor and made no paid posts. At the physical shops I paid first with my own sats, so every owner saw the shillings arrive.
Thank you to every one of these shops. You took a chance on something new, and you move Kisumu's economy forward every day.
The earlier posts go into the engineering of each piece:
What the pilot taught me
Shops are ready. Every owner was amazed that it works and asked why more people don't use it.
The missing half is the spender. Kisumu needs people who earn bitcoin, and local builders who make tools for local businesses. Posters can't fix that. Skills can.
The next chapter: a 234-day Builder Path
I'm now concentrating on open-source skills: learning to review the code that powers bitcoin, alongside my apprenticeship, so I can contribute to open source full time.
My goal is a Btrust Starter Grant to work full time on LND, the Lightning Network Daemon. The listing is clear about the bar: at least five merged code pull requests on one project (not docs, not good-first-issues), careful reviews of other people's work, help in the community, a six-month plan, and two people on the project who vouch for me.
So I wrote a Builder Path: one verified deliverable a day, from 9 November 2026 to 30 June 2027, in four phases:
| Phase | Dates | Exit criterion |
|---|---|---|
| 0. Foundations | 9 Nov – 31 Dec | Build bitcoind and lnd from source, both running on regtest; finish the Go tour; dated log complete |
| 1. Reading and reviewing | 1 Jan – 25 Feb | At least 6 posted reviews that say exactly what was run, on tracked projects |
| 2. Issues and small PRs | 26 Feb – 22 Apr | At least 2 issues and 2 pull requests opened on tracked projects |
| 3. A body of work | 23 Apr – 30 Jun | Merged PRs toward the bar of five, a written proposal, the application |
Every day has a type, and the type says what proves it:
| Type | Proven by |
|---|---|
log |
days/YYYY-MM-DD.md in my public builder-log repo, plus a commit by me on that day |
review |
A review or comment I posted on someone else's pull request in a tracked repo |
issue |
An issue I opened in a tracked repo |
pr |
A pull request I opened in a tracked repo |
merged |
A pull request of mine merged in a tracked repo |
rest |
Sundays. No proof needed |
My week: Monday to Friday, the day's task. Saturday: reflect, do one lab drill, and teach one merchant, so kTown keeps growing. Sunday: rest.
Why a tracker that can't be ticked by hand
A checklist I tick myself proves only that I can tick boxes. Grant reviewers, mentors and I all need the same thing: evidence anyone can click. So the rule in data/builder-path.js is blunt:
// The Builder Path: a dated daily program from beginner to a Btrust-ready
// Bitcoin open-source contributor. One deliverable a day, each proven only by
// Stanley's own public GitHub activity. Code decides every verdict. Nothing
// here is ticked by hand.
lib/tracker.js (316 lines) reads GitHub's public API and computes every verdict. There is even a test that the API takes no input that could change one: nothing is tickable by hand: the API takes no input that changes a verdict.
It starts with four GitHub searches, run in parallel, that between them cover every project I don't own:
const mine = `-user:${u}`; // never his own repositories
const [prs0, issues0, reviewed0, commented0, events] = await Promise.all([
search(`author:${u} type:pr ${mine}`),
search(`author:${u} type:issue ${mine}`),
search(`reviewed-by:${u} type:pr -author:${u} ${mine}`),
search(`commenter:${u} -author:${u} ${mine}`),
eventsAll(u),
]);
-user:altradits matters: my own repositories don't count. Pushing to my own website a hundred times proves nothing about contributing to someone else's project.
Evidence 1: the learning log needs a file and a commit
In the foundations phase most days are log days: write days/2026-11-19.md in the public altradits/builder-log repo saying what I did and what I learned. The obvious check is "does the file exist?" But a file can be created months later with any name. So a log day needs two independent facts:
// The learning repo: which dated log files exist, and which Nairobi days he
// committed on. Both must hold for a log day: the file alone, or commits
// alone, prove nothing.
async function learningEvidence(u) {
const meta = await get(`/repos/${LEARNING_REPO}`).catch(() => null);
if (!meta) return { repoState: "missing", logFiles: new Set(), logCommits: new Set() };
if (!(meta.private === false && meta.visibility !== "private")) return { repoState: "private", ... };
...
const tree = await get(`/repos/${LEARNING_REPO}/git/trees/HEAD?recursive=1`).catch(() => null);
if (tree && !tree.truncated && Array.isArray(tree.tree)) {
for (const e of tree.tree) {
const m = LOG_FILE.exec(e.path || ""); // ^days/(\d{4}-\d{2}-\d{2})\.md$
if (m && e.type === "blob") logFiles.add(m[1]);
}
}
for (let page = 1; page <= 3; page++) {
const cs = await get(`/repos/${LEARNING_REPO}/commits?author=${u}&per_page=100&page=${page}&since=${START}T00:00:00Z`).catch(() => []);
...
for (const c of cs) {
if ((c.author?.login || "").toLowerCase() !== u.toLowerCase()) continue; // linked to his account
const d = nairobiDay(c.commit?.author?.date);
if (d) logCommits.add(d);
}
}
return { repoState: "ready", logFiles, logCommits };
}
Two subtleties:
-
The commit must be linked to my GitHub account (
c.author.login), not just carry my name in the commit metadata, which anyone can type. -
A private repo fails closed. If
builder-logwere made private, every log day would fail, and the tracker would reveal nothing about the repo beyond that state. The page is public, so its evidence must be public too.
Honest limitation: Git author dates are set by the committer's machine, so a determined cheat could backdate a commit. The tracker can't prevent that; it relies on the history being public, where backdating is visible to anyone who looks at push times. Upstream evidence (reviews, issues, PRs) is dated by GitHub's servers and can't be backdated.
Evidence 2: reviews, dated by the review, not the PR
Reviewing is the scarce skill the grant asks for, so review days are checked most carefully. GitHub's search tells you that I reviewed a pull request, but dates the result by the pull request's creation, which could be weeks before my review. So the tracker fetches each pull request's own reviews and comments to get exact dates:
// Exact review dates, from each pull request's own reviews and comments. The
// search index dates the pull request, not the review, so it can't place a
// review on a day. Only his reviews and comments on someone else's pull
// request in a tracked repository count. Comments on issues don't: the review
// check asks for pull request review, the scarce skill.
for (const x of need.values()) {
const revs = await get(`/repos/${x.repo}/pulls/${x.number}/reviews?per_page=100`).catch(() => []);
for (const r of revs) {
if ((r.user?.login || "").toLowerCase() !== u.toLowerCase()) continue;
push(r.submitted_at, x, ...);
}
const cs = await get(`/repos/${x.repo}/issues/${x.number}/comments?per_page=100`).catch(() => []);
...
}
A comment on an issue never satisfies a review day, and nor does anything in a repo outside the tracked list. Saying "+1" on a random issue is not code review.
Which day is it? Time zones decide verdicts
I live in Kisumu, UTC+3. GitHub timestamps are UTC. A review I post at 1:30 a.m. on Tuesday in Kisumu is 22:30 on Monday in UTC. If the tracker used UTC dates, late-night work would count for the wrong day, and a day could be marked missed for work done on it.
So every timestamp is converted to a calendar date in Nairobi time before anything else happens:
// A timestamp's calendar day in Nairobi, where Stanley lives and commits.
const NAIROBI = new Intl.DateTimeFormat("en-CA", { timeZone: "Africa/Nairobi",
year: "numeric", month: "2-digit", day: "2-digit" });
export const nairobiDay = (iso) => {
const d = new Date(iso);
if (Number.isNaN(d.getTime())) return null;
return NAIROBI.format(d);
};
The en-CA locale is a small trick: Canadian English formats dates as YYYY-MM-DD, which sorts correctly as a string, so dates can be compared with < and > without parsing. There is a test for the boundary: the Nairobi boundary: 23:59 EAT counts for that day.
Stronger work satisfies a weaker day
Evidence types are ranked:
const RANK = { log: 0, review: 1, issue: 2, pr: 3, merged: 4 };
and a day is proven by evidence of its type or stronger:
const prove = (date, type) => {
const day = ev.get(date);
if (!day) return null;
const hit = Object.keys(RANK)
.filter((t) => RANK[t] >= RANK[type] && day[t]?.length)
.sort((a, b) => RANK[b] - RANK[a])[0];
return hit ? { type: hit, proof: day[hit][0] } : null;
};
If the plan says "write today's log" and instead I spent the day getting a pull request merged in LND, that day is done, and the calendar shows it was proven by a merge. The opposite never works: a log entry can't satisfy a review day. The comment in the code states the principle: real upstream work is never punished.
Streaks, rest days, and late work
The streak walks backwards from today (slightly simplified):
for (let d = last; d >= START; d = previousDay(d)) {
const v = verdict.get(d);
if (v === "done") { streak++; continue; }
if (v === "rest" || d === today) continue; // rest keeps the streak; today never ends it
break;
}
Three rules are encoded there:
- Rest days keep a streak alive without extending it. Sundays are planned rest; resting shouldn't cost the streak, but it shouldn't pad it either.
- Today never ends a streak while it is still open. The day isn't over.
-
Late work never reopens a missed day. Evidence counts for the Nairobi date it happened on, never the date it was due. Doing Tuesday's task on Thursday proves Thursday, if Thursday's type allows it, and Tuesday stays missed. The test:
late work counts for the day it happened on, never the day it was due.
Public data only, and links that can't be poisoned
The tracker page is public, so two safety rules apply to everything it shows:
Only public repositories. A GITHUB_TOKEN might be able to see private repos; anything that isn't public is filtered out, so every block on the page opens for anyone who clicks it:
const isPublic = new Map(await Promise.all(repos.map(async (r) =>
[r, await get(`/repos/${r}`).then((x) => x.private === false && x.visibility !== "private", () => false)])));
Only GitHub's own links. Every proof becomes an <a href> on the page. If the API reply were ever compromised or unexpected, a javascript: URL could become a stored XSS. So links are filtered at the source:
// Links leave the page as <a href>: only GitHub's own addresses, so a
// compromised or unexpected API reply can't plant a javascript: link.
out.push(...items.filter((i) => typeof i.html_url === "string" && /^https:\/\/github\.com\//.test(i.html_url)) ...
Caching against GitHub's rate limits
One computation makes dozens of GitHub calls (searches, repo checks, per-PR reviews). Unauthenticated, GitHub allows 60 requests an hour, so the result is cached:
- Refreshed at most every 30 minutes on demand, and each morning before my daily report.
- Concurrent views share one refresh instead of each starting its own.
- The last good result is kept if GitHub can't be reached, so an outage shows slightly stale truth, not an empty page.
-
The cache is versioned (
VERSION = 6): when the result's shape changes, a copy saved by older code is refreshed at once instead of lasting out its TTL. Each bump is documented in a comment, a tiny changelog of the data model.
An optional read-only token with no scopes raises the limit; the code works without it.
The tests
GitHub is replaced by a fake fetcher in tests (setGitHubFetcher), so every rule above can be exercised with exact timestamps:
log days: the dated file plus a commit on that Nairobi day, neither alone
the Nairobi boundary: 23:59 EAT counts for that day
upstream days: review, issue, pr and merged each prove their day
real upstream work is never punished: stronger evidence satisfies a weaker day
issue comments and untracked repos never satisfy a review day
rest days need no proof; the streak skips them and today never ends it
a merged pull request on the focus project moves the Btrust bar
late work counts for the day it happened on, never the day it was due
a private or missing learning repo fails log days and leaks nothing
proof links stay on GitHub's own addresses, even if the API carries others
nothing is tickable by hand: the API takes no input that changes a verdict
the curriculum covers every day to the application window with one deliverable each
cached for 30 minutes with one shared refresh, and the last result is kept if GitHub can't be reached
Run them:
git clone https://github.com/altradits/altradits
cd altradits && npm install
node --test test/builder-path.test.mjs test/builder-reminder.test.mjs test/tracker.test.mjs
ℹ tests 23
ℹ pass 23
ℹ fail 0
Where I actually am
The tracker's public API says it plainly. As I write this, on 19 November 2026:
day 11 of 234 · phase 0, Foundations
done 4 · missed 5 · rest 1 · streak 0
merged on LND toward the Btrust bar: 0 of 5
The first four days are proven. Then five missed days. The tracker doesn't care why, and that is the point: a public, code-checked record is only worth anything if it shows the misses too. Today's deliverable is to set up SSH keys for GitHub and log it.
Separately from the Builder Path, I've already shipped 24 merged pull requests to Minmo's payment-channels, including African payment corridor schemas.
Where I'm learning
- LND (lightningnetwork/lnd), my focus
- Bitcoin Core (bitcoin/bitcoin), through the PR Review Club
- Bitcoin Dev Kit (bitcoindevkit/bdk)
- BOLTs (lightning/bolts)
- Bitcoin Optech and the Bitcoin Design Guide
My lab
A Mac running Bitcoin Core and LND built from source, regtest and signet nodes to break things safely, and a small Lightning node on mainnet. Regtest first, signet next, mainnet last and small.
The honest part
The hard thing right now is understanding a large codebase, reading pull requests and testing them properly. My review routine is simple: build the change, run its tests, try to break it on regtest, read what others already said, then post exactly what I ran and what I saw. Ask, don't guess.
It's slow at first. We all start somewhere.
How you can help
I'm open to any open-source project as I build these skills.
- Collaborate: building on bitcoin or Lightning? Let's build together.
- Mentor or review: point me to good first issues, or review my work.
- Invite me in: if you maintain a repo with good first issues, docs to test, or pull requests that need careful reviewers, I'll show up, test, and report honestly.
- Sponsor: support my open-source time and the next kTown shops in sats: https://altradits.com/donate.html
- Have a shop? Register free: https://altradits.com/ktown/
Follow all 234 days, misses included: https://altradits.com/tracker/ · GitHub: https://github.com/altradits
Not sponsored. No paid posts.
Watch and follow
- YouTube Short: https://youtube.com/shorts/Fb2N7TFfd3c
- X thread (pinned): https://x.com/altradits/status/2120895675642650858
- LinkedIn: https://www.linkedin.com/posts/stanmobitech_bitcoin-opensource-lightning-ugcPost-7526662109925928961-O1fp/
- Facebook: https://www.facebook.com/reel/1163783359433214
- Instagram Reel: https://www.instagram.com/reel/DfpWKJzBJca/
- TikTok: https://www.tiktok.com/@altradits/video/7707302878850960654
Top comments (1)
Am I correct in assuming the mechanism means an instant off ramp for the merchant? Did you have any conversation about whether they can consider holding bitcoin?