HONO Protocol Updates
2.41K subscribers
258 photos
32 videos
13 files
444 links
Welcome to the official HONO Protocol channel! πŸš€

Powering liquidity for community projects and growing ecosystems on Web3.

Stay tuned for updates and opportunities.

FarmπŸ¦‰ today at @HootizenBot!
Download Telegram
​​Ethereum's next major upgrade, Glamsterdam, is close. It activated on Sepolia on October 6 and reaches the Hoodi testnet on October 26, with mainnet activation expected to follow in the coming weeks. It is one of the reasons the launch timeline moved, and it explains a bet v3 made from the start.

What the upgrade does. Two headline changes. First, enshrined proposer-builder separation: today the handoff between block proposers and block builders runs through trusted third-party relays outside the protocol. Glamsterdam moves that exchange into the protocol itself, removing the need to trust relays for it. Second, block-level access lists: every block records the accounts and storage it touched, which lets nodes read state and validate transactions in parallel instead of strictly in sequence.

What it does to gas. Parallel validation is what makes higher gas limits safe. Ethereum's block capacity has been rising through 2026 and Glamsterdam is designed to sustain it: more block space per block means less fee pressure at the same demand. The upgrade also reprices some operations upward to reflect what they actually cost the network, so the honest claim is more capacity, not cheaper gas.

Why it matters for v3. L1 has always had the deepest liquidity and the strongest security. What it lacked was cheap enough block space for high-frequency designs, and a fully on-chain order book is the most gas-sensitive design there is: every offer, fill, and cancel is a transaction. Cost is the reason applications left L1 for faster chains and L2s. Glamsterdam directly attacks that reason, and we expect applications to start returning to L1 as capacity rises. v3 is built to already be there.

Why it moved the timeline. Glamsterdam reprices gas, including deployment and state-creation costs, and it changes how blocks are produced and validated. Shipping a new protocol right before a hard fork that changes its cost model means re-validating after the fork anyway. We are validating the deployment against the post-upgrade gas model as part of the remaining checklist, so the contracts launch tuned for the network they will actually run on.

Same story the earlier posts told, at the protocol layer: the post-CEX market needs on-chain venues, and on-chain venues need an L1 with the capacity to run them.
​​Engineering check-in, same format as last time.

Done since the last update:

- The deployment scripts were rebuilt into a staged sequence and the run is underway on Sepolia, stage by stage. The earliest stages are on-chain already: the lock pool is deployed and upgraded, and HONO is running its v3 implementation. Running the sequence is surfacing the problems we built it to catch: ordering issues where later stages consume earlier outputs, and inconsistent contract-address naming across scripts. Both get fixed as they come up.

- The peg keeper is implemented: fee and profit calculation, plus an arbitrage bot that runs through a V4 flash loan.

- The hUSDC base layer and the airdrop streamer are implemented.

- A first round of vulnerability fixes landed, and a second hardening pass across the backing engine, fee collection, vesting, and token creation contracts is in the working tree now.

- Frontend integration is moving: the hUSDC and airdrop pages are being wired to the new contracts, and dead v2 bindings are being removed.

Still in progress: the independent review of the new contracts, the hUSDC vault selection, the remaining stages of the testnet deployment run, validation against the Glamsterdam upgrade's new gas model, and the rest of the frontend wiring.

Same rule as before: no date until the review, the vault selection, the testnet run, and the Glamsterdam validation all clear. When the last item is done, the go-live post follows.
​​v3 gives every graduated token three venues: the bonding curve, the V4 AMM pool, and the order book. A short guide to what each is for.

The bonding curve is for launch. A token does not start with a market; the curve manufactures one. Price discovery from the first buy, automatic liquidity, no creator capital required. Use it to launch, and to buy into tokens that have not graduated yet.

The AMM pool is for casual size and passive liquidity. After graduation, the token trades on a Uniswap V4 pool paired with HONO. Anyone can swap at the pool price or add liquidity and earn fees. The tradeoff: price moves against you as you trade, so larger orders pay more slippage. Use it for convenience and for providing liquidity.

