ERC20Authorized: Delegated Token Authorization Layer

How I got here

My path into this project was gradual. A cybersecurity course first taught me the core of how blockchains actually work — hashing, consensus, and why Bitcoin is designed the way it is. Additionally during a co-op term I briefly worked around Samsung’s Knox Matrix, which showed me blockchain concepts applied to something other than currency. By the time I took a dedicated blockchain course, I wanted to build a real token project end to end, not just read about one.

What it is

ERC20Authorized is an authorization layer on top of ERC-20. Instead of owners approving spenders directly, a central authorization server tracks capped delegated authority: an owner can authorize an account up to a cap, that account can trigger approveFor on registered client tokens, and everything can be revoked. Client tokens register with the server and pay a registration fee that flows to a treasury.

What I actually did

This was a two-person project, and my goal was to touch every layer of it:

• Contracts — I built the client registration logic, including a dynamic registration fee with daily cached updates, and later refactored the linear rate math into its own library.
• Tests — I expanded the Solidity test suite across multiple patch rounds, covering registration, revocation, and fee behavior, including closing out issues we filed against our own contract.
• Deployment — I wrote the Sepolia deploy scripts and Hardhat configuration, so the system actually lived on a testnet rather than only in a local sandbox.
• Frontend — I built the entire sample React + TypeScript frontend with wagmi and Vite: wallet connection, an authorization table reading contract events, and modals for authorize/approve/revoke flows against the deployed contracts.
• Docs — I wireframed the frontend and rewrote the README so someone could understand and run the whole system.

Demo

What was actually hard

Honestly, the Solidity itself wasn’t the hard part. Writing the contracts was mostly learning a library and its conventions — OpenZeppelin patterns, test idioms, deploy tooling. Any decent engineer can pick that up in a few weeks.

The genuinely hard parts were the things no library solves for you:

• Tokenomics. Coming up with a fee model that makes sense — why should registration cost anything, what should the rate curve look like, where does the money go — took far more back-and-forth than any function we wrote.
• Lifecycle. Understanding how a blockchain project actually moves from idea to design to testnet to something a user can touch and then later be updated and maintained.