Leveraged Hooks supercharge Uniswap LPs by turning trading liquidity into lending liquidity too.

We built Hookr.fun around a simple question:

How far can the Uniswap hook primitive actually be pushed?

The obvious uses for hooks are dynamic fees, access controls, automated buybacks, or logic that runs before and after a swap.

But that understates the design space.

A hook sits at the point where liquidity, price discovery, execution, settlement, and LP accounting meet. It can inspect a transaction before it executes, apply market-specific policy, reconcile the result afterward, and maintain persistent state around the market.

That lets us ask a more interesting question:

What if the same liquidity making a market could also extend credit inside that market?

That is the idea behind Leveraged Hooks.

Not a separate perp exchange.

Not a lending protocol placed next to the pool.

Not a second group of depositors funding an external credit vault.

Instead, a single

Hookr.fun

market where LP capital supports spot execution and secured leverage—and where LPs can potentially earn both swap fees and borrow interest.

The Power of the Hook

Leverage is not just a multiplier added to a trading interface.

A credible leverage market has to coordinate an entire state transition:

• Verify that the market is healthy enough to originate new credit

• Calculate how much additional exposure the liquidity can safely support

• Execute the purchase through the canonical market

• Lock the purchased asset as collateral

• Record the resulting debt

• Accrue interest over time

• Restrict new borrowing when utilization or risk rises

• Close or liquidate the position through the same market

A hook can coordinate those steps at the exact moment a swap occurs.

But the hook does not create free capital.

Its power is more precise:

The hook can turn a normal swap into a policy-constrained balance-sheet transaction.

That distinction is the core of the design.

One Economic Market, Not Two Liquidity Pools

The simplest leverage architecture would place a lending vault next to every token pool.

ETH lenders would deposit into the vault. Traders would borrow ETH from that vault. The borrowed ETH would then be swapped through the token’s Uniswap pool.

That architecture can work, but it creates two separate capital bases:

• Trading liquidity

• Lending liquidity

That is not the version we find most interesting.

With Leveraged Hooks, an LP deposits into one Hookr-managed market. That market uses its capital for both execution and secured credit.

There is no second user-facing lending pot and no separate class of lenders.

Technically, the system still requires more than one contract. The hook needs an associated position ledger, risk engine, oracle policy, and managed LP accounting layer.

But economically, there is:

• One LP deposit

• One LP claim

• One market

• One source of capital

The LP’s position is no longer just a claim on the tokens currently sitting on the AMM curve.

It becomes a claim on the complete Hookr market balance sheet:

• AMM inventory

• Performing credit receivables

• Accrued swap and borrow fees

• Market reserves

• Realized bad debt

The underlying primitive is:

An AMM with a balance sheet.

A NODE/ETH Example

Imagine NODE launches through

Hookr.fun

against ETH.

After initial trading, suppose the market contains approximately:

20 ETH

500 million NODE

That market already provides:

• NODE price discovery

• ETH-to-NODE swaps

• NODE-to-ETH swaps

• Trading-fee revenue for LPs

Now Alice arrives with 2 ETH and wants to go 2× long NODE.

Without leverage, she simply swaps:

2 ETH → NODE

With a Leveraged Hook, the position becomes:

2 ETH of Alice’s equity

plus

2 ETH of market-financed credit

equals

approximately 4 ETH of gross NODE buying power

The complete order executes through the actual NODE/ETH market.

The amount of NODE Alice receives depends on the pool’s active liquidity, fees, slippage, and price impact.

The leveraged demand is still real demand.

ETH enters the market.

NODE leaves the available liquidity.

The NODE price moves.

There is no separate leverage price sitting beside the spot market.

The pool remains the market.

The Market Sells NODE on Margin

The cleanest way to understand the transaction is not that the pool physically sends Alice 2 ETH and waits for her to return it.

Instead:

The market effectively sells Alice NODE on margin.

Alice contributes 2 ETH.

The market gives her approximately 4 ETH worth of NODE exposure.

The remaining 2 ETH is financed by the market and recorded as debt owed by Alice.

Her purchased NODE remains locked inside the leveraged position.

She cannot withdraw the financed NODE and disappear.

At origination, the simplified accounting looks like this:

The market delivers

Approximately 4 ETH worth of NODE

The market receives

2 ETH of external cash from Alice

plus

A 2 ETH credit receivable

Alice receives

Approximately 4 ETH of NODE exposure

minus

2 ETH of debt plus interest

Alice’s initial equity

Approximately 2 ETH

No value is created at origination.

The transaction simply changes the form of the market’s assets.

Some liquid inventory becomes a secured credit receivable.

That is how trading liquidity becomes lending liquidity.

Avoiding Double Counting

The locked NODE collateral and Alice’s debt cannot both be counted as independent LP assets.

That would count the same economic value twice.

Alice remains the owner of the position’s residual equity.

The Hookr market has a senior claim against the collateral for principal and interest.

For LP accounting, the market counts the value of the performing receivable.

The NODE collateral matters because it secures that receivable. It determines whether the debt remains healthy and how much the market can recover during liquidation.

But it is not free additional value.

Alice’s equity is:

Locked collateral value minus debt owed

The market’s credit asset should never be valued above the amount realistically recoverable from that collateral.

If the recoverable collateral value falls below the debt, the difference becomes bad debt.

That loss has to reduce LP value or be absorbed by an explicitly funded reserve or backstop.

It cannot be hidden by continuing to mark the loan at face value.

Where Uniswap Ends and Hookr Begins

The persistent debt does not live inside Uniswap as an unsettled token balance.

Uniswap handles:

• The pool

• The swap

• The execution price

• The liquidity transition

• Atomic settlement

Hookr handles:

• Collateral ownership

• Persistent debt

• Accrued interest

• Position equity

• Health factors

• Credit ceilings

• Liquidation eligibility

• Market-level bad debt

Put differently:

Uniswap settles the trade. Hookr carries the balance sheet.

The hook connects the two.

It can validate a position before execution, reconcile the actual swap output rather than relying on an estimate, lock the resulting collateral, and update the credit ledger as one coordinated transaction.

Why Managed LP Accounting Matters

A standard Uniswap LP position represents a claim on the liquidity inside the Uniswap pool.

It does not automatically represent a claim on a separate credit ledger.

That means a production version of Leveraged Hooks will likely require Hookr to manage or wrap the underlying LP position.

LPs would receive a Hookr market share representing their claim on:

• The underlying Uniswap liquidity

• Uncollected swap fees

• Performing leverage debt

• Accrued borrow interest

• Liquidation proceeds

• Market reserves

• Realized bad debt

This is necessary for coherent accounting.

Otherwise, the system could remove NODE from the AMM inventory, create a receivable elsewhere, and leave the original LP position unaware of the asset that replaced it.

The hook is the policy boundary.

The Hookr market share is the accounting boundary.

Together, they let LPs deposit once while their capital performs multiple jobs.

Opening a Leveraged Position

Alice submits a position with:

• 2 ETH of equity

• 2× target leverage

• A maximum acceptable entry price

• A minimum amount of NODE received

• A maximum acceptable borrow rate

Before allowing the trade, the hook checks:

• Current market liquidity

• Existing market debt

• Remaining credit capacity

• Utilization

• Oracle health

• Expected price impact

• Liquidation depth

• Minimum collateralization requirements

• Whether the market is in a protected state

If the checks pass, the gross NODE purchase executes through Uniswap.

The hook reconciles the position using the actual NODE received, not an optimistic quote.

The NODE is then locked inside Alice’s collateral account.

Alice receives a position claim—not freely withdrawable financed NODE.

Hookr records:

• Principal

• Interest index

• Collateral amount

• Entry execution

• Health factor

• Liquidation conditions

The entire operation completes atomically or reverts.

Closing a Profitable Position

Suppose Alice’s locked NODE can later be sold for 6 ETH.

When she closes:

1. The NODE is sold through the NODE/ETH market

2. The market receives the ETH proceeds

3. The 2 ETH principal is extinguished

4. Accrued interest and fees are paid

5. The remaining ETH goes to Alice

For example:

Sale proceeds: 6 ETH

Principal repayment: 2 ETH

Interest and fees: 0.1 ETH

Remaining value to Alice: 3.9 ETH

Alice began with 2 ETH and exits with 3.9 ETH in this simplified example.

The market receives its financed capital back plus yield.

The credit receivable disappears from the balance sheet and becomes liquid market inventory again.

Liquidation and Bad Debt

If NODE declines, the hook continuously compares the recoverable collateral value with Alice’s debt.

Liquidation has to begin before the collateral merely equals the principal.

The system needs room for:

• Swap fees

• Liquidation incentives

• Market impact

• Accrued interest

• Oracle delay

• Adverse price movement during execution

When a position becomes unhealthy:

1. A liquidator or protocol keeper triggers the unwind

2. Some or all of the NODE collateral is sold through the same market

3. ETH proceeds repay principal and interest

4. The liquidator receives a bounded incentive

5. Any residual value returns to Alice

6. Any shortfall becomes explicit market bad debt

The most important invariant is simple:

A credit receivable must never be valued above what its collateral can realistically repay through the market that must liquidate it.

That is why credit capacity should be based on executable depth, not headline TVL.

A market might display a large nominal liquidity number while only being able to absorb a much smaller NODE sale before suffering severe price impact.

The second number is what matters for leverage.

Credit Cannot Grow Faster Than Liquidation Capacity

Suppose the NODE market has:

20 ETH of quote-side liquidity

5 ETH of maximum permitted credit

2 ETH of outstanding credit

The market therefore has:

3 ETH of remaining leverage capacity

That credit ceiling should change with market conditions.

It should consider:

• Available liquidity

• Executable liquidation depth

• Volatility

• Current utilization

• Oracle health

• HOOKR bonding

• Protocol-level risk limits

The most conservative constraint wins.

As debt utilization rises, borrow rates increase.

As liquidity or liquidation depth falls, credit capacity contracts.

When the system reaches its risk limit, the hook rejects new leverage and leverage increases.

Existing users can still:

• Repay debt

• Add collateral

• Reduce exposure

• Close positions

When the system becomes constrained:

Liabilities should be able to shrink, but not grow.

LP Withdrawals Are Part of the Credit Design

No liquidity split does not mean every unit of market value remains instantly withdrawable while loans are outstanding.

