u/sukiiyasuko

ezath's track record page

Been working on this for almost a year now.

The angle: every signal the system publishes on ezath gets SHA-256 hashed before the trade plays out, hashes chained git-commit style.

example of signals

example of a signal's hash confirmation page

Editing any past signal breaks every downstream hash.

Backtest on two years of BTC/ETH/SOL across multiple timeframes(1h/4h/1d):

- Out-of-sample validation slice: 73% WR, +0.86%/trade expectancy,

- Sealed test slice (untouched during development): 65.8% WR, +0.21%/trade

On the per-trade %: system optimizes for consistency over magnitude.

65-73% WR with ~1%/trade compounds to roughly 10-15x annual at 1x leverage (closer to how quant desks actually work)

Current profit factor sits at 2.08

Curious what y'all think.

ezath track record

Been working on this for almost a year now.

The angle: every signal the system publishes gets SHA-256 hashed before the trade plays out, hashes chained git-commit style.

Editing any past signal breaks every downstream hash, so I literally can't silently delete losers like the Telegram crowd does.

some past signals

example of a signal's hash

Chain head is public at ezath.com/track-record

Backtest on two years of BTC/ETH/SOL across multiple timeframes(1h/4h/1d):

- Out-of-sample validation slice: 73% WR, +0.86%/trade expectancy,

- Sealed test slice (untouched during development): 65.8% WR, +0.21%/trade

On the per-trade %: system optimizes for consistency over magnitude.

65-73% WR with ~1%/trade compounds to roughly 10-15x annual at 1x leverage (closer to how quant desks actually work)

Current profit factor sits at 2.08

Curious what y'all think.

I run a rule-based crypto signal system, and one thing always bothered me (including my own setup):
Everything relies on trust.
Screenshots, edited logs, “just believe me” track records.

So I tried to remove trust from the equation.

Core idea

Each trade is turned into a deterministic string (same fields, same order, fixed formatting).

• Hash it with SHA-256 → content_hash
• Link it to the previous trade → chain_hash

So for trade N:

chain_hash[N] = SHA256(prev_chain_hash[N-1] | content_hash[N])

First trade starts from a constant GENESIS.

What this gives you

• You can’t edit a trade → hash breaks
• You can’t delete a trade → chain breaks
• You can’t insert fake trades → chain becomes inconsistent
• Anyone can verify a trade locally:

​

printf '%s' '<canonical>' | sha256sum

No database access or trust needed, just the raw data.

Minimal example

def canonical(trade):
return "|".join([
trade.symbol,
trade.timeframe,
trade.direction,
f"{trade.entry:.4f}",
f"{trade.stop:.4f}",
trade.created_at.isoformat(),
])

def link(trade, prev_hash):
content = sha256(canonical(trade).encode()).hexdigest()
chain = sha256(f"{prev_hash}|{content}".encode()).hexdigest()
return content, chain

Questions

• Is this a reasonable approach for making logs tamper-evident, or am I reinventing something poorly?
• Would a Merkle tree structure make more sense here, or is simple chaining fine for append-only data?
• Has anyone dealt with this in a multi-writer setup without introducing race conditions?