Senior Web3 Product Engineer

LucasFranca

I build smart contracts, indexed chain data, backend services, and wallet-connected products as one production system. Beyond Web3, I build secure AI-agent platforms, Go services, and Rust/EVM tooling.

Solidity · Go · TypeScript · React · Rust

12+ years shipping software · 4+ years shipping Web3 · Brasília, UTC−3 · full-time remote

Selected production systems · Agora · 2025 — now

Production Web3 systems

Contracts, chain data, backend workflows, and wallet UX shipped together. 90+ merged public production PRs across governance systems used by Optimism, ENS, and Uniswap.

  1. 01

    Wallet architecture

    One governance product across EOAs, Safes, and embedded wallets.

    Problem
    Three fundamentally different account models needed to use the same proposal, voting, delegation, and transaction flows.
    Decision
    Build account-aware wallet flows: automatic Safe detection and signer progress, reusable SIWE sessions, and tenant-gated Privy integration that reused the existing wagmi and EIP-712 infrastructure.
    Outcome
    Multisig and email/social users gained first-class workflows without breaking the wallet and relay behavior existing tenants depended on.

    Safe · Privy · wagmi · SIWE · EIP-712

  2. 02

    Notification infrastructure

    Wallet-linked governance notifications across five channels.

    Problem
    Governance users needed event-specific alerts across email, Discord, Slack, Telegram, and browser push, without duplicate, unauthorized, or unverified delivery.
    Decision
    Centralize channel verification, wallet-linked preferences, event permissions, retries, deduplication, failure isolation, and delivery analytics.
    Outcome
    One reusable notification platform serving multiple governance products and tenant DAOs.

    TypeScript · queues · multichannel delivery

    Product write-upNotifications Hub ↗
  3. 03

    Identity and eligibility

    Citizenship eligibility became an auditable state machine.

    Problem
    Optimism Season 9 needed to resist Sybil registrations without forcing every legitimate participant through the same verification path.
    Decision
    Combine wallet and social trust signals, explicit eligibility outcomes, conditional identity verification, and EAS-backed issuance in one staged flow.
    Outcome
    Citizenship registration gained priority windows, audit history, revocation, and atomic persistence instead of one opaque pass-or-fail check.

    Human Passport · OpenRank · EAS · Privy · PostgreSQL

  4. 04

    Trust graphs

    Trust became a user-controlled lens, not a platform-wide ranking.

    Problem
    Token communities needed portable trust signals without one global score becoming authoritative for every user and every context.
    Decision
    Add graph selection, EIP-712 profile vouching, explicit linked-wallet identity rules, and a contextual feed lens behind one external API boundary.
    Outcome
    People can choose how trust shapes their feed, switch graphs without reloading, and keep content available if the optional trust service is down.

    EIP-712 · linked wallets · OpenAPI · trust graphs

How the system fits together

Governance is more than a voting screen.

Account models, participation, identity, eligibility, program operations, indexed state, notifications, and onchain execution all meet inside the same product boundary.

My role
Architecture and end-to-end delivery across Agora product repositories
Constraint
One backward-compatible multi-tenant product
Result
90+ merged public PRs across production governance systems
Read the full Agora case study

Governance is more than a voting screen

One product boundary from identity to mined receipt.

Agora’s products connect account models, governance state, identity and eligibility, program operations, notifications, and onchain execution across multiple live organizations.

My public work spans that path—from Safe and embedded-wallet onboarding through citizenship attestations, trust graphs, contract publication, and receipt-verified completion.

01

One multi-tenant product, different account models.

EOAs, Safe multisigs, and embedded wallets require different onboarding, session, signature, and execution behavior. The product still has to expose one coherent proposal, voting, delegation, and transaction experience.

I shipped automatic Safe detection and signer progress, reusable SIWE sessions, and tenant-gated Privy integration while preserving the existing wagmi, EIP-712, and relay paths for live organizations.

02

Identity and eligibility are product state.

OP Atlas connects project and team identity, linked wallets, grants, citizenship, KYC or World ID, attestations, and revocation. Those decisions must remain explainable after the registration screen disappears.