The order book is for precision. A limit order executes at the price you name or not at all. Makers escrow funds into the contract and wait. Takers fill at the posted price. There is no slippage against a curve because there is no curve: you trade against a specific offer at a specific price. Partial fills let large orders work through the book in pieces.

Two different tools. The AMM prices every trade against a formula. The order book lets you name your price and let the market come to you.

On a CEX, the order book was the whole product and the venue held your funds. On v3, both venues exist side by side, the AMM is standard V4, and the order book is contract-escrowed.
​​The full economics of a token launch on v3, in one post. The mechanics and fee numbers below are real; treat any worked example as illustrative, not as parameters.

Path one, the bonding curve. A creator launches a token and it trades against HONO on the curve. Every buy and sell pays a 1% trading fee. The curve runs on a constant-product model with a virtual HONO reserve set at pool creation, so the starting price is fair without the creator fronting capital. The creator can also set a creator fee that routes a percentage of trades to them, and run an airdrop allocation from the curve supply.

Graduation. When the token accumulates enough HONO buying pressure to hit the threshold, the curve converts: the token plus the collected HONO become the initial LP of a Uniswap V4 pool. A 2% graduation fee applies. From that block, the token is a standard V4 asset: tradeable on the pool, routable through aggregators, listable on the order book.

Path two, the liquidity loan. A creator with an existing community locks xHONO instead. The protocol mints hUSDC, converts it to HONO through the vault, and pairs the HONO with the creator's token in a live V4 pool from the first block. The minted hUSDC stays inside the protocol: PSM to vault to LP. It is a loan, not a gift. The liquidity is protocol-owned, reclaimable if the token is abandoned, and backers get their xHONO back on wind-down.

Where the money flows on a loan-path pool: swap fees split three ways between the protocol on a decaying share, the xHONO backers, and the creator. The decay means the protocol takes less as the token grows, which gives the creator a reason to keep building.

Two paths, one destination: a HONO-paired V4 pool with real liquidity.
​​Phase 5 covered the architecture of agentic trading. Here is what it looks like in practice, end to end.

An AI agent connects to our MCP server on the user's machine. The server is read-and-build only: it reads market state and constructs unsigned transactions. It never sees a private key and never broadcasts.

The flow for a first trade:

1. Read. The agent pulls market state through the MCP server, backed by the subgraph: current order book, price history, recent fills. Clean GraphQL, no log parsing, no storage reads.

2. Decide. The agent computes a strategy in its own process. Example: a token's order book price sits above its bonding curve price, an arbitrage gap.

3. Build. The agent asks the MCP server to construct the calldata for both legs: buy on the curve, fill the sell offer on the book. The server returns unsigned transactions.

4. Sign. The transactions go to MetaMask Agent Wallet, which signs and broadcasts under the user's permissions. Threat scanning, MEV protection, and gasless relay live at that layer.

5. Settle. On-chain, through contract escrow. No intermediary holds funds at any step.

The separation is the point. The agent orchestrates, the protocol provides the interface, the wallet signs. Each piece does one job, and no single piece can move funds on its own.

Humans scripting bots run the same rails through a different interface: users author strategies as JSON, and the bot trading system executes them deterministically under the risk guard.
​​Another engineering check-in.

Since the last update:

The launch checklist, where it stands:

- Independent review of the new contracts: βœ…
- Vault tests: βœ…
- Full deployment script on a test network, end to end: βœ…
- Validation against the Glamsterdam gas model: βœ…
- Frontend integration: work in progress

The order book is implemented and tested. The MCP server and bot trading system continue in development; both are post-launch releases, not launch blockers.

Same rule as before: the go-live post ships when the checklist clears, not before.
​​One audience we have addressed in pieces but not as a group: builders. What v3 exposes if you want to build on it.

The order book is composable at the contract level. Other contracts call it directly. A lending protocol can liquidate positions into the book. An aggregator can route orders through it. The graduation contract converts curve liquidity into book markets. No permission required.

The subgraph indexes every event: order placements, fills, cancellations. The full market history is queryable through a standard GraphQL API. An analytics dashboard, a third-party frontend, or an agent that needs market state starts there.

