How Bear Pairs works

Introduction

Bear Pairs is a launchpad for inverse stock memecoins: tokens whose reference instrument is the daily inverse of a popular stock. When Tesla has a red day, the index value of shortTSLA has a green one. That is the whole idea. Every token on Bear Pairs lives and dies opposite to its underlying.

Each launch is one transaction. You pick a stock, and Bear Pairs deploys a fixed-supply ERC20, creates a PancakeSwap v2 pair for it against WBNB, seeds the entire supply plus half of your first buy as liquidity with the LP tokens burned forever, buys the token with the other half, and binds the token to its inverse pairing. From that moment the token trades like any other memecoin, while the pairing engine tracks the stock and renders the token's inverse index, tick for (inverse) tick.

The lifecycle of every Bear Pairs token:

1. Launch. One transaction deploys the token and its pool. The creator's first buy funds it: half seeds the liquidity pool alongside the full supply, half buys the token.
2. Pairing. The token is bound to its underlying at launch. The pairing is permanent and cannot be changed.
3. Tracking. The pairing engine consumes equity price oracle feeds and computes the token's inverse index: the daily-rebalanced inverse of the underlying, normalized to 100 at launch.
4. Trading. The token trades against BNB in its PancakeSwap v2 pool.
5. Resolution. Anyone can paste the contract address into Bear Pairs and see the exact pairing the token was launched with.

Core concepts

The pairing

A Bear Pairs token is paired by reference, not by custody. The pool never holds the stock, a stock derivative, or any claim on one. Instead, the token carries a declared, platform-anchored pairing: the pairing engine tracks the underlying stock and publishes the token's inverse index value next to its live pool price. Settlement always happens in BNB, on-chain. The pairing lives in the reference layer, where it is computed, displayed, and resolved for every CA lookup.

This separation is what makes inverse stock memecoins possible at all. No stock inventory, no custodied synthetics, no funded derivative pools. The memecoin trades freely in its own BNB pool while the pairing engine does the mirroring.

The inverse instrument

Every pairing is an inverse −1x instrument, rebalanced daily. If r_t is the underlying's return on day t (close-to-close), the inverse index V compounds like this:

V₀     = 100                     (normalized at launch)
Vₜ     = Vₜ₋₁ · (1 − rₜ)           (daily rebalance)
rₜ     = Sₜ / Sₜ₋₁ − 1             (underlying daily return, close-to-close)

Daily rebalancing means the inverse applies to each day's move rather than the cumulative move since launch. Over multiple days the index is path-dependent: a stock that goes +10% then −10% does not return the inverse index to 100.

Over those three days the stock is down 2.13% cumulatively, while the inverse index is up 1.87%. That is the daily-rebalanced inverse, not −1 × the cumulative return.

The pairing engine

The pairing engine is Bear Pairs' reference layer. It turns equity market data into the inverse index every token is paired to.

Oracle layer

Underlying prices come from multiple independent equity market-data providers. Feeds are medianized and sanity-bounded, so an outlier print beyond the deviation band is discarded before aggregation. The engine consumes official session closes for the daily return r_t and streams intraday reference prints for the live chart on each token page.

Market hours

Memecoins trade 24/7. Equities do not. The engine is market-hours aware:

• During the session, intraday reference prints update the live index value shown on token pages.
• At the close, the official close fixes r_t for that session and the daily-rebalanced index compounds once.
• Overnight, weekends, holidays, the index holds its last close-to-close value. A token's pool keeps trading regardless; the inverse index simply waits for the next session.

Corporate actions

Underlyings are adjusted for splits and dividends before returns are computed: a 5:1 split does not register as a −80% day (which would otherwise 5x the inverse index). Delistings and ticker changes finalize the index at the last authoritative print. The token and its pool are unaffected and keep trading.

Supported underlyings

Launching a token

Launching is a single call to the Launchpad contract. You pick an underlying and confirm the suggested name and ticker. By convention the inverse of TSLA is named “Short Tesla” with ticker shortTSLA. Both are editable. The pairing, once recorded, is not.

The launch transaction does five things atomically:

1. Deploys the token. A minimal ERC20, 18 decimals, fixed supply of 1,000,000,000 (1B) minted in full to the Launchpad. No mint function exists after construction; supply can never change.
2. Creates the pair. A WBNB / token pair on the PancakeSwap v2 factory, the standard pool shape every aggregator and wallet can read.
3. Seeds the liquidity. The entire 1B supply plus half of the first buy goes into the pool. The LP tokens are minted to 0x…dEaD: the liquidity is burned forever and can never be pulled.
4. Executes the first buy. The other half of the first buy swaps BNB for the token through the new pool, straight to the creator's wallet.
5. Records the pairing. The token address is bound to its underlying in the Launchpad, permanently.

Launching costs gas plus the first buy (minimum set by minInitialBuy). The Launchpad emits Launched(token, pair, creator, name, symbol, underlying), and the token page is live immediately.

Pool architecture

Every Bear Pairs token trades in a PancakeSwap v2 pool against WBNB on BNB Chain. The pool carries no stock exposure; that lives in the reference layer. Keeping the settlement layer plain and standard is what keeps it deep and safe.