For Optimism Season 9, I combined parallel wallet and social trust evaluation with explicit ALLOW, NEEDS_VERIFICATION, and BLOCKED outcomes, priority windows, atomic issuance, and a durable evaluation trail.

03

Trust can be plural and contextual.

Holders.vote lets a viewer choose one trust graph—or none—rather than allowing a single platform score to become universal reputation.

Profiles prepare, sign, and submit EIP-712 vouches; linked wallets retain explicit raw-key identity semantics; and the feed applies the selected graph through a server-only external API boundary that fails open for content availability.

04

Long-running operations need durable semantics.

Publishing hundreds of contracts exceeded PostgreSQL’s bind-parameter ceiling and could not remain one browser-bound transaction.

I split large publications into authenticated, persisted batches with resumable progress and a separate final metadata phase, while keeping smaller publications atomic.

05

Submitted is not completed.

Authorization decisions moved from client assertions into reusable SIWE-backed server boundaries with tenant, ownership, and role checks.

For sponsored execution, production traces showed that a relay transaction could be submitted, mined, and still fail. Gas limits became estimate-based and the UI began treating a successful receipt—not a transaction hash—as completion.

06

The product depends on more than contracts.

Notification preferences, delivery permissions, indexed governance state, and canonical proposal data connect the product to users between onchain actions.

My application work consumed services such as dao-node and CPLS alongside Snapshot, EAS, RPCs, indexers, relayers, and five notification channels. Those are integration dependencies, not claims that I authored every service.

Public evidence and integration context

AI agent platforms

TakeAIt — an AI-first ticketing system.

Humans and coding agents are first-class users. Agents can claim tickets, create isolated workspaces, run tools, stream progress, ask for input, open pull requests, and pause for human review.

I built the Next.js/PostgreSQL control plane, GCP provisioning layer, and multi-daemon Go runner runtime that make those long-running workflows secure, durable, and recoverable.

How a ticket becomes a pull request

Agents own work; humans retain control.

A model turn is only one event in a longer ticket lifecycle. TakeAIt orders the work, gives the runner a recoverable execution contract, and keeps people connected from assignment through review.

Unit of work
A ticket keeps dependencies, comments, and ordered verb assignments—plan, investigate, code, review, or respond—in one durable record.
Claim
The daemon atomically claims the next eligible assignment while bounded runner capacity prevents competing work from overloading a host.
Run
An isolated workspace receives pinned profile and execution settings while ticket comments and human directives remain live throughout the turn.
Finish
A runner-owned completion policy must pass before final inspection, pull-request creation, and recorded execution provenance.
01

Secure execution

  • Zero-inbound, poll-only runners
  • Rotating hashed keys and per-secret IAM
  • Private VMs and per-agent Unix users
  • Ephemeral per-agent credentials and controlled egress
02

Durable workflows

  • Atomic work claiming
  • Run journaling and replay
  • Crash recovery and host lifecycle management
  • Concurrency controls, reconciliation, and redacted logs
03

Human supervision

  • Pause and redirect during execution
  • Mention-to-wake conversations and question handling
  • Web and Go CLI supervision
  • Review-gated pull requests
Read the full TakeAIt architecture case study

Agents that finish the ticket

The model writes the diff. TakeAIt makes the work durable.

A useful diff is not a completed ticket. Real engineering work accumulates dependencies, comments, decisions, restarts, validation, and review.

TakeAIt keeps that lifecycle in one shared record while the Go runner turns each claimable assignment into a contained, recoverable run.

01

Tickets outlive model turns.

Humans and agents share tickets, threaded comments, dependencies, and assignments. Each assignment pairs a user with a verb such as plan, investigate, code, review, or respond.

Assignments are ordered, so dependency state and earlier work determine what can be claimed next. The resulting run, discussion, outcome, and pull request remain attached to the same ticket.

02

Atomic claiming and isolated execution.

The Go runner atomically claims eligible work and respects bounded host capacity so concurrent daemons cannot execute the same assignment or overload the machine.