The MCP server gives LLM agents a standard interface: read market state, build unsigned transactions. An agent product, a trading copilot, or an automated strategy runner integrates at that layer.

The bot trading system exposes strategy as data. Typed, versioned JSON documents, executed deterministically under an unbypassable risk guard. Strategy tooling, backtesting, or a marketplace for strategies builds on that format.

Infrastructure means other people's products work on top of it. The exchange, the launchpad, the data layer, the agent interface, and the bot runtime are each a surface someone else can build a business on. That is the difference between a dapp and infrastructure.
​​Engineering check-in, same format as before.

The calendar will be extended slightly. The checklist is updated, and there are still a few items pending.

Where the launch checklist stands:

- Independent review of the new contracts: pending for new features
- hUSDC vault selection: βœ…
- Full deployment script on a test network, end to end: βœ…
- Validation against the Glamsterdam gas model: βœ…
- Frontend integration: work in progress
- Order book implemented and tested: βœ…
- MCP and bot trading: in development, post-launch releases

Due to some exciting new features we've added to strengthen the project, the calendar has been extended.

Same rule as every status post: the go-live announcement ships when the last item clears, not before.
​​A consolidated look at what stands between your funds and the protocol, across every part of v3.

The order book. Maker funds sit in contract escrow for the life of the order. Takers pay the maker directly. You can cancel any open order at any time and get the unfilled portion back. No admin function can freeze an account or halt a cancellation. The only market-level control the owner holds is closing a token to new offers, which leaves existing orders and refunds untouched.

The liquidity layer. USDC deposited in the PSM goes into ERC-4626 yield vaults, held under the vault standard's accounting rules rather than a discretionary wallet. hUSDC exchanges back to USDC at 1:1 for as long as the PSM holds USDC.

Staking. The staking contract is the same model, upgraded. Stakes, votes, and the wstETH rewards stream carried over intact.

The bot system. Every strategy cycle passes through an unbypassable risk guard: daily loss limits, token risk tiers, gas gates, position limits. A strategy can tighten those limits. It cannot loosen them.

The process layer. Fuzz testing runs at 10,000 runs. The deployment script is staged so ordering problems surface on testnet instead of mainnet. Two rounds of vulnerability fixes have landed or are in flight. The independent review is still in progress, and it gates the launch.

None of this removes smart contract risk, which is why the review comes before the announcement. What the design removes is the trust requirement: no operator holds your escrow, no admin freezes your account, no strategy exceeds its limits.
​​The PSM has come up in almost every liquidity-layer post. Here is what it actually does, mechanically.

The PSM is the contract that exchanges USDC and hUSDC at a fixed 1:1 rate in both directions.

Deposit: you send USDC, the contract mints hUSDC 1:1 against it. The USDC goes into ERC-4626 yield vaults, and the vault return belongs to the depositors.

Exchange back: you send hUSDC, the contract returns USDC 1:1, drawn from those vaults, for as long as it holds USDC.

Two properties follow. First, hUSDC is a USDC derivative in the literal sense: every unit in circulation exists because a unit of USDC was deposited, and that USDC is earning yield. Second, the 1:1 exchange is what anchors the DualPool's ~$1.00 price target. Arbitrageurs do the holding work: below target they buy hUSDC on the pool and exchange it at the PSM; above target they mint at the PSM and sell into the pool. The PSM is the layer-three backstop from the DualPool post, and it is mechanical: a fixed-rate exchange, not a committee decision.

The PSM is also where the liquidity loan starts. When a creator locks xHONO, the protocol mints hUSDC through it, converts to HONO via the vault, and pairs the HONO with the creator's token. That minted hUSDC flows PSM to vault to LP and stays inside the protocol. A loan collateralized by the lock, not new supply reaching end users.
​​A part of v3 that has not had its own post: airdrops, and who they go to.

A creator can reserve a share of their token's supply as an airdrop allocation when they launch. The tokens sit in the airdrop contract while the bonding curve trades. When the token graduates to its V4 pool, the allocation moves into the staking contract and the distribution snapshot happens on-chain.

