I am Endale. I build protocol-grade infrastructure that survives adversaries, not surface-grade glue that survives demos. The work is to turn complex logic into systems that hold their shape across chains, runtimes, and load.
My focus sits at three layers: core protocol upgrades, liquidity infrastructure, and cross-chain interoperability — plus the developer-centric SDKs that make all three usable by the people who ship on top.
EVM at the foundation. Solana for high-throughput liquidity. TON for its actor-model asynchrony. Aptos and the Move world for resource-typed safety. Each runtime gets a working dialect — not a port.
“Complex logic is raw ore. Resilient infrastructure is what comes out of the furnace.”
A scribe's ledger of mastery — each paradigm weighted against shipped evidence and the open research front it leads into.
Hardening protocol-level integrity at the state-machine layer. Block synchronization, seal verification, and the slow arithmetic of consensus stability — work that lives beyond execution, in the mechanics of agreement itself.
Designing liquidity engines where every microsecond and every lock contention is a line item on the bill. Industrial-grade SDKs that abstract the math without hiding it — a developer surface engineered for the next wave of builders.
Architecting communication layers between fundamentally different VMs. Solving for atomicity and data integrity across EVM, Solana, and Move runtimes — one semantic surface over execution models that disagree about what "state" even means.
Mastering the shift from synchronous EVM determinism to asynchronous message-passing. Researching cell-based serialization (BOC), TL-B schemas, and actor-model invariants — the scaling bottlenecks that emerge when every contract is its own asynchronous agent.
The furnace doesn't cool. The same ledger as the CV — every thread has a public repo, from untested privacy research to a shipped MCP server.
Exploring privacy-preserving payment primitives — stealth addresses and unlinkable transfers on a chain built for radical transparency.
A zero-knowledge toolkit for on-chain real-world-asset use cases — modular circuits for the agentic RWA economy.
A working implementation of a verifiable random function — provable, tamper-evident randomness for on-chain consumers.
A live Telegram bot monitoring on-chain whale trades on Viction — real-time surveillance of the deep water.
An MCP server handing AI coding agents deterministic, schema-validated EVM tools — security scanning, gas profiling, compiler diagnostics, transaction simulation. Evolved from the EVM Skills Hub library.
Everything else lives in the open — browse the full ledger of public repositories on GitHub.
The dated record behind the paradigms — roles, protocols, and the numbers they left behind. Audited where it counts.
Languages are tools. The real surface is the runtime — its execution model, its consensus, its memory and account semantics. The blueprint lives one layer down.
Account-isolated parallel execution. Liquidity-grade infra where lock contention is the cost — Saros DLMM was built against this model.
Sequential, world-state execution. Block synchronization, seal verification, and consensus internals — the substrate of Viction Chain Core.
Every contract is an actor with its own mailbox. Designing aggregator logic here means treating message ordering as a first-class invariant.
Resources are linear; assets can't be copied or implicitly dropped. The type system is the audit — a different shape of safety than EVM contracts.
Reach out for protocol-level engagements: core upgrades, liquidity infrastructure, cross-chain interoperability, or developer-centric SDKs across Rust, Solidity, FunC and Move.