Each run receives an isolated workspace and a validated, versioned execution profile. The selected harness, model configuration, and source revision are recorded before work begins.

03

Durable recovery.

The runner distinguishes a completed engine, a stalled turn, an interrupted tool call, and an operational restart instead of collapsing every failure into a generic retry.

Before claiming new work, recovery reconciles durable run state with the workspace and active session. Safe work can resume, stale ownership can be reclaimed, and inconsistent attempts stop with a recorded reason.

04

Human intervention and review.

New comments become context, while questions, pauses, redirects, and interruption remain available throughout execution. A parked run can continue from a human answer even after recovery.

Runner-owned completion policy and structured review findings gate pull-request creation. Every finding must be fixed or answered, and execution provenance stays attached to the review.

05

Operational use and outcomes.

TakeAIt is used in Agora’s internal engineering workflow. Agents share the backlog with humans without someone babysitting a terminal or runner host.

Each handoff remains observable, interruptible, recoverable, and review-gated, so autonomous execution does not remove human accountability.

Original open-source systems project · Rust, Solidity, React

EVM Migration Lab

A public reference system for migrating ERC-721 and ERC-1155 state between EVM chains, with every snapshot and destination claim independently inspectable.

EVM Migration Lab reconciliation view showing the verified Base Sepolia campaign
Fail-closed verification against the released Sepolia → Base Sepolia reference deployment.

Original open-source project · v0.1.0

Verified Sepolia → Base Sepolia reference deployment

  1. 01
    Deterministic source evidence

    Resumable Rust reconstruction, canonical manifests, Merkle proofs, source-chain authorizations, and atomic artifact bundles.

  2. 02
    Narrow destination authority

    Typed ERC-721/ERC-1155 claim contracts, frozen roots, fixed recipients, and direct, batch, delegated, and smart-wallet claims.

  3. 03
    Fail-closed verification

    A React application recomputes artifacts, compares complete campaign state, and disables actions on any disagreement.

2023 — present · shipped onchain products

Onchain products under real load

Historical and current systems where real-time gameplay, DAO stewardship, irreversible assets, and chain migrations became product and operations problems—not contract demos.

01

Historical production game · 2024–2025 · part-time lead

Sekai Glory

A mobile Web3 card game across contracts, indexed state, and real-time play.

I owned the product path from an approximately 16-contract application and indexed tournament state through wallet UX, live matchmaking, recovery flows, and the Blast-to-Ronin migration.

  • Upgradeable game contracts for cards, packs, crafting, equipment, tournaments, and battle-pass state.
  • A five-language mobile PWA with quests, deck management, matchmaking, and animated battles.
  • Multi-chain state and migration work, including production fixes around gas, queues, and failed transactions.
02

DAO governance and game development · 2023–present

Lifeverse DAO / Colosseum of Phanes

Strategy, treasury stewardship, and product delivery for a gaming DAO.

As a council member, I helped decide where treasury and engineering effort should go, stopped work that was not meeting the DAO’s quality or delivery bar, and contributed directly to Colosseum of Phanes.

  • Stopped Arcane development after reviewing a year-long cycle that remained too slow and produced work below the required quality bar, preventing further waste of DAO resources.
  • Built Colosseum of Phanes game and data workflows across registration, battles, missions, traits, rewards, and transactional duplicate-action protection.
  • Helped direct DAO strategy and NFT-holder distributions through a verified ERC-20 claim contract.
03

Historical production system · 2023–2024 · full-stack

Realm

Wallet UX for a transaction-heavy onchain strategy game.

I owned full-stack product integration across battle, equipment, missions, construction, resources, crafting, and ANIMA staking—reconciling contract writes, indexed state, local projections, and transaction lifecycle UX.

  • Battle, crafting, and progression workflows across four verified contracts with more than 277,000 combined transactions by August 2026.
  • Data-heavy resource, productivity, refinery, staking, and reward interfaces.
  • Batched transaction payloads when complete game actions exceeded practical single-transaction data limits, while keeping progress and failures understandable in the UI.
  • Synchronization among contract writes, three subgraphs, local simulations, and failure-aware wallet UX.