Your share is proportional to stake-seconds: the amount of xHONO you have staked multiplied by how long it has been staked. 100 xHONO staked for one day counts the same as 1 xHONO staked for 100 days. Amount and duration weigh equally, which is what makes the distribution resistant to mercenary capital: showing up with a large stake the day before graduation earns you one day of duration.

Claims are pull-based. After graduation you call claim on the staking contract and receive your share. No snapshot website, no Merkle proof, no off-chain recipient list. The same accumulator pattern that already distributes wstETH rewards distributes the airdrops.

The cumulative effect matters more than any single airdrop: a staked xHONO position collects a piece of every graduating token that carries an allocation, weighted by commitment. Staking already earned votes and wstETH rewards. In v3 it also earns exposure to the launch pipeline itself.
​​The fee structure has come up piecemeal. Here is the whole map: what each venue charges, and where the revenue ends up.

What gets charged:

- Bonding curve: 1% base on buys and sells while the token is on the curve, discounted by your xHONO tier (0.10% floor, 0.00% at Protocol Ally)
- Graduation: 2% of the raised HONO when the curve converts into the V4 pool. A slice pays the last buyer as the graduation reward; the rest goes to treasury
- Order book: the same tiered taker fee (1.00% base, down to 0.00% at Protocol Ally, 0.10% floor on every tier below it)
- V4 pools: a static 1% LP fee on every swap, no tier discount
- DualPool: swap fees on hUSDC/USDC volume, plus a 5% performance fee on depositor gains (high-water mark, never on principal)

Where it lands:

- Graduated tokens run weekly contests: the epoch's collected HONO fees (V4 LP fees plus order book fees, minus the creator's share and the bid wall's 10%) pay that epoch's qualifying buyers (170+ HONO of buys) pro-rata in HONO
- Token-side fees are burned, or split 50/50 between a burn and rebates streamed to xHONO stakers when the token opted in
- 10% of collected HONO fees feeds the progressive bid wall under each graduated pool
- DualPool depositors earn the vault yield on their USDC plus the pool's swap fees, net of the performance fee
- Creators can set a share of up to 20% of their token's collected HONO fee revenue after graduation
- Curve taxes and the graduation fee go to the protocol treasury

The flywheel post described the loop in the abstract. This is the same loop in cash terms: fees stay inside the system, paying the depositors, stakers, creators, and traders who generate them.
​​Graduation gives a token more than a pool. It gives it a credit market.

Every token that crosses the graduation threshold gets a Morpho Blue market created in the same transaction: the token is the collateral, HONO is the loan asset, max LTV is 77%. Holders can borrow HONO against their position instead of selling it.

The part that makes this safe to offer on a memecoin is the price feed. Each market runs on a winsorized oracle built for it at graduation, fed by samples the V4 hook records on every swap. The oracle takes a weighted median of recent prices and caps how far one sample can move the reading: 0.5% up, 5% down. A flash pump cannot inflate your collateral value, and a real crash still reaches liquidations within minutes.

Why it matters: on every other launchpad, a holder who needs liquidity sells into the pool and the chart takes the hit. Here they post the token, borrow HONO, and keep their exposure. Selling pressure turns into lending volume.
​​The rollout starts on launch day. What is staged for after go-live.

The bot trading system releases post-launch. User-authored strategy JSON, deterministic execution, the unbypassable risk guard. It is in development now and deliberately not a launch blocker: the trading rails land after the venues are live and proven.

The MCP server opens to developers at launch, and the agent tooling grows around it: more market coverage, more transaction types, better reads on book state. The agentic rails posts laid out the architecture; post-launch is when agents start using it for real.

The first graduations start the contest system. Every token that graduates runs a weekly trading contest forever, paying its fee revenue back to qualifying buyers in HONO. The first epoch begins when the first token crosses the threshold.

The subgraph keeps accumulating: every order, fill, cancel, graduation, and contest payout becomes queryable history. Third-party frontends, analytics, and agent products build on that record.

And the chain underneath keeps moving: Glamsterdam status at posting time; if mainnet has activated, say so. If not, delete this sentence. V3 is built to take advantage of L1 capacity as it expands.

Launch is one day. The rollout is the weeks after it.
​​Before launch, the complete picture in one place.