Once part of the market’s balance sheet exists as credit receivables, some value remains illiquid until borrowers repay or positions are liquidated.

The LP redemption system therefore needs explicit withdrawal rules.

Depending on utilization, a withdrawal might:

• Execute immediately from available liquidity

• Be limited to a portion of liquid market assets

• Enter a withdrawal queue

• Receive a proportional claim on outstanding receivables

• Include a utilization-sensitive exit fee

The system cannot let early LPs withdraw all liquid ETH while leaving the remaining LPs exposed to every outstanding loan.

This is not just a user-interface decision.

It is part of solvency.

The credit model and LP redemption model have to be designed together.

The Market as Its Own Oracle

For a newly launched token, the Hookr.fun market may be the only meaningful source of price discovery.

That makes the pool the natural price source.

But it does not mean the latest trade should always be trusted.

The hook can maintain observations around:

• Spot price

• Short-window average price

• Long-window average price

• Liquidity depth

• Volatility

• Spot-versus-average-price deviation

• Trade size relative to active liquidity

If price quality deteriorates, the market can enter protected mode.

Protected mode disables

• New leverage

• Leverage increases

• Risk-increasing collateral withdrawals

Protected mode still allows

• Debt repayment

• Collateral additions

• Deleveraging

• Position closure

• Liquidation under the applicable oracle policy

The oracle does not need to pretend the market is always trustworthy.

It needs to recognize when it is not.

What LPs Are Being Paid For

Leveraged Hooks can expand LP revenue from one source to several:

• Swap fees

• Borrow interest

• Liquidation fees

• Hook fees

But the additional yield is not free.

LPs are taking additional risks:

• Borrower default

• Delayed liquidation

• Oracle manipulation

• Reflexive sell pressure

• High utilization

• Withdrawal delays

• Smart-contract risk

Borrow interest is the price paid for that additional balance-sheet risk.

The objective is not simply to advertise higher LP yield.

It is to create a market where additional LP revenue is matched by explicit, measurable, and bounded exposure.

Where $HOOKR Fits

HOOKR can become the economic coordination asset around this market structure.

A creator enabling Leveraged Hooks could be required to bond the already-live HOOKR token.

That bond can help:

• Gate advanced market functionality

• Align the creator with long-term market operation

• Support a market-specific safety buffer

• Constrain credit capacity alongside real liquidity limits

• Reward developers who build and maintain the module

Leveraged Hooks also create new fee streams:

• Borrow interest

• Opening and closing fees

• Liquidation fees

• Additional swap fees

• Module fees

Another hook can route part of that revenue through a simple loop:

Market fees → buy HOOKR → bond HOOKR

This creates a compounding system:

More activity creates more fees.

More fees acquire more HOOKR.

More HOOKR becomes bonded behind the market.

That additional economic backing can become one input into how much safe credit the market can support.

But HOOKR cannot replace real liquidity.

A large HOOKR bond cannot make an illiquid NODE market safe.

Liquidity and liquidation depth remain the hard constraints.

HOOKR can coordinate access, incentives, and economic backing around those constraints.

Existing Tokens Can Opt In

An existing token would not need to change its token contract.

Instead, it could create a new leverage-enabled

Hookr.fun

market.

That new pool would be initialized near the token’s current market price and seeded with enough liquidity to avoid immediate divergence or manipulation.

The token remains the same.

The new pool introduces a different market structure around it.

The Actual Primitive

Leveraged Hooks are easy to describe as native 2× longs.

But the underlying primitive is more important:

A hook-controlled AMM with an expanded balance sheet.

The hook does not bypass accounting.

It makes more expressive accounting possible.

It connects:

• Swaps

• Collateral

• Debt

• LP claims

• Interest

• Liquidations

• Oracle policy

• Fee routing

into one market state machine.

Uniswap provides the settlement and liquidity substrate.

Hookr adds the credit ledger and risk policy that allow the market to do more than exchange one token for another.

That is the boundary we want to push.

Leveraged Hooks supercharge Uniswap LPs by turning trading liquidity into lending liquidity too.

Leveraged Hooks are currently in design and are not live.

We are working through the exact integration, managed LP accounting, credit ceilings, withdrawal model, oracle behavior, liquidation mechanics, and HOOKR bonding system.

Push hooks beyond swaps.

Leveraged Hooks—coming to Hookr.fun🪝

HOOKR TOKEN IS LIVE ON ROBINHOOD CHAIN: 0x18E674231A58c239Dc7DaeDcffE15Ec3A24cff5c

Hookr is a token launchpad for Robinhood Chain where the market rules are a Uniswap v4 hook you compose yourself.

When we started building Hookr, we made a bet: on a permissionless chain, the interesting part of a token launch is not the ticker — it is the market mechanics, and on every launchpad they are identical. Same pool, same fee, same opening chaos. So we built a launchpad where the pool’s behavior is the product.

Hookr is named for the Uniswap v4 hook — the contract a pool calls inside every swap. As of block 27,763,919 on Robinhood Chain, release generation 3 is live and writes are open: launching, blueprint publishing, and trading all work.

How it works:

You enter the token name, symbol, and image, and pick the ETH raise target for your curve — anywhere from 0.0001 to 1000 ETH. Metadata on Hookr is permissionless and not unique; a token is identified by its contract address, and the app says so everywhere rather than pretending otherwise.

You set your fee recipients — up to four, with balances credited automatically at collection — and your creator share of pool fees, from a 50 percent default up to 80 percent. The protocol always keeps at least 20 percent.

You compose the hook. Five blocks are available: Anti-Snipe caps each buy at a share of supply and adds an extra LP fee for your chosen number of blocks after graduation, with exact-output buys blocked so the cap cannot be routed around. Surge Fees scales the LP fee with how much in-range depth a trade consumes. Auto Burn sends a share of actual buy output to the dead address inside the swap. LP Rewards donates an ETH-side share of each buy to in-range LPs in that same swap. Nth-buy Pot fills a pot from an ETH-side share and pays the Nth qualifying buyer. Every parameter you choose is public on the token page before anyone buys. You can also launch from a blueprint — a saved configuration published by another designer, who earns a royalty from the stack’s hook fees when you use it.

You launch, for a flat creation fee (currently 0.0002 ETH). The token sells along a ten-tranche bonding curve: fixed supply of 1 billion, 80 percent on the curve, each tranche priced 70 percent above the last, with a 1 percent curve fee split between creator and protocol. Buys and sells both work on the curve.

When the curve fills, graduation is atomic. In one operation, the reserve ETH and the remaining supply become a full-range Uniswap v4 position owned by the launchpad, with your hook attached. The launchpad has no function to remove that liquidity — locked by construction, not by policy. LP fees on the locked position remain collectable and split creator/protocol; the token side of collected fees is burned. After graduation, nobody can retune the pool. Not you, not us.

We made a number of deliberate design decisions with Hookr, and we would rather state them — edges included — than have you discover them.

Mechanics inside the swap, not around it

First, every block runs on the pool’s own callbacks, inside the swap that triggers it. There is no keeper, no off-chain trigger, no oracle, no ETH vault waiting to be sandwiched. If a mechanic cannot survive being executed atomically in the open, we do not ship it.

Second, the floor is fixed so the mechanics can be flexible. Every launch gets the same curve math, the same atomic graduation, and the same permanently locked liquidity. Creativity lives in the hook; the floor is not negotiable.

Evidence over hype

Third, writes on Hookr are opened by evidence, not by a config flag. The release gate demands ordered deployment receipts, runtime code-hash readbacks, the hook’s exact permission flags, and user-confirmed canary transactions — a real launch-and-graduate, buy, approval, and sell — all re-verified against live RPC before the manifest flips. A production boolean alone cannot open writes. Our superseded first deployment remains public and readable on chain as the receipt of why this process exists.

Finally, the sharp edges are part of the product description. The pot is deterministic, not random — the counter is public, advances at most once per pool per block, and the next slot can be raced. Auto Burn sends tokens to the dead address but does not reduce the ERC-20 totalSupply readout. Hook cuts apply to exact-input buys only; sells pay the LP fee. And when a chain read fails, the app renders “unavailable” — never a fake zero.

This candor may cost us some hype. We think it buys something better: traders who know the rules of a pool before they enter it, and creators whose mechanics can be checked by anyone.

Verify everything yourself on Blockscout:

HookrLaunchpad: 0xaAed6fab06D53311220F35421Dda5cc6D6e9d6C3

HookrHook: 0xd0005624Da88a688BcaB3DBFB4d1Cb23d32Ca0CC

HookrSwapRouter: 0x3f6E7BA9689d3c78A00d68931b7C223f51e0f21b

Hookr Token CA: 0x18E674231A58c239Dc7DaeDcffE15Ec3A24cff5c

Every receipt and canary hash ships in the app’s release manifest.

Stack hooks. Launch tokens. Verify onchain.

Hookr.fun, live on Robinhood Chain.

Unaudited. Not financial advice.

Disclosure: I work on OpenZaps. The contracts are live on Robinhood Chain and have not completed an external audit. Onchain actions are irreversible; use only funds you can afford to lose.

Most “agent wallets” start with the same question: how much authority should an autonomous process receive?

OpenZaps starts somewhere else. It asks whether the agent needs authority at all.

A Zap is a small contract that holds funds for one pre-committed action graph. Its target, recipient, assets, calldata and execution policy are fixed before the user signs. An agent can later submit an execution, but submission is only a trigger. The contract decides whether the submitted action is exactly the one the owner authorised.

That gives us a useful separation:

• Creation authority stays with the user’s wallet or Safe.

• Execution authority lives in the immutable Zap policy and the owner’s typed signature.

• Submission authority is a courier. It chooses when to present the signed action, not what the action does.

The distinction matters because a credential can leak. A session key, delegated signer or broad API token creates a second authority surface that has to be scoped, stored, monitored and revoked correctly. OpenZaps does not give an agent one.

What “connecting” an agent actually means

For recurring and price-triggered Zaps, the owner signs an EIP-712 intent. One field can name an executor address.

If the field is the zero address, anyone may submit a run that is due. If it names an address, only that address may submit it. The contract checks the executor alongside the amount, cadence, floor, recipient and nonce.

There is no separate OpenZaps account connection, bearer credential or offchain delegation record. The signed intent is the connection.

