---
name: gomp
version: 1.0.0
description: Mint and burn GOMP on Base via an immutable Richards bonding curve. No team, no premine, no admin. Agents can also swap on the secondary Uniswap v4 pool.
homepage: https://gomp.sh
---

# gomp

a richards bonding curve token on base — a generalized-logistic S-curve in the gompertz family, tuned with the inflection at e=0 so the marginal price climbs monotonically over a 0-400 ETH operating range. supply is set by math; price moves with the reserve. mint to send ETH and receive GOMP at the current curve price; burn to return GOMP and pull ETH from the reserve (minus a time-decaying fee). no team, no admin, no upgrade path. the contract is the issuer.

- base url: https://gomp.sh
- raw skill: https://gomp.sh/skill.md
- whitepaper: https://gomp.sh/whitepaper
- source: https://github.com/sp0oby/gomp

## Network

This skill manifest points at **Base mainnet**.

| field | value |
|---|---|
| chainId | 8453 |
| Gomp (ERC-20) | `0x832555f5239E65D70f71dd7E9D2D8F7C4Bcc12af` |
| GompHook | `0xc95DA5E5f0565242E253f7a69F8Ec6342eb3e888` |
| GompSwapRouter | `0xfd2745ac27094F1D93f551AbD70E1dbf82FabF93` |
| Uniswap v4 PoolManager | `0x498581fF718922c3f8e6A244956aF099B2652b2b` |
| Genesis block | 46432468 |

## Actions

### mint — buy GOMP through the curve

Send ETH, receive freshly-minted GOMP at the current Richards-curve marginal price.

- contract: `GompSwapRouter`
- solidity:
  ```solidity
  function buy(
    PoolKey  calldata key,
    address           swapper,    // credited for cooldown tracking
    address           recipient,  // receives the minted GOMP
    uint256           minOut      // revert if gompOut < minOut
  ) external payable returns (uint256 gompOut);
  ```
- attach: `msg.value = ethIn`
- fee: 0.3% of `msg.value` retained by the hook forever
- cooldown: after a buy, the same `swapper` cannot sell for 1 block

PoolKey for mint (curve pool, with hook):
```
currency0:   0x0000000000000000000000000000000000000000
currency1:   0x832555f5239E65D70f71dd7E9D2D8F7C4Bcc12af
fee:         3000
tickSpacing: 60
hooks:       0xc95DA5E5f0565242E253f7a69F8Ec6342eb3e888
```

Pre-quote (no tx):
```solidity
function quoteBuy(uint256 ethIn)
  external view
  returns (uint256 fairGomp, uint256 fee, uint256 ethToCurve);
```

### burn — sell GOMP back to the curve

Approve the router for GOMP once, then call `sell`. The hook applies the inverse curve, subtracts a time-decaying fee, and pays ETH from the reserve.

- step 1: `Gomp.approve(router, amount)` — recommend `type(uint256).max` so future burns need no further approval
- step 2:
  ```solidity
  function sell(
    PoolKey  calldata key,
    address           swapper,    // checked against cooldown
    address           recipient,  // receives ETH
    uint256           gompIn,
    uint256           minOut      // revert if ethOut < minOut
  ) external returns (uint256 ethOut);
  ```
- fee: starts at **1.0%** in the same block as last buy, decays linearly to **0.3%** after 10,000 blocks (~5.5 hours on Base 2s blocks). hold longer → pay less to leave.
- cooldown: same 1-block cooldown after a buy

Pre-quote:
```solidity
function quoteSell(uint256 gompIn)
  external view
  returns (uint256 ethOut, uint256 fee, uint256 ethFromCurve);
```

### swap — trade on the secondary Uniswap v4 pool

Independent of the curve. A standard v4 pool (no hook) for GOMP/ETH spot trading. Use any v4-compatible router (Universal Router, etc.). The secondary pool is permissionless — anyone can initialize it and add liquidity; if no LP exists yet, swap is unavailable until someone does.

PoolKey for the secondary pool:
```
currency0:   0x0000000000000000000000000000000000000000
currency1:   0x832555f5239E65D70f71dd7E9D2D8F7C4Bcc12af
fee:         3000
tickSpacing: 60
hooks:       0x0000000000000000000000000000000000000000
```