The problem: centralized exchanges are shutting down. BitMEX closed September 23. BitMart winds down through January. AscendEX is gone. AI agents are becoming the traders. Token launches need real liquidity, not thin pools. The infrastructure for all of this did not exist as one system.

The three pillars:

1. An on-chain order book. Limit orders, price-bucketed matching, partial fills. Maker funds escrowed in the contract; the taker pays the maker directly. Cancel anytime. No admin can freeze an account. The CEX model without the CEX.

2. A USDC derivative liquidity layer. Deposit USDC into the PSM, receive hUSDC 1:1, your USDC earns yield in ERC-4626 vaults. hUSDC backs HONO. The DualPool trades hUSDC/USDC with a three-layer arbitrage defense holding the ~$1.00 target. Plus the bonding curve: launch on the curve, graduate to a V4 pool at the HONO threshold, and every graduated token gets a Morpho market for borrowing HONO against it.

3. Agentic trading rails. The MCP server lets AI agents read markets and build transactions; MetaMask Agent Wallet signs. The bot trading system runs user-authored JSON strategies deterministically under an unbypassable risk guard. The subgraph exposes everything through GraphQL.

The flywheel: USDC in, hUSDC minted, HONO backed, tokens launch and trade, volume flows through the DualPool and the order book, vault yield accrues, HONO backing strengthens.

HONO is at the center: every pair, every launch, every trade. xHONO stakes, votes, earns, and cuts trading fees. hUSDC is the credit layer. No migration, no new token to claim, nothing to swap.

On top of that: staking xHONO cuts your trading fees on both venues, down to zero at the top tier. And every graduated token runs a weekly trading contest that pays its fee revenue back to buyers in HONO.

One more piece of context: the chain underneath all of it. Everything above runs on Ethereum L1 because L1 has the deepest liquidity and the strongest security in the industry. The old reason to leave was cost. Glamsterdam, the next Ethereum upgrade, attacks it from the capacity side: proposer-builder separation inside the protocol and parallel block validation that sustains higher gas limits. The applications that left L1 for cheaper venues get a reason to come back, and v3 is already there.

What remains before go-live: the independent contract review, the hUSDC vault selection, the end-to-end testnet deployment, and validation against the Glamsterdam gas model. When those clear, the launch post follows.
​​Launch is close. What to do if you hold HONO or xHONO.

If you hold HONO: nothing required. Your HONO carries over to v3. You can use it to buy tokens on the bonding curve, trade on the order book, provide liquidity, or stake for xHONO.

If you hold xHONO: your stake and votes carry over. The staking contract is the same model, upgraded. You do not need to re-stake or re-vote. The rewards stream kept running and continues on v3.

If you want to deposit USDC into the PSM for hUSDC: that is a new action available at launch. You will deposit USDC, receive hUSDC, and start earning vault yield plus your share of DualPool fees. Exact instructions will come with the launch announcement.

If you want to launch a token: the bonding curve is open to anyone at launch.

If you want to trade on the order book: deposit your funds into the contract as escrow, place orders, and trade. Non-custodial. Withdraw anytime.

If you want to run a trading bot: the bot trading system will be available post-launch. The MCP server will be available for developers to connect AI agents.

What you do NOT need to do: migrate tokens, claim a new token, swap one token for another, or take any urgent action. There is no deadline. Nothing expires at launch.

Exact launch instructions will come with the go-live post.
πŸ‘2πŸ”₯1
​​The v3 scope has grown since the Day 1 announcement. Here is what was added, and why.

Since the last engineering update, a set of improvements was added to the core design. They were not in the original Day 1 plan. They strengthen the backing model, the routing, the liquidity structure, and the rewards flow. Adding them meant expanding the checklist and validating each one before go-live.

The additions:

1. HONOv3. HONO's backing switches from wstETH to hUSDC. Same HONO token, same total supply, same holder balances β€” but the asset backing it becomes a USDC derivative held in yield vaults. HONO's exchange value becomes denominated in dollars and grows as fees flow in.