That also means the interface cannot manufacture a stronger relationship than the chain knows about. “Connected” is derived from signed intents and confirmed events, not from a row in a profile database.

The blast radius is deliberately small

Assume the agent is fully compromised.

For a pinned recurring series, the compromised process can:

• Submit a run the Zap already owes.

• Withhold submission and stall the series.

• Receive the executor share of the protocol fee when it submits a valid run.

It cannot:

• Change the recipient.

• Change the amount, cadence, run count or output floor.

• Substitute another adapter, asset or calldata payload.

• Run before the signed interval.

• Run the same nonce twice.

• Continue after the signed series ends.

• Create, fund or drain the Zap.

• Sign as the owner.

Those are not policy promises made by the agent service. They are conditions checked by the Zap onchain.

Pinning therefore trades liveness for exclusivity. If the named executor goes offline, the series stalls. The owner can recover by invalidating the series nonce or signing fresh terms under a new series identifier. If liveness matters more than exclusivity, the owner can use the open-executor mode instead.

Why the MCP surface has no key

The OpenZaps MCP tools are split into two safety classes:

1. Read public chain and relay data.

2. Publish an artifact the owner already signed.

There is no tool that signs as the owner, creates a Zap or broadcasts with an owner wallet.

Simulation is structurally unable to reach the broadcast branch because it is called without a signer. Publishing an intent moves an already-signed artifact to an untrusted relay; it does not grant the relay authority. The Zap re-verifies every field when someone later submits that intent onchain.

This is an important pattern for agent-native finance: the model may propose, but deterministic code and contracts dispose.

A practical connection flow

1. Open the Connect view.

2. Enter the public address that will submit runs.

3. Choose a standing execution type: recurring, relative-floor recurring or a price trigger.

4. Review the recipient, asset, per-run amount, cadence or condition, run count, floor and executor address.

5. Sign the typed intent with the owner wallet.

6. Deliver the signed JSON to the shared relay, the local executor intake, or a file watched by the executor.

7. Verify the signed executor and policy details before relying on automation.

A one-shot Zap is different. Its `relayer` field identifies a fee recipient rather than an exclusive executor, so the product should not describe a one-shot action as “connected” to an agent.

Revocation has three levels

Soft stop: stop the executor process or rotate its gas key. A pinned series stops being submitted, but the signed terms still exist.

Hard revoke: the owner sends an onchain nonce invalidation for the series. Future attempts under that series identifier fail.

Re-pair: the owner signs fresh terms for a new executor under a new series identifier.

Revoking an offchain login would not provide any of these guarantees, which is why OpenZaps does not pretend that a login is execution authority.

What this design does not solve

Bounded authority does not remove smart-contract, adapter, oracle, chain, wallet or market risk. OpenZaps is live and pre-audit. A correctly bounded action can still execute into adverse market conditions within the limits the owner signed. A stalled executor can still cause a missed opportunity. A compromised owner wallet can still authorise harmful terms.

The claim is narrower and testable: an agent cannot widen a Zap beyond the policy the owner committed to.

That is the design target for agent-native DeFi. Give the machine enough agency to watch and trigger. Keep the authority in the signature and the chain.

Verify it yourself

• OpenZaps documentation

• Live explorer

• Agent connection decision record

• Security policy and current audit status

Not financial advice. No yield, return or safety guarantee is implied.

DeFi is programmable, but using it still requires a surprising amount of manual operation.

Users monitor positions, claim rewards, rebalance liquidity, manage collateral, execute recurring swaps, and respond to changing market conditions. Each action may be straightforward on its own, but the work never really stops.

Agents offer an obvious solution: give software the ability to operate continuously on a user’s behalf.

But that creates a more important question:

How much authority should an agent have?

Giving an agent unrestricted wallet access is simple, but it is the wrong abstraction. A general-purpose agent is probabilistic. It consumes untrusted information, interacts with external tools, and makes decisions under uncertainty. Even a highly capable agent should not have the power to reinterpret a user’s intent or move assets wherever it chooses.

OpenZaps starts from a different premise:

Don’t give the agent a wallet. Give it a bounded capability.

Today, we’re introducing OpenZaps, a system for turning approved DeFi workflows into sealed, immutable policy capsules that a Hermes agent can simulate, submit, monitor, and revoke—without ever receiving discretionary authority over the wallet.

Capabilities, Not Custody

An OpenZap represents permission to perform a particular workflow under a particular set of constraints.

Instead of authorizing an agent to “manage my portfolio,” a user can authorize something closer to:

• Compound rewards back into the same vault.

• Rebalance a specific liquidity position within an approved range.

• Repay a bounded amount of debt if a health threshold is crossed.

• Execute a recurring allocation within a fixed budget and slippage limit.

The agent remains flexible in how it observes, reasons, schedules, and responds. But the space of transactions it can execute is fixed by the policy.

The distinction matters.

A model may decide when to invoke an action. It cannot redefine what it is authorized to do.

Conceptually, a policy capsule could constrain the assets, protocols, contracts, function calls, amounts, price impact, frequency, expiry, destinations, and market conditions associated with a workflow. Once the policy is sealed, the agent cannot quietly widen its permissions. A different policy requires a different capsule and a new user authorization.

The capsule is immutable. Its authority is revocable.

This creates a deterministic security boundary around a probabilistic operator.

Agents Need Policies, Not Transactions

Wallets were designed around individual transactions.

A wallet presents calldata, asks the user to approve it, signs it, and broadcasts it. That model works when a person is present for every action. It becomes cumbersome when software is expected to operate continuously.

Agents need a policy-centric authorization model.

A transaction says:

Perform this action now.

A policy says:

You may perform this class of actions, within these boundaries, until these conditions change or this permission is revoked.

Every transaction submitted by the agent is then an instance of an already-approved policy. The user approves the operating envelope rather than every individual operation.

That is the core abstraction behind OpenZaps.

The Goal Is Not a Perfect Agent

Much of the conversation around agent security focuses on making agents more reliable: better models, better prompts, better monitoring, better tool selection.

Those improvements matter, but they cannot be the final security boundary for onchain assets.

The execution layer must assume that an agent will eventually make a bad decision, misunderstand some context, consume manipulated data, or interact with a malicious external system. The system should remain safe even when that happens.

OpenZaps approaches this through least authority.

An agent does not receive general custody and promise to behave. It receives the minimum capability required to perform an approved task. A failure may interrupt the workflow or produce an undesirable action within the permitted range, but it should not become unrestricted control over the wallet.

The security objective is therefore not:

Make the agent incapable of being wrong.

It is:

Make the consequences of being wrong legible, bounded, and revocable.

Hermes as the Operator

OpenZaps is designed to work with Hermes, the open-source agent developed by Nous Research.

Hermes provides the persistent operational layer: memory, reusable skills, scheduling, tool integrations, and the ability to run continuously rather than only during an interactive chat session.

That makes it well suited to tasks such as monitoring onchain conditions, simulating an approved workflow, submitting eligible actions, tracking their results, and reporting back to the user.

But Hermes is the operator, not the owner.

It can reason about the workflow and invoke the capabilities it has been given. It cannot expand those capabilities or acquire discretionary control over the rest of the wallet.

This separation between intelligence and authority is the important part.

The agent can become smarter over time. The permission boundary remains fixed.

From Private Bots to Open Workflows

Most DeFi automation today is implemented as a private bot, a proprietary interface, or a strategy-specific smart contract.

OpenZaps points toward a more open model: reusable, inspectable workflow capsules that can be created by developers, reviewed by users, simulated by agents, and enforced onchain.

A mature ecosystem could allow:

• Protocols to publish canonical automations for their products.

• Strategists to create specialized workflows without taking custody.

• Wallets to display permissions in a standardized, human-readable format.

• Auditors and monitoring systems to reason about the exact action surface.

• Agents to discover and invoke compatible workflows across applications.

Instead of every agent building bespoke integrations and asking for broad wallet permissions, it could operate through a shared library of narrowly scoped capabilities.

The result would be more than automation. It would be an open coordination layer between users, agents, wallets, and protocols.

Introducing 0xZAPS

OpenZaps launches alongside 0xZAPS, the token associated with the project.

The token was deployed through Clanker on July 21, 2026, with the contract address:

0xDd90bFa4adC7F4401E611AbaC692D939F9F4CB07

The initial announcement identifies 0xZAPS as the token for OpenZaps; its broader utility, governance, and incentive mechanics have not yet been detailed.

Bounded Autonomy

Onchain agents will not become useful simply because they gain broader permissions.

They will become useful when users can delegate meaningful work without surrendering control.

OpenZaps is an attempt to make that possible:

Humans define the policy.
Agents handle the operation.
Smart contracts enforce the boundary.

The future of onchain automation should not look like an agent holding your private key and promising to follow instructions.

It should look like an open network of auditable capabilities that agents can invoke—and nothing more.

That is the idea behind OpenZaps.

Bounded onchain automation, with a token to match.

Token contract: 0xDd90bFa4adC7F4401E611AbaC692D939F9F4CB07

Clanker: https://www.clanker.world/clanker/0xDd90bFa4adC7F4401E611AbaC692D939F9F4CB07

Onchain finance has spent the last few years focused on RWAs — bringing real-world assets onchain.

PoolFans is focused on something adjacent, but structurally different:

RWCs — Real World Cashflows.

Where We Started: Tokenized Creator Rewards

PoolFans began with a narrow but intentional use case:
tokenizing Clanker creator reward streams.

Fees accrue onchain, flow into a vault, and mint tokens representing pro-rata claim rights. Those tokens can be traded, routed, or composed into markets.

This demonstrated a simple idea:

Once revenue settles onchain, it can behave like a financial primitive.

That insight generalizes.

Roadmap Phase 1: Liquidity-Native LP Pools

The first expansion stays crypto-native.

We’re introducing additional Clanker-style LP pools with tokenized rewards built directly into the pool architecture. These pools support:

• Clanker tokens seeking deeper liquidity

• any ERC-20 token

• automatic emission of tokenized reward streams

Liquidity stops being incidental. It becomes a revenue-emitting surface by default.

Roadmap Phase 2: Generalized Onchain Cashflows

Next, the primitive expands beyond any single protocol:

Framework for tokenizing any onchain cashflow, using standardized vaults that turn revenue into claimable instruments.

Revenue Stream Vaults — Continuous Cashflow

Simple Vaults are designed for open-ended revenue streams:

• revenue flows in continuously

• tokens represent pro-rata claim rights

• holders can claim at any time

• tokens persist indefinitely

These are well-suited for:

• protocol fees

• ongoing creator revenue

• subscriptions

• usage-based pricing

They represent continuous participation in a live revenue stream.

Time-Locked Revenue Stream Vaults — ‘Revenue Stream Bonds’

Time-Locked Vaults introduce duration.

They mint ERC-20 shares that represent claim rights on future revenue, with a fixed maturity defined at deployment.

• shares are freely transferable during the lock

• the lock expiry is immutable

• after expiry, holders redeem once

• redemption burns all shares (burn-on-claim)

This creates a clean lifecycle:

trade during the term → redeem at maturity → exit

Functionally, these behave like revenue stream bonds.

Markets price:

• duration

• expected yield

• revenue reliability

This enables fixed-term revenue financing, forward pricing of cashflows, and secondary markets for time-bounded exposure.

Modern Transfer & Settlement Standards

Time-Locked Vault shares support modern authorization-based transfer standards:

• ERC-2612 (permit)

• ERC-3009 (authorized transfers)

This enables gasless transfers, intent-based routing, and integrations with payment and settlement rails—allowing revenue instruments to move as naturally as any native token.

Roadmap Phase 3: RWCs — Real World Cashflows

Once the system supports:

• continuous revenue streams

• fixed-term revenue bonds

• market routing and liquidity formation

…the source of the revenue stops being the defining factor.

This is where RWCs come in.

RWCs represent real-world revenue that settles onchain and flows through the same vault and market infrastructure.

Example Flow

An online business generates USD revenue.

1. Sales occur offchain

2. Revenue is converted into USDC on Base

3. USDC is deposited into a PoolFans vault

4. Tokens are minted representing claim rights

5. Tokens trade, route, and redeem onchain

The cashflow becomes onchain-native.
The markets treat it the same as any other revenue stream.

The Unified Stack

Across all phases, the architecture stays consistent:

FANS → governance + revenue access
ZAPS → market ignition + liquidity routing
Revenue / RWC Tokens → cashflow claims

Whether revenue originates from:

• creator rewards

• protocol fees

• LP activity

• or real-world commerce

…it flows through the same stack once it settles onchain.

Why This Matters

RWAs bring existing assets onchain.

RWCs bring ongoing economic activity onchain.

By focusing on cashflows, PoolFans enables markets that are:

• continuously priceable

• composable

• duration-aware

• and governed at the protocol layer

Tokenized fees were the starting point.
Generalized onchain cashflows expand the surface.
RWCs extend it beyond crypto while preserving the same structure.

Closing

RWAs represent what exists.
RWCs represent what flows.

PoolFans is evolving from tokenized creator rewards into infrastructure for global cashflow markets — continuous or fixed-term, crypto-native or real-world.

That’s the vision.

Pool.Fans Homepage

Outline

1. Overview: Clanker + PoolFans

2. How Clanker Works (Mechanics)

3. Token Archetypes That Fit

4. Liquidity Lifecycle and External LPs

5. PoolFans: Tokenized Creator Rewards

6. Playbooks for Creators

7. Investor Lens: Why This Stack Matters

8. Resources

💦 Homepage: pool.fans
📚 Docs: pool.fans/docs
🧭 Clanker Guide: pool.fans/clank
✅ Deployment Cheatsheet: pool.fans/cheatsheet
🏦 Clankernomics: pool.fans/clankernomics
⚙️ Tokenizer: tokenizer.pool.fans

Overview

Clanker is a modular, multi-chain token launchpad built on top of Uniswap v4–style pools (factory + hooks + LP locker). It turns “launch a token” into a repeatable onchain pattern instead of a one-off bespoke contract.

A Clanker deployment gives you:

• A fixed 100B ERC-20 token.

• A Uniswap v4 pool backed by a locked “liquidity staircase” of single-sided token liquidity.

• Configurable swap fees that generate ongoing creator rewards.

• Reward routing to up to seven recipients, including PoolFans’ Rewards Vaults.

PoolFans sits downstream of Clanker’s reward routing and turns a slice of those creator rewards into ERC-20 Rewards Tokens. That creates a separate, composable layer for owning, selling, and aligning around the fee flows from a token’s market.

Together:

• Clanker = launch + liquidity + creator rewards wiring.

• PoolFans = control plane for those creator rewards and the incentives built on top.

2.1 Launch Without Upfront Liquidity

Traditional launches assume the creator brings quote-asset liquidity (ETH, stables). Clanker inverts that.

On deploy:

• The factory mints a fixed 100B ERC-20.

• The LP locker posts that token into a set of Uniswap v4 positions as single-sided liquidity across up to seven price bands (the “liquidity staircase”).

• These positions are protocol-locked.

You supply tokens, not ETH. Buyers bring the quote asset when they trade. As price climbs through ranges, more of your supply unlocks into the market.

Implications:

• No upfront ETH/stables required for a credible market.

• Locked, non-ruggable liquidity.

• A deterministic launch curve, encoded in how you distribute supply across ranges.

• You give up some flexibility in exchange for trust and clarity around how supply exits.

2.2 Creator-Owned Rewards from Swap Fees

Each Clanker pool has its swap fees wired through a hook:

• Every swap pays a configurable fee into the pool’s fee logic.

• The protocol takes a fixed cut.

• The remainder becomes creator rewards, split immutably across up to seven recipients (basis-point splits).

Simple example:

• Pool fee: 1%.

• Daily volume: 100k notional.

• Raw fees: ~1k.

After the protocol cut, the rest flows as creator rewards to whichever recipients you configured:

• Treasury or dev wallet.

• Community rewards address.

• PoolFans Rewards Vault that mints Rewards Tokens.

Instead of fees accruing to anonymous LPs, Clanker routes them directly into creator rewards rails that you can design around.

2.3 Dynamic Fee Logic and Fee Conversion

Clanker’s hook layer supports different fee styles:

• Static fees: fixed basis points for buys/sells when you want predictability.

• Dynamic fees: base fee plus a volatility component, skimming more during turbulent periods and less during calm periods.

• Fee conversion: creator rewards can arrive as WETH, WETH + token, or token-only, depending on configuration.

You get real levers:

• Low static fees if you want frictionless volume.

• Dynamic fees if you want to protect depth and harvest more creator rewards when markets are wild.

• A choice of what asset your creator rewards accumulate in.

2.4 Sniper Protection and MEV Redirection

Launches on a public mempool usually devolve into a latency and MEV race. Clanker inserts a MEV-aware module between “deploy” and “open trading.”

High-level flow:

• After deployment, swaps are gated for a short protection window.

• During this window, the pool runs a sequence of sniper-auction rounds with a descending fee curve.

• Aggressive early takers pay elevated fees, which are redirected as creator rewards rather than pure external MEV.

You get:

• A staged ramp from protection mode into normal trading.

• Early demand partially recycled into creator rewards.

• A more legible starting environment for humans instead of a single-block snipe.

Lifecycle: intent → config → deploy → MEV window → open distribution, with the MEV window explicitly designed, not ignored.

The contracts don’t care about narrative, but three archetypes map cleanly to this structure.

3.1 Mini-App Tokens

For mini-app builders (Farcaster, Base-native apps, and other ecosystems as Clanker expands):

• The app has a clear onchain loop: tips, boosts, access levels, in-app actions.

• A Clanker token sits at the center of that loop.

• Swap fees from trading the token generate ongoing creator rewards.

• Those creator rewards are routed to a mix of treasury, community programs, and possibly a PoolFans Rewards Vault.

Creator rewards become the app’s “cash register”:

• They scale with real usage and volume.

• They can be tokenized as Rewards Tokens and used for aligned incentives (staking, quests, loyalty programs).

• They avoid inflationary emissions on the base token.

3.2 Creator / Social Tokens

Creators use Clanker when they want:

• Fixed supply + credible, transparent launch rails.

• Built-in creator rewards from swap fees.

• Optional PoolFans integration for tokenized reward claims.

These tokens can represent:

• Access to communities or content.

• Participation in a project’s upside.

• Membership or reputation inside a graph.

Routing examples:

• Some creator rewards to a dev wallet.

• Some to a community pool or staking contract.

• Some to a PoolFans Rewards Vault that issues Rewards Tokens.

You wire creator rewards onchain at deploy time instead of promising to “share upside later.”

3.3 Meme Tokens and Viral Experiments

Meme coins are high-throughput users of the system:

• Priority: fast, low-friction launch.

• The liquidity staircase gives a shaped supply curve without manual LP games.

• Swap fees turn volatility into creator rewards while the narrative plays out.

Even if you never touch PoolFans:

• Liquidity is locked and transparent.

• Fees are configurable and explicitly routed as creator rewards.

• Onchain history is clean and easy to integrate with tools and explorers.

Memes and serious applications share the same launch rails and rewards surface.

The core mental model: factory + hooks + LP locker → token + pool + creator rewards wiring. The nuance is how liquidity and creator rewards evolve over time.

4.1 Phase 1: Locked Staircase as Distribution

At deploy:

• The LP locker spreads your token across up to seven price bands, forming the liquidity staircase.

• Most non-reserved supply (not set aside for vaults, airdrops, dev buy, etc.) lives in that staircase.

• Positions are locked; the only way tokens leave them is when traders buy.

In Phase 1:

• Traders bring the quote asset, walk the staircase, and pull tokens out.

• Quote asset accumulates behind the remaining tokens in each band.

• Swap fees accrue as creator rewards into the fee locker, then out to your reward recipients.

From the creator’s perspective:

• If you’re the only reward recipient, you effectively own 100% of the pool’s liquidity and creator rewards (minus protocol cut).

• You cannot withdraw or reshape the staircase after deploy.

• Price and holder distribution are driven entirely by flow, not treasury decisions.

The bottleneck here is attention and usage. Weak orderflow means most of your supply sits idle in the staircase and creator rewards grow slowly.

4.2 Phase 2: External LPs and Creator Rewards Dilution

If the token catches a bid:

• Volume grows.

• Holder count grows.

• External LPs start adding their own positions around the active ranges.

Now:

• Your locked staircase still exists.

• Additional LP positions overlay it.

• Routers split trades across all positions based on best execution.

Example:

• Total liquidity: 80% your staircase, 20% external LP ranges.