The secondary pool's price can drift from the curve's marginal. Arbitrage opportunity: when the gap exceeds round-trip fees (mint 0.3% + sell 0.3% via swap, or vice versa), an agent can mint from the curve and sell on the pool — or buy on the pool and burn through the curve.

## Curve

Price comes from a Richards (generalized-logistic) sigmoid, normalized so S(0) = 0 and S(∞) = K:

```
R(e) = (1 + ν · exp(-α · (e - e_m)))^(-1/ν)
S(e) = K · (R(e) - R₀) / (1 - R₀)
```

Where:
- `K` (supply asymptote) = 21,000,000 tokens (never reached)
- `ν` (asymmetry) = 10 — values > 1 produce a long tail
- `α` (steepness, per ETH) = 0.02 — wide curve covering the 0-400 ETH range
- `e_m` (horizontal reference) = 0 ETH — inflection at the start; price rises monotonically
- `R₀` = R(0) — precomputed normalizer pinning S(0) = 0

### Phases an agent should know

Price is **monotonic** — every additional ETH into the reserve raises the marginal price. No pre-inflection dip, no lag-phase arbitrage zone.

| phase | reserve range | behavior |
|---|---|---|
| lag | 0 → 15 ETH | first 10% of K mints here. cheapest entry; price climbs slowly from the floor. |
| growth | 15 → 78 ETH | bulk minting. 10% → 50% of K. price 1× → 2× of start. |
| asymptotic | 78 → 186 ETH | 50% → 90% of K. price climbs 2× → 10× of start. |
| tail | 186+ ETH | last 10% of K. price ramps hard. ~300 ETH to reach 99% of K. |

**The lag phase is contrarian**: an agent buying at e = 0 pays more per GOMP than one buying at e = 5. Strategies assuming linear price-up from launch will misfire.

## Live state reads

All view functions on `GompHook`:

```solidity
function ethCum()           external view returns (uint256);  // cumulative ETH into the curve
function totalMintedFair()  external view returns (uint256);  // fair supply tracked by the curve
function feesAccrued()      external view returns (uint256);  // locked fees (unreachable)
function lastBuyBlock(address) external view returns (uint256);  // per-address cooldown anchor
function selfDeprecated()   external view returns (bool);     // true once the curve has retired
function curveReserveEth()  external view returns (uint256);  // ETH available for burns
function philosophy()       external view returns (string);   // on-chain manifesto
```

## Identity check

Before trading, agents should call `philosophy()` on the `GompHook` and verify the returned string contains the literal phrase **"on base, it"** — that confirms the canonical gomp deployment with the correct manifesto. Any deployment whose `philosophy()` differs is a fork or impostor.

## Caveats for agents

1. **Lag-phase pricing is non-monotonic** — don't assume "earlier = cheaper".
2. **Burn fees depend on per-wallet hold time** — track `lastBuyBlock(swapper)` per address, not per pool.
3. **1-block cooldown** between any buy and the same wallet's next sell. No flash mint-burn.
4. **Pool fee field is `3000` (= 0.30%)** for both the curve pool and the secondary pool. The `hooks` field differs and is what distinguishes them.
5. **Secondary pool may not exist yet** — the curve mint/burn always works. If no LP is in the secondary pool, agents should route through the curve only.

## ABIs

Drop-in viem / ethers fragments:

**GompSwapRouter**
```
function buy((address,address,uint24,int24,address),address,address,uint256) payable returns (uint256)
function sell((address,address,uint24,int24,address),address,address,uint256,uint256) returns (uint256)
```

**GompHook (view)**
```
function quoteBuy(uint256) view returns (uint256,uint256,uint256)
function quoteSell(uint256) view returns (uint256,uint256,uint256)
function ethCum() view returns (uint256)
function totalMintedFair() view returns (uint256)
function feesAccrued() view returns (uint256)
function lastBuyBlock(address) view returns (uint256)
function selfDeprecated() view returns (bool)
function philosophy() view returns (string)
```

**Gomp (ERC-20)**
```
function approve(address,uint256) returns (bool)
function balanceOf(address) view returns (uint256)
function allowance(address,address) view returns (uint256)
function transfer(address,uint256) returns (bool)
function totalSupply() view returns (uint256)
```

## License

MIT. Contracts are immutable. Frontend is open source: https://github.com/sp0oby/gomp