2. The HONO/hUSDC routing pool. A protocol-owned Uniswap V4 pool that creates the canonical route USDC β†’ hUSDC β†’ HONO β†’ token. It functions as a debt facility: every swap fee it collects raises HONO's backing.

3. HonoBidWall. A progressive HONO bid wall under every graduated token, funded by 10% of collected HONO fees each epoch. It is a standing buy order just below spot that follows price upward and converts absorbed sells into token burns.

4. RebatePool. For tokens launched with the rebate flag enabled, 50% of token-side fees go to xHONO stakers as claimable rewards. The other 50% is burned. Opted-out tokens burn 100%.

5. AirdropStreamer. The airdrop model changed from a single graduation snapshot to a continuous 12-month stream weighted by live xHONO stake. Same goal β€” reward committed stakers β€” without the one-block dump incentive.

None of this changes the three pillars from Day 1. It hardens them. The order book, the launchpad, and the agentic rails are the same; the liquidity and backing underneath are stronger.

The engineering checklist is updated to include these. The go-live post still ships only when the checklist clears.
πŸ‘2
​​A deeper look at the first addition: HONOv3.

HONO itself does not change. The token contract keeps the same address, the same total supply, and every holder keeps the same balance. What changes is the asset in the backing vault.

Currently HONO is backed by wstETH. After the upgrade it is backed by hUSDC, the USDC derivative introduced in Phase 4. The price math is the same β€” backing divided by supply β€” but the units switch from wstETH to hUSDC.

Why this matters. HONO's exchange value becomes dollar-denominated instead of ETH-denominated. hUSDC is backed 1:1 by USDC in yield vaults, so HONO is backed by a dollar asset that earns yield. The backing is still concrete and transparent; it is just a different, more stable unit.

The migration is a phased proxy upgrade. First the contract is upgraded with hUSDC support while still in wstETH mode. Then the wstETH is withdrawn, converted to USDC, minted to hUSDC, and transferred to the contract. Finally the backing mode is switched. No HONO is minted or burned in the process.

For holders, no action is required. The token symbol, the decimals, and your balance stay the same. The backing asset underneath changes. That change is what makes the rest of the v3 liquidity architecture possible.
​​The second addition: a canonical pool between HONO and hUSDC.

Right now, to get from USDC to a launched token, a trader would need to find a path through whatever liquidity exists. The new design creates a single canonical route: USDC β†’ hUSDC β†’ HONO β†’ token.

The middle leg, hUSDC β†’ HONO, is a protocol-owned Uniswap V4 pool. It functions as a debt facility: the protocol supplies both sides, and the pool's price is anchored to HONO's live backing ratio from HONOv3.

The fee is 0.05%. Every time a swap passes through, the fee is split:
- hUSDC fee component is deposited directly into HONO's backing.
- HONO fee component is burned.

Both actions raise HONO's backing ratio. The pool is designed so that routed volume reinforces backing. A swap that uses the route makes HONO backing stronger.

This is possible because the pool uses just-in-time liquidity. Instead of a static concentrated position that goes stale as the backing ratio rises, the hook deploys fresh liquidity around the current tick on every swap. No position migration is needed.

For traders, the route is discoverable by the Uniswap router and quotable end-to-end. For the protocol, every routed trade is a small backing ratchet.
​​The third addition: a structural floor under every graduated token.

When a token graduates, three positions are created in its V4 pool. One of them is the HonoBidWall: a single HONO-only liquidity position placed one tick below the current spot price.

Every epoch, 10% of the HONO fees collected from that token's pool are sent to the bid wall. When enough HONO accumulates, the wall is removed and redeployed one tick below the new spot price. As the price rises, the wall follows it upward.

When the wall absorbs sells, it ends up holding tokens. On the next re-peg, those tokens are burned. The wall converts a share of fee revenue into permanent supply reduction and downside support.

It does not prevent crashes. A wall can be punched through, and when it is, the absorbed HONO is spent and the wall restarts from the next epoch's allocation. It works as a shock absorber and a buyback mechanism; it is not a guarantee that price will hold.

The design is adapted from Flaunch's proven BidWall pattern, modified for Hono's static-fee epoch model. It adds a demand-side and supply-side effect to the same fee stream.