• Daily volume: 100k notional.

• Pool fee: 1%.

Roughly:

• About 80k of volume routes through your staircase.

• About 20k routes through external LP positions.

Your creator rewards now correspond to ~80% of volume instead of 100%. As successful pairs mature, the share of liquidity controlled by the original staircase usually declines.

Clanker’s range layout and dynamic fees make the staircase harder to dominate, but in a permissionless AMM, creator rewards naturally dilute as more external capital arrives.

The point is not to prevent dilution, but to observe it and decide what to do with that signal.

PoolFans plugs into Clanker by replacing a plain reward address with a Rewards Vault that mints ERC-20 claims on creator rewards.

5.1 From Creator Rewards to Rewards Tokens

Baseline: Clanker routes creator rewards to normal addresses. With PoolFans:

• In your Clanker configuration, you assign one reward slot to a PoolFans Rewards Vault.

• That slot’s share of creator rewards (for example, WETH from swap fees) flows into the vault.

• The vault mints a fixed supply of Rewards Tokens, where 100 tokens = 100% claim on that vault’s creator rewards.

• Anyone holding Rewards Tokens can claim their pro-rata share via PoolFans contracts.

You now have:

• The underlying Clanker token (used and traded by your community).

• A separate Rewards Token (claims on the creator rewards generated by that token’s market).

Both are ERC-20s and can move independently.

5.2 Aligning Incentives with Your Community

Without tokenized rewards:

• The only way outsiders can tap into creator rewards is to compete with your staircase as LPs, which dilutes your share.

With Rewards Tokens:

• You can sell or allocate part of your creator rewards as direct onchain claims, without changing the token supply itself.

• Rewards Token holders earn more as volume and creator rewards increase.

• They don’t need to post LP capital to share upside.

This changes the incentive landscape:

• Fragmented liquidity and mercenary LPs reduce aggregate creator rewards and the value of Rewards Tokens.

• Coordinated activity around the canonical Clanker pool increases creator rewards for all Rewards Token holders.

Creator rewards become a shared coordination primitive rather than an internal line item.

5.3 Escaping the Early Phase

Tokenized rewards give you a lever for the hardest part: going from “fresh launch sitting in the staircase” to a live market with sustained activity.

Simple design:

• Your Clanker config routes some defined share of creator rewards (say 60%) into a PoolFans Rewards Vault.

• That vault mints 100 Rewards Tokens.

• Treasury keeps a portion; the rest are sold or allocated to early supporters.

Proceeds from selling a portion of Rewards Tokens can:

• Fund development and operations without dumping your main token.

• Seed non-inflationary rewards programs for stakers, users, or LPs.

• Underwrite PoolFans engagement pools and campaigns.

For Rewards Token buyers and recipients, upside is tied to:

• Creator rewards, which track sustained trading and usage.

• The health of the canonical pool and the integrations built around it.

Over time, you get a loop:

• Tokenized rewards attract aligned supporters instead of purely speculative flow.

• Those supporters drive integrations and volume.

• Creator rewards increase; Rewards Tokens re-rate.

• You gain more room to experiment with PoolFans-powered incentives.

6.1 Launch Playbook

1. Choose archetype: mini-app, creator/social, or meme.

   • That choice sets fee levels, staircase shape, and when/if tokenized rewards come in.

2. Configure fees and reward routing:

   • Apps: balance user friction vs runway.

   • Creator/social: design how creator rewards are surfaced back to holders.

   • Memes: lean into volatility but keep fees meaningful enough to fuel creator rewards.

3. Treat the first week as a lifecycle, not just an announcement:

   • Content and casts lined up in advance.

   • At least one concrete use case or integration live at launch.

   • Clear, legible story about where creator rewards go and whether there is a Rewards Vault.

6.2 Growth Playbook

1. Watch three curves:

   • Your share of total liquidity across ranges.

   • Volume flowing through your staircase vs external LPs.

   • Creator rewards per unit of volume.

2. Introduce or scale tokenized rewards once you have evidence, not just theory:

   • Real volume and sustained interest.

   • Historical creator rewards as proof points.

   • A plan for how Rewards Tokens will be sold, distributed, and used.

3. Aim rewards at growth behaviors, not passive holding:

   • Onchain actions that deepen your market and graph.

   • Bots, mini-apps, and dashboards that integrate your token.

   • Liquidity that strengthens the canonical pool rather than fragmenting it.

6.3 Long-Term Playbook

1. Keep a clear canonical pool and rewards configuration:

   • One obvious “main” market.

   • Transparent creator rewards routing.

   • Simple explanation of any Rewards Vault.

2. Treat fee config and reward splits as parameters:

   • Revisit static vs dynamic fees as the market evolves.

   • Adjust total fee take vs user friction.

   • Update splits between treasury, community, and tokenized rewards as needed.

3. Put creator rewards on your mental balance sheet:
   Over time you’ll have:

   • A liquid token with trading history.

   • A visible onchain stream of creator rewards.

   • A layer of Rewards Tokens and vaults tied to that stream.

That is a composable structure you can plug into treasuries, auctions, lending, indexes, and strategy contracts.

From an investor perspective, Clanker + PoolFans is interesting on three axes: standardization, structural fee capture, and composability.

7.1 Standardized Launch + Rewards Rails

• Clanker provides a repeatable launch primitive across multiple EVM chains.

• Projects plug into the same contract pattern instead of rolling their own.

• This standardization makes it easier for wallets, explorers, and dashboards to integrate.

7.2 Structural Fee Capture and Distribution

• Swap fees (and part of the launch-time MEV) are hard-routed into creator rewards.

• PoolFans lets those creator rewards be fractionalized into liquid ERC-20 Rewards Tokens.

• Over time, every successful Clanker token accumulates a measurable onchain history of rewards flow.

This unlocks:

• Protocol-level cuts on creator rewards.

• Infra around Rewards Tokens (vaults, auctions, strategy contracts) as additional fee surfaces.

• Baskets and indices of fee claims across many Clanker launches.

7.3 Aligned Liquidity Instead of Pure Rent Extraction

• Without tokenized rewards, external LPs are the only way for outsiders to share upside from trading fees, which dilutes creator rewards.

• With Rewards Tokens, creators can sell or allocate fee rights directly to aligned users who don’t need LP capital.

• Communities then have a direct incentive to route volume and integrations into the canonical pool where creator rewards are maximized.

7.4 Multi-Chain Expansion

• The pattern is chain-agnostic: once the factory, hooks, and lockers are deployed on a chain, the same launch and rewards logic applies.

• Each new chain adds:

  • A new surface for Clanker deployments.

  • A new universe of creator rewards streams.

  • A larger pool of Rewards Tokens for PoolFans-powered strategies.

7.5 Network Effects and Moat

• More tokens launched on Clanker → more creator rewards streams → more interesting things to build on.

• More tools and strategies built on Rewards Tokens → more demand for Clanker-style launches.

• The full stack (factory, hooks, staircase design, sniper logic, rewards vaults, and strategies) is opinionated and interlocking, making it harder to clone piecemeal.

Over time, the goal is for “Clanker + PoolFans” to be the canonical way EVM-native tokens launch, own their liquidity, and share creator rewards with aligned holders.

Sources:

• Clanker Documentation — Introduction
  https://clanker.gitbook.io/clanker-documentation

• Clanker Documentation — v4 Core Contracts (factory, hooks, LP locker)
  https://clanker.gitbook.io/clanker-documentation/references/core-contracts/v4

• Clanker World — Main interface and token deployment surface https://clanker.world

• Dish — “Introducing Clanker v4” (Paragraph)
  https://paragraph.com/@dish/introducing-clanker-v4

• unblocked — “Keep the Rewards Flowing: How External LPs Affect Your Clanker Rewards” (Paragraph)
  https://paragraph.com/@unblocked/how-external-lps-affect-your-clanker-rewards

• Uniswap Docs — v4 Overview
  https://docs.uniswap.org/contracts/v4/overview

• Uniswap Docs — v4 Hooks Concept
  https://docs.uniswap.org/contracts/v4/concepts/hooks

💦 Homepage: pool.fans
📚 Docs: pool.fans/docs
🧭 Clanker Guide: pool.fans/clank
✅ Deployment Cheatsheet: pool.fans/cheatsheet
🏦 Clankernomics: pool.fans/clankernomics
⚙️ Tokenizer: tokenizer.pool.fans

Clanker Fee Tokenizer will give $FANS exposure to trading fees and align us with the continued success of all Clankers 💦 View recording from This Week in Miniapps hosted by Linda from Farcaster to learn more.

Links:

Website: https://pool.fans/

Coingecko: https://www.coingecko.com/en/coins/poolfans

FANS Token Contract: https://basescan.org/token/0x04cafd53ecfa6f6a9168de3d6d2b837d04a51b07

Farcaster Miniapp: https://farcaster.xyz/miniapps/uoCURgSipbep/pool-fans

Farcaster Profile: https://farcaster.xyz/poolfans

Kyberswap: https://kyberswap.com/swap/base/eth-to-fans

Hey everyone!

Been a while but I haven't been this excited to launch something in our space since Zapper ⚡️

Would love to hear your thoughts 🙏

View Launch Thread on X

Join my new subscriber chat:

Today I’m announcing a brand new addition to my Substack publication: DeFi Tutorials subscriber chat.

This is a conversation space exclusively for subscribers—kind of like a group chat or live hangout. I’ll post questions and updates that come my way, and you can jump into the discussion.

Join chat

How to get started

1. Get the Substack app by clicking this link or the button below. New chat threads won’t be sent sent via email, so turn on push notifications so you don’t miss conversation as it happens. You can also access chat on the web.

Get app

2. Open the app and tap the Chat icon. It looks like two bubbles in the bottom bar, and you’ll see a row for my chat inside.

3. That’s it! Jump into my thread to say hi, and if you have any issues, check out Substack’s FAQ.

😡 Current web3 UX problems

Web3 involves complex concepts and technical jargon that can be confusing for the average user and most applications often lack intuitive onboarding processes making it challenging for new users to get started.

Most people are here for financial opportunity and cultural impact. Learning the ins and outs of web3 can be an uphill battle. The protocols and their UIs are complicated, and there are risks of human error and scams such as phishing.

As builders in this space onthis.xyz wants to enhance the user experience and reduce the barrier to entry and growth in Web3.