Historical ANIMA staking interface

Read the full onchain-products case study

Full-stack onchain games

The contract is only one state machine.

A player experiences one product, but its state crosses wallets, contracts, indexers, servers, queues, local projections, and the interface.

Across Sekai Glory, Lifeverse, and Realm, my work concentrated on keeping those boundaries coherent under real transactions, real-time expectations, and irreversible assets.

01

Optimistic interfaces over slow finality.

Approvals, signatures, submission, mining, indexing, and reflected UI are distinct states. The interface must stay responsive without pretending any intermediate state is final.

I built transaction lifecycle UX around explicit pending, confirmed, failed, stale, and recovered states so a user could understand what the chain had actually accepted.

02

Derived game state crosses several sources.

Battles, equipment, tournament state, productivity, rewards, and crafting combine contract reads, subgraph data, server records, and local calculations.

The hard work is defining which source owns each transition, how stale projections are reconciled, and when the product should recompute rather than trust cached state.

03

DAO stewardship includes stopping work.

After joining the Lifeverse council, I reviewed Arcane against its year-long development cycle, delivery pace, and quality. Continuing would have spent more DAO resources without a credible path to the required result, so I argued to stop development.

That was a product decision as much as a technical one: protect the treasury, redirect effort toward work with a clearer path to players, and contribute directly to Colosseum of Phanes and NFT-holder distributions.

04

Transaction-heavy gameplay changes product design.

Realm treated battles, equipment, missions, construction, crafting, resources, staking, and level progression as onchain state transitions—not decorative mints. Four verified gameplay contracts alone processed more than 277,000 transactions by August 2026.

Some complete actions exceeded practical single-transaction data limits, so I split payloads into batches and made partial progress and failures legible. The application also coordinated three subgraphs, local projections, gas and receipt behavior, and data-dense resource interfaces.

05

Migration is a continuity problem.

Moving a live game between chains changes contracts, indexed data, wallets, operations, and the meaning of late transfers at once.

For Sekai’s Blast-to-Ronin migration, the snapshot boundary was treated as final and product flows were updated around the new execution and indexing boundaries rather than presenting the move as a trustless bridge.

06

Ownership differed by project.

Sekai included contract, product, data, and operational work. At Lifeverse, my scope combined DAO council decisions, treasury stewardship, NFT-holder distributions, and direct Colosseum of Phanes development. Realm’s strongest attributable scope is the wallet-connected application and integration layer over a large existing protocol.

The public evidence below distinguishes official products, product media, verified contracts, transactions, tokens, and collections instead of treating each link as equivalent proof of authorship.

Product systems beyond the protocol layer

Products beyond Web3

Backend, full-stack, real-time, payments, and applied-AI systems with product ownership from requirements through operations.

01

Solo product · closed pilot

Pingou

Built a paid-alerts product for Brazilian streamers: Pix and card checkout, asynchronous content generation, SSE-driven OBS delivery, real-time controls, and automated tests.

Visit Pingou ↗
02

2014–present · long-term part-time

TCDF and ChatTCDF

Twelve years delivering government audit workflows across backend services and Vue/TypeScript interfaces, plus the Court's internal RAG chatbot with Python, LangChain, Elasticsearch, SQL Server, and Docker.

Engineering range

Protocol, backend, product, and operations.

The systems I ship usually cross all four—from contracts and indexed data through durable services, user-facing interfaces, and production infrastructure.

Protocol and wallet systems
Solidity, EVM, Foundry, Safe, SIWE, EAS, wagmi, viem, The Graph, Ponder.
Backend and distributed workflows
Go, TypeScript, Python, PostgreSQL, Redis, queues, SSE, WebSockets, durable execution, idempotency.
Product interfaces
React, Next.js, Vue, wallet onboarding, real-time state, accessibility, i18n, responsive interfaces.
Infrastructure and operations
GCP, AWS, Docker, Terraform, private networking, observability, deployment and recovery.

Full-time remote · international contractor

Build the whole system.

Available from Brasília, UTC−3, with four or more hours of U.S. Eastern overlap.