Build Log #023: Offline mint initialization evidence
Spotting a mint initialization instruction is not the same as knowing who created the token, and it's nowhere near proving the token is safe. C9 is built around keeping those apart.
The engine now takes an explicitly selected Solana transaction that's already stored and checks it, offline, for the classic SPL Token InitializeMint2 instruction, in both Legacy and v0 transaction formats.
The result is bound to that exact stored observation: source, network and signature. Before anything counts, it checks the instruction structure, the program ID and the required accounts. Then it decodes the initial decimals, the mint authority, and the freeze authority if one was set. Anything ambiguous, malformed or unsupported gets rejected the same way every time, and the source and processing versions stay attached to the result.
It runs only on evidence I already have. No new RPC request, no database writes, and no risk score made up on top.
The limits matter as much as the checks. A positive result means the selected RPC observation passed these checks. It does not prove the transaction is part of the canonical chain, it says nothing about who holds the authorities today, and it doesn't identify the creator. Creator identity stays unknown.
So this isn't a rug detector on its own. It's a verified building block that later threat analysis can rely on.
For traders, the point is that "mint authority was X at launch" and "mint authority is X now" are different claims, and the engine won't blur them.
Next is C10: Pump.fun create_v2 evidence.
1
118
Build Log #022: Controlled continuation and recovery
Getting the first page of a token's Solana transactions is the easy part. The harder question is what the engine is allowed to do before it touches page two.
#019 to #021 covered durable workflow roots, one-shot acquisition, and recovery after the process dies. This is the last piece of C8.
First, the engine can now reopen an explicitly selected discovery run and its first attempt for inspection, even before anything has been interpreted. It only reads. It doesn't write to the database, doesn't pick the "latest" run on its own, and doesn't authorize any new HTTP requests.
Second, continuation. When a stored policy decision says CONTINUE, the engine validates the selected history and prepares exactly one next step. It won't quietly switch to a different interpretation, it won't pull every remaining page in one go, and reopening an old workflow never grants fresh permission to send requests.
I kept discovery, interpretation, policy decisions, authorization, acquisition and evidence storage as separate operations on purpose. If a run fails halfway, I can still see which evidence and which decision justified each step up to that point.
For traders, that means a finding can be traced back step by step to the transactions behind it, even on a run that broke and was resumed.
C8 is done within its scope, and C9 moves on to offline mint initialization evidence.
Question for anyone who has built crawlers on Solana RPC: when a run dies mid-pagination, do you resume from the stored cursor, or restart the walk from the top?
37
A crash after an HTTP attempt is not permission to send the same request again.
Build Log #021
Process-Death Recovery
A process can die at the worst possible moment.
Before a request is sent.
While transmission is underway.
After a response arrives, but before it's saved.
Or after the evidence has been committed.
Each case leaves a different amount of information behind.
In the guarded acquisition workflow, a fresh dispatch authorization is consumed before the HTTP transport is invoked.
If the process dies after that point, restarting does not recreate permission to transmit.
A reconciled dispatch is not a fresh authorization.
And if a response existed only in memory when the process died, its bytes cannot be recovered from a dispatch record.
We tested these boundaries using controlled Linux SIGKILL scenarios, checking what survives, what can be inspected, and what must remain unknown.
The distinction matters.
A committed record is not proof of network delivery.
A timeout is not proof that nothing was sent.
A missing response is not proof that the provider received nothing.
Recovery must not invent certainty.
These rules apply to the guarded workflow under its defined assumptions, not to every possible API call, crash, or power failure.
The goal isn't to pretend failures won't happen.
It's to make sure uncertainty doesn't silently become another request or a fabricated history.
Offline mint initialization evidence is next.
72
A timeout is not proof that an RPC request was never sent.
Build Log #020
The provider may receive a request before the connection drops. Retrying automatically means sending another request without knowing what happened to the first.
After making an undecided seed inspectable in #018 and covering root creation in #019, we added explicit dispatch authorization to the acquisition workflow.
Permission to send is tied to a specific operation. A saved decision or a recovered workflow does not grant that permission. Reconciling an uncertain dispatch does not restore it either.
Once transmission has been attempted, an ambiguous outcome cannot silently become another HTTP attempt for that operation.
This does not tell us whether the provider received the request. It keeps the unknown visible and prevents it from becoming permission to retry.
Process-death recovery and restart safety come next in #021.
For traders reviewing the engine's evidence, a missing response must remain an unknown, rather than being treated as proof that nothing happened.
Build Log #019
Recovery starts with knowing which workflow was actually created.
A process can die mid-run. An ack can vanish after the commit. Without a durable root, the restart becomes guesswork and "we found something on disk" starts to sound like "start over."
Roots are created on purpose and persisted before any HTTP acquisition. Losing the acknowledgment does not create a second root. Finding a valid one does not authorize a transmit.
The workflow's identity has to outlive the process that started it.
Next: guarded one-shot acquisition.
1
86
Build Log #018
Auditing a decision should not create a new one.
When we need to look at a stored policy decision, the engine opens it by the ID that was written, evidence links, the interpretation used, the recorded outcome. Read-only. No "give me the latest." No re-running today's rules over yesterday's inputs. No write path hiding in the inspection call.
Recomputing would be faster. It would also rewrite history. The rules or the surrounding state may have moved, and a new answer stamped as the old one is how audit trails go soft.
If a tool re-scores an old flag with new rules, do you still trust the timestamp on the original verdict?
1
55
Build Log #017
A database error doesn't always mean the write failed. Sometimes the data was saved and only the confirmation got lost on the way back.
For a system that flags tokens, that gap matters. Guess wrong and you either lose a decision or quietly rewrite one.
So this part was about committing decisions safely. Every saved decision keeps its run, attempt, evidence reference, the interpretation it used, the policy outcome and a snapshot of the evaluation.
If a decision already exists, the engine never overwrites it. It compares the stored one with the new one. If they match exactly, it reconciles them. If they don't, it reports a conflict. If we can't tell whether the write landed, it keeps that uncertainty instead of assuming a rollback.
Only a committed continue lets the analysis move forward. Stop and fail end it there.
It's more work than retry and hope. But a flag is only worth something if we can show where it came from, even after something breaks.
Next up: read-only inspection of the stored state.
Have you ever seen a tool give two different verdicts on the same token?
1
92
Build Log #016
This one is about a problem i didn't expect to care about: which analysis a risk flag actually came from.
The engine can re-analyze the same on-chain data many times as the rules get better. the easy option is to just use the newest result.
The problem is that a flag can then quietly change what it's based on and nobody would know.
So now nothing gets picked automatically. every decision has to point at one specific interpretation by its ID and that ID gets checked against the run, the attempt and the evidence it came from. old results are never overwritten.
it's more work on every decision. but if we flag a token, i want you to be able to see exactly what we looked at even months later.
Next up: committing decisions durably and reconciling them.
Has a scanner ever changed its verdict on a token held without saying why?
1
1
110
Making a change to how i run this account.
posts here will go out on a steadier schedule, so more of my hours go into building the engine and i can get back to your replies faster.
Same rule as always: every finding has to point to on-chain evidence you can check yourself.
77
RugShield Build Log #015
Versioned Interpretations
We process stored evidence under an explicit processor version and append each result with its own identity.
Raw observations stay unchanged. No automatic "latest" selection. No silent overwrite.
60
RugShield
Engineering Note
Raw evidence and its interpretation are different.
An RPC response captures what was observed.
An interpretation captures how it was understood.
New analysis must not rewrite raw evidence
Evidence stays. Understanding evolves.
#RugShield #Solana
47
RugShield Build Log #014
Atomic Raw Capture Persistence.
An RPC response is not yet durable evidence.
RugShield stores raw evidence and capture provenance in one SQLite transaction.
An uncertain acknowledgment is not proof of rollback.
No HTTP resend.
43
RugShield Build Log #013
Historical Evidence Reconstruction.
In security infrastructure, the latest state isn't always the state that matters.
A decision must remain traceable to the exact evidence and interpretation that supported it.
RugShield can now reconstruct explicitly selected signature-discovery history using durable identities and ordered relationships.
The reconstruction preserves:
- Discovery run identities
- individual retrieval attempts
- stored evidence references
- selected interpretations
- ordered historical relationships
No automatically selected "latest" interpretation
No rewriting previously stored evidence
No treating historical reconstruction as permission to issue another RPC request.
Why does this matter?
Security logic evolves.
New interpretations emerge.
Threat intelligence improves.
But historical evidence must remain inspectable without silently changing what was originally recorded.
The principle:
Evidence stays immutable.
Interpretations stay identifiable.
History stays reproducible.
Next: Atomic Raw Capture Persistence.
#Solana #Rust
34
RugShield Build Log #012
Deterministic Pagination Policy.
Signature discovery can span multiple pages, but deciding whether to fetch another page shouldn't depend on guesswork.
RugShield now evaluates pagination using explicit, deterministic rules:
- Returned signature order
- Cursor progression
- Request and history limitis
- Duplicate inclusive accounting
- Terminal conditions
Every evaluation produces a defined outcome:
CONTINUE - another page is eligible
STOP - a stopping condition was reached
FAIL - evidence or constraints prevent safe continuation
A policy decision is not permission to send another RPC request.
Planning, authorization and acquisition remain separate operations.
No silent continuation
No assumed completeness
No hidden decisions
The goal is simple:
make every discovery decision reproducible , explainable and traceable to it's evidence.
Next: Reconstructing the exact history behind a decision.
26
RugShield Build Log #011
One discovery run can involve multiple attempts.
A run defines the discovery context.
An attempt identifies a specific retrieval step.
A request defines what as asked of solana RPC.
Keeping these identities distinct makes discovery history traceable and auditable.
#RugShield #Solana #Rust
31
RugShield
Engineering NOTE
Arequest was mad.
A response was received.
A request was made.
These are not the same event.
In security infrastructure, each transition matters.
We design our pipeline to distinguish what was attempted, what was observed and what as durably recorded.
#TardiLabs #Solana
29
RugShield Build Log #010
SQLite Schema V3 - Provenance by Design.
Storing blockchain data is relatively straghtforward.
Preserving its identity, relationships and history correctly is the harder engineering problem.
RugShield's SQLite schema has evolved to V3, supporting durable evidence and explicit provenance relationships.
Core principles:
-> Raw transaction and discovery evidence remain separate
-> Durable identities are explicit
-> Relationships are validated
-> Read only access never silently modifies or repairs storage
-> Historical evidence remains distinct from derived interpretations
-> Failed writes must not leave partially committed records
Append only behavior is enforced through the application's persistence API's.
That does not make SQLite tamper proof against external writers.
The distinction is intentional.
A future security finding must be traceable to the exact evidence and processing history behind it.
Without provenance, intelligence becomes difficult to verify.
Next: runs, attempts and exact request identities.
#TardiLabs #RugShield
1
1
44