User experience should always be seamless.

Decentralized Finance (DeFi) is an ecosystem of protocols that provide financial opportunities for anyone with a computer and an internet connection. The problem however, is that often times people are reluctant to engage in these opportunities due to the complexity of the actions required in order to execute even the most basic strategies.

To execute a strategy you must visit a combination of protocols which exposes you to the risk of getting phished. A common occurrence where scammers create fake websites that look like the real website where users get their wallet drained upon interaction.

This happens more often than you think and even the most experienced users have been victims at some point.

In addition to all this, loading webpages often times can be data intensive. If you have slow internet, the entire process becomes even more challenging and puts you at a disadvantage to others.

To summarize the 3 main problems are

🚨 Executing DeFi opportunities requires time & undivided attention.

🎣 Users are constantly exposed to phishing risk.

📉 Weak internet delays execution, putting users at a disadvantage to those with faster internet.

The solution to all this is something we call ENS Shortcuts.

📚 Intro to ENS domains

The Ethereum Name Service is like an internet directory for the Ethereum blockchain. It helps people find other people by "labeling" their web3 wallet addresses with easy-to-read names.

Let's think of your wallet address as your web3 username.

When you create a fresh wallet, your "username" will look like this: 0x0c24f8af31b9b552923ba36b29f484eabb7fa0d2

With ENS domains you essentially "rename your username" into something that's actually readable by other people.

Your "username" can be something like eldari.eth

This way if Vitalik Buterin wanted to send me some ETH he would simply type in my easy to remember "username".

⚙️ How ENS Shortcuts work

OnThis is building ENS shortcuts which simply connect existing protocol functions together.

Shortcuts do not add on any extra smart contract risks in addition to current financial protocols that are built on top of Ethereum. End-user like you are literally doing the same thing you would be doing on your own when interacting with these protocols.

There is a default fallback function called receive() which starts the chain of function calls.

One of the biggest advantages of using shortcuts is that you're not waiting for one transaction to settle in order to move on to the next one.

OnThis does not charge any fees, all shortcuts are free to use and we do not control or hold any users funds.

💡 Shortcut Examples

​​Let's say you want to sell some ETH.

You can do that by sending the ETH you want to sell to the domain ethToUsdc.eth

Pretty simple.

Now let's look at another example of a domain that represents a more complex action than just selling a token.

Let's say you have some ETH sitting in your wallet and you want to put it to work to earn more ETH.

This particular strategy earns users 6-7% on their ETH and requires interaction with 2 protocols: Lido Finance & Curve Finance.

How to execute the strategy:

1. Visit Lido Finance protocol.

2. Approve contracts for use.

3. Deposit your ETH. You will receive stETH tokens representing your deposit.

4. Visit Curve FInance.

5. Search & find the stETH/ETH pool.

6. Approve contracts for use.

7. Deposit stETH.

OR

You can use an ENS Shortcut for this and turn 7 steps into 1:

1. Send ETH to stake.onlido.eth 🤷‍♂️

This is done directly from your wallet meaning you won't need to wait for any websites or transactions to load.

🌟 Potential

Shortcuts revolutionize user experience. They empower users by allowing them to seize opportunities with minimal effort while simultaneously protecting them from scams.

1 action to do what you intend - swap, earn, mint, bridge and etc.

That's it.

Shortcuts amplify growth for protocols. Something like onboarding liquidity or minting NFTs becomes a 1 step action for end users.

Shortcuts remove complexity and make it easier for protocols to boost users, value, and activity.

🛠️ Create your own shortcut

If you have a shortcut idea for you or a protocol you can start the building process here. http://coda.io/form/Create-Your-Shortcut_dOFvrtN5QAV…

Shortcuts can be build to perform a combination of the following actions:

- Swaps

- Bridging

- Minting NFTs

- Staking (LPing)

- Opening/Closing leverage positions

- Buying/Selling socialFi shares

To get some inspiration for your ideas, you can refer to our current directory of shortcuts by visiting:

http://onthis.xyz

🫂 Connect

If you'd like to connect with anyone from the OnThis.xyz team please reach out our DMs are open! You can also join our discord community by visiting this invite link : http://discord.gg/onthis

If you are starting with ETH and want to add liquidity to Uniswap V3 Pools, you will need to navigate through a complex UI and execute at least 3 on-chain transactions:

1⃣ Visit a website and find a pool.

2⃣ Select which price range you would like to provide liquidity for.

3⃣ Swap appropriate amount of ETH into the other underlying asset of the pool.

4⃣ Wrap remaining ETH into WETH.

5⃣ Process 2 approval transactions for 2 underlying assets of the pool (WETH+Another ERC20).

6⃣ Preview the liquidity position and process the add liquidity transaction itself.

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇

Why Shortcuts?

👉 With Shortcuts you just send ETH and you’re done!

No need to: ❌ visit any websites, ❌ approve tokens, ❌ select ranges, or ❌ swap into required proportions.

Each shortcut has been programmed to do one thing and one thing only: execute a defined intent. Don’t worry about filling in any function parameters, when you send ETH to one of the shortcut contracts, it knows what to do. So different actions/intents each have their own dedicated contract with a custom ENS name.

The first Shortcut we are introducing for Uniswap V3 pooling is adding liquidity to the cbETH/ETH V3 Uniswap Pool with Min Tick: 440 and Max Tick: 590. This means you will be generating proportional split of any swaps which happen between 0.94271 cbETH per ETH and 0.95696 cbETH per ETH.

Using Metacrypt’s tool for simulating and calculating pool ROIs, this range seems to be generating fees as your overall position always stays fully exposed to ETH + generating pool swap fees on top!

How it works:

We’ve registered each Shortcut with the Ethereum Name Service, enabling a Venmo-like experience where users just send ETH to human readable addresses to execute specific intents directly from your wallet.

Dedicated Shortcut Smart Contract for adding liquidity to the cbETH/ETH LP has been registered with ENS under cbeth.onuni.eth so that adding liquidity on Uniswap V3 Pool could be as easy as sending a text!

You can view all adding liquidity transactions on etherscan: https://etherscan.io/address/0x69BFfC600f74864cBa3099fd6BD9765604fcc5Cd

Here’s a sample transaction: https://etherscan.io/tx/0x8feecaa51102f65c3ab0d715452c9ab2fc2d6286b2e52d3a2774f552a83d8ea9

As you can see out of 0.01 ETH input, 0.005 was swapped for 0.004761578514613799 cbETH. After 0.004761578514613799 cbETH and 0.00205170807456229 ETH were added to the cbETH/ETH LP. User receives ERC-721 NFT which tracks your pool share.

Any leftover ETH along with minted Uniswap ERC-721 NFT Liquidity Provisioning tokens are sent back the users’ wallet. onThis.xyz does not charge any fees on top of network gas and soon we will enable completely gas-less transactions.

What happens after?

• Once you receive your LP tracking tokens, you can track your balances here https://app.uniswap.org/pools.

When it comes to leveraging DeFi protocols, it can be difficult to know where to start.

Here at onThis.xyz, we aim to make it easier & safer to access interesting opportunities in Web3 - saving you time, effort, and transaction costs.

Have a shortcut idea? Submit this form to get started.

Share

We’ve created an ENS shortcut to help anyone buy Friend.tech keys simply by sending ETH to a human readable address directly from mainnet wallet AND without the need to sign up for Friend.tech (which is currently invite only).

Want to set up a custom shortcut to help your followers buy your keys with ease? Submit form here.

Why use this?

• No sign up.

  • Buy Friend.tech keys without getting into tech.

• Save time.

  • Instead of having to process multiple transactions and navigating through endless UIs, send ETH and you’re done!

• Save gas.

  • Interacting with ENS Shortcuts eliminates the need to process approvals and multiple txs, cutting up to 40% of your net gas costs compared to doing it yourself manually.

• Stay safe.

  • Avoid phishing sites by never having to visit any websites to get into DeFi. Just send ETH to human readable addresses directly from your wallet.

How it works:

Visit https://ens.defrag.fi to view all available shortcuts!

Visit https://ens.defrag.fi to view all available shortcuts. In this tutorial we will go over a shortcut which helps you stake ETH on Lido & Curve in one transaction.

How it works:

Simply deposit ETH directly from your wallet to stake.onLido.eth or 0xe3c2068C3920d9703c2963661004eA2D41ce8f8E.

What happens in the background:

1. Your ETH is staked on Lido to get stETH.

2. After, your stETH is pooled on Curve to get steCRV LP.

Here’s a sample transaction: https://etherscan.io/tx/0xeee60c7e061ca9081493ded67ec89a27f724d1de2c93e647967ac8288665aca2

Net APY on your ETH deposit: 6-7%

Why use this?

• Save time.

  • Instead of having to process multiple transactions and navigating through endless UIs, send ETH and you’re done!

• Save gas.

  • Interacting with ENS Shortcuts eliminates the need to process approvals and multiple txs, cutting up to 40% of your net gas costs compared to doing it yourself manually.

• Stay safe.

  • Avoid phishing sites by never having to visit any websites to get into DeFi. Just send ETH to human readable addresses directly from your wallet.

Traditional Method VS ENS Shortcuts

1. Visit Lido Finance. 1. Send ETH to onlido.eth

2. Deposit ETH → Receive stETH.

3. Visit Curve Finance.

4. Select the stETH pool.

5. Approve Contracts.

6. Deposit & Stake stETH.

What happens after I send my ETH?

Your wallet will receive steCRV LP tokens and you’re able to view your details on:

https://curve.fi/#/ethereum/pools/steth/deposit

DeFragDAO submitted the first proposal on Snapshot, please follow this link and vote if you are a Metamatician holder and get closer to claiming future rewards. Not a holder?

MINT METAMATICIANS

What's DeFrag?

DeFrag is a lending protocol where borrowers can use NFT assets as collateral to get an instant loan.

How it Works.

The protocol allows you to get an instant loan using NFTs as collateral. It does so by applying a peer-to-pool model connecting borrowers to an underwriting pool. As a borrower, you do not have to wait for another user to accept the terms of your loan. 

The maximum amount you can borrow depends on the value of the NFT assets you have deposited and the available liquidity.

Initial Collateral.

Genesis Legions NFTs by TreasureDAO.