The constant-product pool

The pool is the classic x · y = k market maker. Its price is the ratio of the two reserves, and every trade moves that ratio:

reserves         (W, T)  from pair.getReserves()   (WBNB, token)
price            P = W / T                       (BNB per token)
buy  (BNB → token):  W up, T down  →  P increases  →  token appreciates
sell (token → BNB):  T up, W down  →  P decreases  →  token depreciates

BNB in, BNB out

Pools pair against WBNB under the hood, but the router wraps and unwraps automatically: buyers send plain BNB and sellers receive plain BNB. No manual wrapping step anywhere in the flow.

Trading

Swaps route through the PancakeSwap v2 router, the canonical exact-input router every BNB Chain wallet and aggregator already knows. No exotic intermediaries.

swapExactETHForTokens(
  minOut,              // slippage bound: reverts below it
  [WBNB, token],       // path
  to,                  // output recipient
  deadline
)                      // payable: msg.value is the BNB in

swapExactTokensForETH(
  amountIn, minOut, [token, WBNB], to, deadline
)                      // sell side

• Buying. Call swapExactETHForTokens with msg.value = amountIn. The router wraps BNB to WBNB and delivers tokens to the recipient.
• Selling. Approve the router for the token amount, then call swapExactTokensForETH. BNB is paid out to the recipient.
• Slippage. minOut bounds execution, and the UI quotes off getAmountsOut with a 3% floor so the bound reflects real reserves.

Price impact follows the constant-product invariant: larger trades move further along x · y = k, and the pool's reserves bound how far any single trade can move the market.

Fees & economics

Because the LP position is burned, the liquidity share of every swap fee stays locked in the pool forever, so volume deepens the market instead of paying a rentier.

The pairing registry

The registry is Bear Pairs' resolution layer: it maps a token contract address to the pairing it was launched with. Paste any CA into Bear Pairs and the registry answers with the exact inverse pairing (underlying, instrument type, name, ticker, creator, launch transaction), or with no_pairing if the address was never launched on Bear Pairs.

Lookups are case-insensitive, so checksummed and lowercase CAs resolve identically. Records are keyed by {chainId}:{address} and immutable: a duplicate registration returns 409 already_registered with the original record.

API

TokenRecord

{
  "address":    "0x…",            // token contract (the CA)
  "chainId":    56,
  "underlying": "TSLA",           // one of the supported underlyings
  "type":       "inverse",        // Bear Pairs pairings are inverse −1x
  "name":       "Short Tesla",
  "symbol":     "shortTSLA",
  "creator":    "0x…",
  "txHash":     "0x…",            // the launch transaction
  "launchedAt": 1788719195612
}

Trust & transparency model

Bear Pairs is explicit about which guarantees are enforced by the chain and which are provided by the reference layer.

Enforced on-chain

• Provenance. Every Bear Pairs token and its pair are created by the Launchpad in one transaction, and the Launched event records them together.
• Supply and liquidity. 1B fixed supply, 100% seeded to the pool at launch, LP tokens burned to 0x…dEaD, no mint function, no hidden allocation.
• Settlement. Every trade settles in BNB via PancakeSwap v2 with atomic settlement semantics.
• Fees. The swap fee is a property of the DEX pool, not of the platform UI.

Provided by the reference layer

• The pairing. The binding of a CA to its inverse underlying is declared at launch and is immutable thereafter.
• The inverse index. Computed by the pairing engine from oracle closes and rendered on each token page, next to the live pool price.

Contract reference

Launchpad

launch(string name, string symbol, string underlying) payable
                   → (address token, address pair)
setMinInitialBuy(uint256)                // owner
pairOf(token) → address
creatorOf(token) → address
getLaunchedTokens() → address[]
underlyingOf(token) → string             // the stock each token shorts
allTokensLength() → uint256

constants: TOTAL_SUPPLY = 1e9·10¹⁸ · LP_BURN = 0x…dEaD · minInitialBuy (owner-tunable)

Events

Pool identity

pair  = Factory.getPair(token, WBNB)   // CREATE2, deterministic
price = wbnbReserve / tokenReserve     // both sides 18 decimals

FAQ

Is a Bear Pairs token backed by the stock?

No. It is paired by reference. The token's identity is the daily inverse of its underlying, computed and displayed by the pairing engine, while the token itself trades and settles in BNB in its PancakeSwap v2 pool.

What happens when the market is closed?

The pool keeps trading around the clock. The inverse index holds its last close-to-close value until the next session, then compounds the new daily return at the official close.

Can a pairing be changed after launch?

No. The pairing is recorded once at launch and duplicates are rejected. A token launched as shortTSLA is the inverse of Tesla forever.

What happens if the underlying is delisted?

The pairing engine finalizes the index at the last authoritative close. The token and its pool are unaffected and keep trading.

Does Bear Pairs take a fee?

No. The only fee on a trade is the DEX's 0.25% swap fee, and its liquidity share stays locked in the burned LP position forever.

Who can launch?

Anyone, gas plus the first buy. One transaction deploys the token, creates the pair, seeds and burns the liquidity, and records the pairing.