Hi, I’m @dylanlott

Currently

Founder, Rust, Ethereum, & Magic: The Gathering Nerd @ init4

Working on Signet, a pragmatic Ethereum rollup.

Previously

• Security Auditor & Audit Lead @ Least Authority
• Senior Protocol Engineer @ Pocket Network
• Senior Golang Engineer & Technical Lead @ SolutionReach
• Senior Software Engineer @ Meroxa
• Senior Software Engineer @ Storj Network

Checkout my github, some of my projects, or some of my audits to see more.

Check out the decklist at Gitrog75.

This build follows the same spirit as my Heliod75 list, but for The Gitrog Monster, aka Frog.

I wanted to build a new commander in this same format, and Gitrog is a commander I’ve not yet explored, so I figured where better to start for the next list.

Same rules apply as previous similar builds: $75 budget for the 99, Commander cost is excluded, it must be tournament legal, and it should be built to be as competitive as possible. Think cEDH analysis applied to $75 budget lists.

I’ve been writing Rust at work for about 4 years now, and while I have a good intermediate grasp on the language, I’m by no means an expert. There’s a lot of things I still want to explore and learn in Rust. The dyn keyword, phantom data, Box and Pin, etc…

1. Directions on channels as types

• <- chan struct{}{} or -> chan struct{}{} is super useful for easy reading and understanding of data flow
  • you can of course just pass around a channel chan struct{}{} but I tend to prefer bound and directed channels.
  • Rust has no equivalent syntax for typing the channel direction
• Interfaces are much easier to pass into functions in Go
  • If you want to pass a trait as a function type in Rust, you can, but it opens up a whole box of dyn troubles because of the ownership implications.
  • Again, possible, but difficult.
• You can make args require an impl, e.g. arg1: impl MyTrait will require that the arg1 argument to the function in example can be anything that implements MyTrait.
  • In rust this is possible but harder to do. Rust’s generic syntax can be a little bit dense sometimes, though I only slightly prefer Go’s constraint syntax.

2. The Simplicity

• I like Rust a lot, but I think that it’s heavy handed sometimes for what I want. Go still hits a sweet spot.
• Everything in Go has a Go answer, but sometimes this does result in some Magic.
  • The date time in the standard library is a great example of Magic in Go.

3. Rust Things That I Miss in Go

• Pattern matching
  • The match keyword is so strong and allows for extremely succinct handling.
  • I almost always prefer a match to an if/then/else flow. It reads so much better to me, and the exhaustive match makes it very clear.
• The memory first approach has to be honored.
  • Rust simply makes Go’s mantra of “share memory by communicating, don’t communicate by sharing memory” into a compile time rule.
    • I’ve described this as Rust “front-loading” the memory management design of a given program.
  • It’s very nice for the actor pattern and similar patterns.
• If it compiles I’m certain it will run, and if it will crash, that’s on me.

Monte Carlo simulations are a powerful method for generating forecasts—predicted scenarios with associated probabilities. These simulations are widely used across various fields, from estimating constants like π and e to predicting weather patterns and modeling fission energy production. In fact, the Monte Carlo method was originally developed by John von Neumann and his colleagues at Los Alamos during the Manhattan Project to simulate atomic collisions in fission reactions.

A Monte Carlo simulation works by assigning multiple values to a single variable, generating multiple results, and then averaging them to estimate likely outcomes. For example, if we wanted to analyze land draw rates for different deck compositions, we could simulate thousands of games and weight the results to determine the most probable outcome. Similarly, we could estimate the likelihood of drawing into a combo with n number of key cards.

Decklist on Moxfield Last Updated 23 Aug 2025.

Introduction

This deck is a response to a Discord deck-building challenge I joined. It attempts to achieve a cEDH-viable Rule of Law style stax and tax deck that can hang at any table based on solid fundamentals rather than a blown-out mana base and artifacts.

The rules were simple: $75 budget, Commander-legal format, and the cost of the Commander is excluded from the budget.

CHOAM is a custom zero-knowledge proof implementation of the Chaum-Pedersen protocol, a challenge-and-response Sigma protocol

The Chaum-Pedersen protocol demonstrates the elegant power of zero-knowledge cryptography. What appears as simple modular arithmetic actually enables profound security guarantees: proving knowledge without revelation.

Building CHOAM in Rust revealed several valuable lessons:

• Rust’s Type Safety: The borrow checker prevented several potential security bugs around integer handling
• Async Architecture: Tokio’s gRPC implementation scales beautifully for cryptographic workloads
• Mathematical Principles: Zero-knowledge protocols showcase how pure mathematics solves real-world security problems

This implementation proves that sophisticated cryptographic protocols can be both secure and practical. The combination of Rust’s performance and safety guarantees with the mathematical elegance of zero-knowledge proofs creates a compelling foundation for next-generation authentication systems.

                     ▄▄    ▄▄         ▄▄                                                        
                     ██  ▀███       ▀███                                   ██                   
                           ██         ██                                   ██                   
 ▄█▀████████  ▀███ ▀███    ██    ▄█▀▀███ ▀████████▄█████▄  ▄█▀██▄  ▄██▀████████  ▄▄█▀██▀███▄███ 
▄██  ██   ██    ██   ██    ██  ▄██    ██   ██    ██    ██ ██   ██  ██   ▀▀ ██   ▄█▀   ██ ██▀ ▀▀ 
▀█████▀   ██    ██   ██    ██  ███    ██   ██    ██    ██  ▄█████  ▀█████▄ ██   ██▀▀▀▀▀▀ ██     
██        ██    ██   ██    ██  ▀██    ██   ██    ██    ██ ██   ██  █▄   ██ ██   ██▄    ▄ ██     
 ███████  ▀████▀███▄████▄▄████▄ ▀████▀███▄████  ████  ████▄████▀██▄██████▀ ▀████ ▀█████▀████▄   
█▀     ██                                                                                       
██████▀                                                                                         

Guildmaster is a tool for game tracking in MTG or other free-for-all style games.

These are a few of the publicly available security audits I completed in my time working as Golang and Rust blockchain application security researcher and auditor at Least Authority.

• Ethereum 2.0 Specifications Audit
• Ethereum Node Disocvery Protocol Audit
• Filecoin Lotus Implementation Audit
• Protocol Labs GossipSub v1.1 Security Audit

A few things I’ve been working on lately.

Code

• futuresight, a terminal CLI for observing Ethereum data.
• vedh.xyz, A virtual boardstate tracker for web and mobile Commander games
• choam, a zero-knowledge JWT authentication server

Decklists

• heliod 75, a low budget ($75), competitively-focused Heliod stax and tax list
• gitrog 75