Why TreasureDAO? The current market conditions are difficult. In difficult times, projects have the opportunity to lay the foundation for hypergrowth in the future. We believe the decision to incorporate DeFrag into the foundation of the Treasureverse will be instrumental for both DeFrags’ and Treasures’ future success.

A decentralized video game console thrives on growing NFT collections within the Treasureverse. One of the most significant value unlocks for these NFT collections will be the creation of Liquidity Pools for the purposes of lending and borrowing. DeFrag allows borrowers to use NFT assets as collateral to get an instant loan utilizing a peer-to-pool model.

Initial Underwriting Pool.

In order to jumpstart borrowing, the protocol needs to raise liquidity for underwriting initial loans.

This is where Metamaticians come in. Metamaticians are NFTs based on famous mathematicians. They are randomly generated with 100% on-chain art and metadata.

Proceeds from Metamatician NFT mints will be used to jumpstart the initial underwriting pool for TreasureDAO's Genesis Legion NFTs.

• This will enable borrowers to generate instant liquidity using Legions as collateral.

• In return Underwriters will earn fees based on their stake in the underwriting pool. Because the initial underwriting pool is using liquidity from minting proceeds, Metamatician NFT holders are the initial Underwriters. Each representing a proportional share of the pool and fees earned.

Benefits of using DeFrag:

• Instant liquidity for borrowers: Borrowers can receive a loan by using their NFT assets as collateral by tapping into the liquidity provided by the underwriters, providing an instant loan without negotiating peer-to-peer loan terms. ****Underwriters pool liquidity to earn premium fees from the sale of Put Options without having to negotiate terms such as strike price, or expiration with a peer or counter-party.

• Liquidation insurance on collateralized NFT assets: The protocol automatically insures your NFT assets with a financial instrument called a Put Option. In other words, to receive a loan against your NFTs, the protocol purchases insurance on your behalf via Put Options. The maximum amount you can borrow depends on the value of the NFT assets you have deposited and the available liquidity.

• Ability to utilize collateralized NFT assets in-game: Our dynamic vaults will allow borrowers to get a loan using their in-game NFTs assets without losing the in-game playability of their collateralized NFT assets.

• Lower barrier to enter Treasureverse: DeFrag will enable users to obtain Treasureverse NFTs (starting with Genesis Legions) without having full liquidity to do so. For example, if Genesis Legion asking price is ~$1000 and the user has only $800, in a single transaction DeFrag will: (1) flash-loan the user $200, (2) add it to user’s $800 to purchase the $1000 GL, (3) collateralize on DeFrag to generate $200 loan to repay the flash-loan. As a result, the user would have obtained the Genesis Legion NFT with a $200 loan from DeFrag.

Get involved

Join our Discord: https://discord.gg/defrag

Follow us on Twitter: https://twitter.com/DefragDAO

DeFrag DAO will be giving away Genesis Legion #601 to one lucky DeFrag Underwriter!

• To become an underwriter you must mint at least one Metamatician NFT before migration snapshot: 11:59 PM EST 10/15/2022.

• The more Metamaticians you mint, the greater your chance of winning.

• All Metamatician minting proceeds will be deposited to bootstrap the initial underwriting pool, giving each Metamatician NFT a proportional share in the pool.

MINT METAMATICIANS

Last week marked the launch of Gitcoin Grants Round 13. Gitcoin Grants is a new funding mechanism for open-sourced initiatives. As a leader in web 3 talent sourcing, Gitcoin introduces a novel matching approach by leveraging quadratic funding to further boost contributions to popular projects. 

Quadratic funding places emphasis on the quantity of contributions, rather than the total size of those contributions. Meaning that the more people who contribute to a campaign, the larger portion of the matching pool they will receive. This creates a powerful bootstrapping mechanism as the community can signal towards where funds *should* be flowing.

We’re extremely excited to participate in this round of Gitcoin Grants and encourage those interested in improving NFT liquidity throughout our ecosystem to contribute on our page: https://gitcoin.co/grants/5051/defrag.

Each contribution means a lot for us, no matter how small. Currently, your $1 donation gets matched with $157!

We will be using 100% of proceeds to partner with the industry’s best talent to help expedite the deployment as well as an official audit.

If you or your project want to help us on our journey, come join us on Discord and stay in touch on Twitter.

DeFrag Gitcoin Page

A quick recap:

DeFrag will launch in phases, gradually adding features as the protocol matures.

In order to provide a frictionless borrowing experience, the protocol needs to raise liquidity which will be used to underwrite the loans. This is where Metamaticians come in.

Metamaticians are randomly generated NFTs based on famous mathematicians. By owning a Metamatician you will have a stake in the first Underwriting Pool to earn premium fees. A Metamatician NFT serves as an entry ticket into the DeFrag universe of NFT collateralized loans. During the mint, a random 8 digit number and a greek symbol associated with risk in pricing out financial instruments are generated and assigned to each Metamatician.

The 8 digit number will be used to generate unique properties on your NFT which can boost your abilities in our financial ecosystem. A few examples include - improving your collateral ratio in other words the ability to borrow more. Another example is increasing your stake in a liquidity pool. Once the protocol is live, the community will be able to vote in other interesting dynamic variables to be derived from 8 random numbers and real-world events.

All minting proceeds are automatically deposited into the DeFrag DAO Treasury. Once the community votes in the initial NFT project to be used as collateral, ETH will be transferred over from the Treasury into that initial underwriting pool. As borrowers begin to take out loans, the protocol will automatically issue the required # of NFT put options and lock up required ETH to underwrite them. Learn more on docs.defrag.fi

Step-by-step visual guide on how to mint Metamaticians through DeFrag.fi homepage.

Step 1: Connect your Ethereum Wallet.

Step 2: Choose the total amount of Metamaticians you would like to mint.

Step 3: Confirm your transaction.

Optional Step: View minting transaction process via Etherscan.

Step 4: View your Metamatician on OpenSea.

Minting via Etherscan.

Why should I know this?

Minting directly through the smart contract allows the user to bypass the website interface. This is critical to know in case the website experiences downtime, which is common with hyped NFT drops. The steps below apply to most NFT projects.

Step 1: Search the Contract Address on Etherscan.

Copy and paste the contract address into the search bar on Etherscan and click the address that pops up.

Contract Address: 0xdD93258A9C8b4C4EA900FD3043fc59Be05D624A6

Step 2: Navigate to “Contract” Section.

Once you search the contract address you’ll see this window. Click on the contract section.

Step 3: Click on “Write Contract”

Step 4: Connect your Ethereum wallet.

Step 5: Click on the “mint” function.

The naming of this function can be different depending on what the developers named it.

Step 6: Input Mint Price and Amount of NFTs you want.

You want to get this information from etiher the project site or discord. Make sure you have the correct price per mint and the max amount of NFTs you can mint in 1 transaction.

The deadline is time now in seconds from epoch + 20 minutes in seconds.

new Date(new Date().getTime() + 20 * 60000).getTime()

JS Deadline^

Step 7: Confirm the transaction.

Once you’ve confirmed the transaction, the Matematcian(s) should arrive to your wallet shortly. In the meantime, you can view the status of your mint transaction on Etherscan. Simply paste your wallet address into the search bar as you did in Step 2. You’ll be able to view your most recent transactions.

Step 8: View your Metamatician on OpenSea

We will use the most common marketplace for viewing your NFT(s) in this example. Go to Opensea and connect your Metamask wallet.

Our core beliefs

We are spending more of our lives online. As global citizens of the internet, we must have two fundamental building blocks — financial sovereignty through DeFi and digital private property through NFTs. We believe Web3 will manifest itself by leveraging these two components. As native Web3 assets proliferate, they will require an intricate yet fluid relationship between DeFi and NFTs.

Who we are

Introducing DeFrag, a lending protocol for NFT owners to access instant liquidity. DeFrag allows you to use your NFTs as collateral. We rank the creditworthiness of your NFTs based on several factors to determine your collateral ratio.

Why we are different

The protocol automatically insures your NFT assets with a financial instrument called a Put Option. In other words, to receive a loan against your NFTs, the protocol purchases insurance on your behalf via Put Options.

Peer To Pool

DeFrag uses a Peer To Pool model which allows for borrowers to get instant liquidity on their NFT assets without having to wait for a counter-party to enter into a contract. Underwriters provide liquidity and earn premiums through the insurance fees collected from the sale of Put Options.

Raising the Underwriting Pool via Minting our Metamatician NFTs

In order to provide a frictionless borrowing experience, the protocol needs to raise liquidity to jump-start the liquidity pool that will underwrite the loans.

This is why we created the Metamatician NFT.

Metamaticians are randomly generated NFTs based on famous mathematicians. Minting proceeds will be deposited into the initial NFT underwriting pool giving each Metamatician a proportional stake in the LP. Subsequently, the NFT will be generating fees that are collected from the sale of Put Options (insurance on your NFTs).

Minting Details

In phase one, 3,141 Metamaticians will be available to mint for a set price of 1.618 ETH each and serve as an entry ticket into the DeFrag universe of NFT collateralized loans.

Each Metamatician features unique attributes including the name of a famous mathematician, a randomly generated 8 digit number, and a greek symbol associated with risk in pricing out financial instruments.

DeFrag has integrated Chainlink Verifiable Random Function (VRF) on the Ethereum mainnet. By integrating the industry-leading oracle solution, DeFrag now has access to a tamper-proof and auditable source of randomness required to assign attributes to Metamatician NFTs during the minting process in a fully transparent and unpredictable manner. Through Chainlink VRF, we can help ensure participants have a fair and equal chance at obtaining NFTs with the rarest traits.

The 8 Digit Number | Pi π

The randomly generated 8 digit number is your place in the number Pi following the decimal.

The proximity of your number to “3” will determine the rarity of your NFT. Which in turn will boost your abilities in our financial ecosystem. A few examples include improving your collateral ratio in other words the ability to borrow more. Another example is increasing your stake in a liquidity pool.

Get involved

Join our Discord: https://discord.gg/XCWXtU3pdt

Follow us on Twitter: https://twitter.com/DefragFinance

Introduction.

Two years ago Zaps made their DeFi debut @ Kyber’s Hackathon with one simple goal — abstract the complexities of accessing unique opportunities in open finance.

What’s a ‘Zap’?

A Zap is a smart contract that bundles multiple DeFi actions into a single transaction, enabling frictionless onboarding and saving time.

