Full stack and blockchain developer with a focus on developer tooling, DeFi protocol engineering, and smart contract security. I build end-to-end — TypeScript CLI tools, Python SDKs, React frontends, Solidity/Clarity/Rust smart contracts, and backend indexers — and I ship independently without a team.

Grant recipient from Arbitrum and the Stacks Foundation. Active security researcher with 15+ confirmed findings across Sherlock, Code4rena, and Immunefi. I audit the same protocols I know how to build, which means I find what others miss.

Languages: TypeScript · Python · Solidity · Rust · Clarity · Cairo · Move · JavaScript
Frameworks: Node.js · React · Next.js · Hardhat · Foundry · Anchor · web3.py · viem
Chains: Ethereum · Arbitrum · Solana · Stacks · Rootstock · Polkadot · Starknet · BNB · Aptos

CLI development environment for Arbitrum Stylus (Rust) smart contracts. Think Hardhat, but for Stylus.

Arbitrum grant-approved. Shipped both milestones. 224 NPM downloads.

stylus-toolkit init --name my-token --template erc20
stylus-toolkit build
stylus-toolkit profile

┌──────────────────────┬──────────────┬──────────────┬────────────┬────────┐
│ Function             │ Rust (Stylus)│ Solidity     │ Savings    │ %      │
├──────────────────────┼──────────────┼──────────────┼────────────┼────────┤
│   read               │ 5,000        │ 6,000        │ 1,000      │ 16.67% │
│   write              │ 12,000       │ 20,000       │ 8,000      │ 40.00% │
│   compute            │ 8,000        │ 15,000       │ 7,000      │ 46.67% │
│   oracle             │ 75,000       │ 103,000      │ 28,000     │ 27.18% │
│ Avg per-call         │ -            │ -            │ -          │ 32.6%  │
└──────────────────────┴──────────────┴──────────────┴────────────┴────────┘
✅ 32.6% average gas savings proven · 26%+ full TCO savings

What it does: init with 4 templates (basic, ERC20, ERC721, DeFi) · build to WASM · profile for side-by-side Rust vs Solidity gas benchmarks · dashboard analytics web UI · dev one-command Docker testnet · deploy to local / Arbitrum Sepolia / Arbitrum One

Stack: TypeScript · Node.js · Rust · Docker · GitHub Actions CI

MCP framework that lets AI agents autonomously manage DeFi positions on Rootstock/Bitcoin — with policy enforcement and session-scoped spend limits.

MCP Client (Claude / any AI)
        │
        ▼
   MCP Server (5 tools)
        ├── get_protocol_data  → Money on Chain + Tropykus RPC
        ├── simulate_swap      → viem call/estimateGas (no broadcast)
        ├── execute_intent     → Session validation → Policy engine → sendRawTransaction
        ├── get_position_health → Tropykus health factor
        └── get_wallet_balances → RBTC + ERC-20 balances

5 hard-coded policy rules block every unsafe action before broadcast — zero-address transfers, selfdestruct calls, single-tx values over 10 RBTC, spend cap overflows, and non-whitelisted contracts. Every decision (allow or deny) is written to an audit log.

Protocol integrations: Money on Chain (MoCState — BTC price, coverage ratio, BPRO/DOC rates) · Tropykus (Compound fork — supply/borrow APY, per-account health factor)

Stack: TypeScript · @modelcontextprotocol/sdk · viem · zod · tsup · Node.js ≥ 20

Python SDK for the Rootstock (RSK) blockchain — wallet management, ERC-20 tokens, smart contracts, RNS domain resolution.

from rootstock import RootstockProvider, Wallet, ERC20Token

provider = RootstockProvider.from_mainnet()
wallet   = Wallet.from_private_key("0x...", chain_id=30)

# ERC-20 in 3 lines
rif = ERC20Token.from_symbol(provider, "RIF")
print(rif.balance_of_human(wallet.address))   # "150.5"
receipt = rif.transfer(wallet, to="0x...", amount=100 * 10**18)

# EIP-1191 Rootstock-specific checksum
addr = to_checksum_address("0x5aaeb6...", chain_id=30)

Covers: Wallet create/import/encrypt · RBTC transfers · ERC-20 (balance, transfer, approve) · arbitrary contract call/transact · RNS forward + reverse resolution · gas estimation · mainnet and testnet

Stack: Python ≥ 3.10 · web3.py · eth-account · pytest · ruff · PyPI published

Non-custodial sBTC yield optimizer on Stacks — compare live APY across Bitflow, ALEX, Zest, Velar, and Hermetica; rebalance in one atomic Clarity call.

;; vault.clar — core deposit/withdraw, 5% performance fee on yield only
(define-public (deposit (amount uint)))
(define-public (withdraw (amount uint)))
(define-read-only (get-position (user principal)))
(define-read-only (get-accrued-yield (user principal)))

;; yield-source trait — every protocol adapter implements this
(define-trait yield-source-trait
  ((get-current-apy  ()    (response uint uint))
   (deposit-sbtc     (uint) (response bool uint))
   (withdraw-sbtc    (uint) (response bool uint))))

Adding a new protocol = one new adapter contract. Core vault never changes.

Architecture: contracts/ (Clarity 4: vault, yield-tracker, rebalancer, trait) · indexer/ (Node.js + TypeScript APY fetchers for each protocol, Express API) · frontend/ (React + Stacks.js, Leather + Xverse wallet connection, YieldTable, PositionCard, RebalanceModal)

Stack: Clarity 4 · Clarinet · TypeScript · React · Stacks.js · Vercel + Railway · Stacks Foundation grant

15+ confirmed findings across Sherlock, Code4rena, Cantina, and Immunefi. The same protocol knowledge that lets me build DeFi tooling also lets me find what breaks it.

Rankings: #45 Ammplify · #48 Super DCA on Sherlock

Languages

Frameworks & Tooling

Chains

Security reviews · Protocol audits · Full stack / backend / blockchain engineering roles · Ecosystem grants · Dev tooling collaborations