So far over 150 Zaps have deployed $10 billion across various DeFi protocols.

This post will review the History of Zaps; Where they came from, how they iterate, & current/future use-cases.

The Evolution of DeFi.

Today, Decentralized Finance (DeFi) is a multi-billion-dollar ecosystem of smart contracts, enabling a wide range of crypto-financial activities across multiple blockchains. DeFi’s open, permissionless, non-custodial, composable features have lowered the barrier for creating new financial instruments.

However, this Cambrian explosion of financial experiments would never have been possible without Ethereum’s community. They held true to the ethos of DeFi — build without compromising any of the four core principles.

“Skate to where the puck is going to be.”

Looking at the 2018–2019 statistics, one might compare the total value locked and not see much progress. But even though the total value locked in DeFi year over year experienced only a modest increase, the number of users utilizing multiple DeFi protocols exploded.

In other words, only a small number of new users entered DeFi protocols that year. However those that did, not only stayed but they actively used more, especially as new protocols were introduced.

Why ‘Zaps’?

When I started to notice ‘DeFi’ popping up everywhere, I naturally gravitated toward it; given my background in accounting.

At the time, I didn’t know what to build. I started by making walk-through tutorials using new DeFi projects such as, MakerDAO, Compound & Uniswap, among others. Many of my legacy friends were intrigued but still hesitant to utilize these tools. That is when I decided to use DeFi Tutorials as a way to test drive & growth hack while simultaneously showing them that these products had real potential.

Interestingly enough, I actually parlayed my information from DeFi Tutorials to create something called DeFi Strategies. It was a trading simulator that used Google Sheets and Etherscan allowing people to mess around with DeFi using fake money.

After playing around with different scenarios, I noticed a number of users expected to be able to buy the bundle of their choosing directly within DeFi Strategies. I immediately connected this with a tool that connects thousands of Web-2 apps via Zaps called Zapier. It was clear that as more protocols launched onto market, DeFi would desperately need a tool comparable to Zapier - one that would connect DeFi actions performing an overarching task without having to visit each of the underlying Dapps individually.

The First Zap.

During Kyber’s DeFi hackathon, we only had one functioning Zap deployed on the mainnet: Lender Zap. This Zap simply allocated incoming deposits 90% to cDAI and 10% to opening a 2x leveraged ETH Long.

A key feature to note, is that Zaps don’t simply allocate your capital to ‘top 10 by market cap’, they deploy it directly into the underlying financial protocols. In other words, you mint & receive the same liquidity/position tracking tokens that you would if using Uniswap, Compound, Synthetix, etc, separately.

While Lender Zap cut out unnecessary transactions, it wasn’t just the ‘money allocator’ concept that won Kyber’s hackathon for us. It was a combination of the Zap Generator (survey that recommends which Zap combo might be right for you) and the integration of ENS capabilities, which allowed users to access DeFi opportunities simply by sending ETH to human-readable addresses directly from their Ethereum wallet.

Winning the hackathon gave us an incredible push from the community to keep building. The importance of improving UX in DeFi was clear.

Moving the needle for AMMs.

After deploying Lender Zap, we continued to gather user feedback to improve repetitive user transactions by bundling them. The flexibility to pivot by spinning up a new Zap in a short period of time, made Zaps the perfect tool for finding product market fit. Every Zap launch could be considered a mini product launch that focuses on a niche target market/user-case. You just need to listen, adjust and repeat.

From observing a common paint-point some users experienced while interacting with Uniswap Pools, we created Unipool Zaps. As many users are familiar at this point, you need to supply 2 equally proportioned assets if you want to enter a pool on Uniswap V1 or V2.

Here is a basic example:

Let’s say you are holding ETH; to add liquidity to the ETH/DAI pool:

1. Convert 1/2 of ETH into DAI,

2. Approve DAI for trading on Uniswap

3. Make a deposit of ETH + DAI to mint your LP tokens

DAI Unipool Zap bundles all of those steps into one; taking care of all the required conversions and allocations in the background so that anything you send to this contract will get converted 50% into DAI and 50% into ETH (if it’s already not in ETH) and deposited into the pool.

So instead of ETH → DAI → DAI Approval → DAI LP 

It’s ETH → DAI LP directly.

Most Valuable Pegger.

The demand for Unipool Zaps was clear right away, especially around sETH/ETH pool. In addition to keeping your exposure fully in ETH, it rewarded stakers with SNX tokens.

This was the original Yield Farm. Prior to Anton’s infamous Liquidity Mining contract, which automated farming distributions; the Synthetics team was taking periodic snapshots of all sETH UNI-LPs and distributing SNX rewards manually.

Every Zap into a sETH/ETH pool improved the sETH<>ETH peg itself, and by March the peg had resolved to ~1.00. It was a privilege working with the Synthetics community to improve liquidity around sETH.

But the majority of Uniswap pools didn’t keep your exposure fully in ETH. This was a big issue for those wanting to provide liquidity but anticipating ETH or ERC20 asset to increase in price much faster than the other one. To help eliminate impermanent loss, Leveraged Liquidity Pooling Zaps were introduced. These Zaps used ⅓ of your deposit to open a margin long position with 2X leverage on ETH or ERC20 asset (whichever you anticipate to go up faster in relation to the other). And the other ⅔ is deposited into your desired liquidity pool. Here’s an example of LINK Leveraged Liquidity Pooling Zap:

iEarn Zaps.

As DeFi got more complex, so did the number of possible Zap combinations. The best way to keep up with this demand is to open up the floor for builders to easily remix their own Zaps by combining existing Zap actions. This is why all Zaps were open-sourced from day 1 and it didn't take long for builders to start composing new financial instruments with Zaps. 

Zaps 2 years later.

Continued user feedback & iteration ultimately lead to the inception of the robust ecosystem of over 150 Zaps you see today.

Projects utilizing Zaps:

• Synthetix

• Yearn

• Trader Joe

• ArbiNYAN

It was a huge year for us at Zapper! Although it might feel like Zapper has been around forever, our journey officially kicked off on May 1st. Back then, we never dreamed of passing $1B in total transaction volume just 8 months later.

That said, we wanted to take the time to recap Zapper’s first calendar year from simply building the tool we personally needed as DeFi users, to greater ambitions ahead of us in 2021 and beyond.

January

• After winning Kyber’s DeFi Hackathon, DeFiZap continues composing new use-cases with the introduction of Leveraged Liquidity Pool Zaps.

• DefiSnap, a simple dashboard that allows users to monitor all their DeFi assets in one single place, is launched.

February

• DeFiZap launches “Zap-Outs” a new feature that allows users to exit liquidity from Uniswap into a single asset.

• DefiSnap adds support to 15 new protocols and reaches the milestone of 1000 weekly active users.

April

• DeFiZap and DefiSnap join forces to form Zapper, combining DeFiZap’s seamless access to innovative investment opportunities with DefiSnap’s unified visual DeFi dashboard.

May

• As a result of the merge, Zapper.fi is launched on May 1st.

June

• The “Yield Farming” craze kicks in, and Zapper is a central hub to help farmers get access to the newest opportunities in DeFi.

July

• We announce a pre-seed round from Michael Dunworth and MetaCartel Ventures.

• Zapper volume reaches $100M.

August

• We announce our seed round, led by Framework Ventures and Libertus Capital, with participation from various prominent DeFi investors.

September

• At the height of the “Yield Farming” craze, Zapper registers more than 300,000 monthly active users monitoring their portfolios.

• The one and only DeFi Dad joins the team as the CDO (Chief DeFi Officer).

• We launch Zapper Exchange, an exchange aggregator that helps user’s find the best rates across DeFi without needing to leave Zapper.

October

• Yield TV is launched to help connect DeFi audiences with various projects and interesting builders in the space.

November

• Zapper announces a seed extension from Coinbase Ventures, Delphi Digital and Scalar Capital.

• Zapper adds Bitcoin Wallet support.

• We add 0x API to our Zapper Exchange, enabling more than 20 sources of liquidity.

December

• On December 25th, we officially reach the milestone of $1B in transaction volume!

Throughout all the year, we added about fifty new protocol integrations (we’ve lost count), as well as countless new investment opportunities (zaps) across Uniswap, Curve, Sushiswap, Yearn, Balancer and Bancor.

Moving forward

We’re extremely excited for what’s to come in 2021. Among updates we have planned for early 2021, we have a Bitcoin bridge to DeFi coming live to the Zapper dashboard, as well as a brand new mobile app.

Another effort we’re adding to 2021 is gearing Zapper towards community efforts, from streamlining protocol integrations to simple token additions. Zapper is the product of two grassroots driven efforts in DefiSnap and DeFiZap, and we are staunch believers in the community-oriented nature of DeFi.

And always, thank you for all the love and support! To 2021!

We’re excited to announce our team has raised an extension to our seed round from Coinbase Ventures and Delphi Ventures.

We are grateful to have both these funds onboard as investors in our continued mission to build the future of decentralized finance (DeFi) on Ethereum and make peer-to-peer finance applications accessible across the globe!

Coinbase Ventures invests in companies building the open financial system. We look forward to having their expertise onboard, having made countless investments over the years in teams we couldn’t imagine living without in the Ethereum community, such as Etherscan, Compound, The Graph, Matic, Audius, Instadapp, and more.

With Delphi Digital, we have one of the most advanced DeFi and cryptocurrency research and consulting firms in the world. Having recently launched Delphi Ventures, Delphi is now investing in DeFi related technologies like Zapper. Delphi Digital has educated countless institutional and retail investors on the technologies empowering the DeFi movement, and so we’re ecstatic to leverage their asymmetric insights and knowledge to continue building Zapper as a DeFi hub for millions of future users.

Join the Zapper community and DeFi revolution!

🤝 We host weekly Zapper Community call Fridays at 2 pm EST, as an open forum to ask questions about DeFi and Zaps, share ideas, and connect with our peers.

📢 Follow us on Twitter to get the latest Zapper updates and join over 5,000 members in our Zapper Discord to learn more about DeFi and learn from our community.

⚡ Track your DeFi portfolio, Zap into DeFi investments, and swap for the best rates and least slippage with Zapper Exchange, powered by the 0x API at Zapper.fi!

📺 Watch our daily DeFi livestream on Yield TV, as we interview the leading founders and builders and demonstrate live how to leverage DeFi!

And as always, thank you to the Zapper Community!