How SOCLE works.

Overview

SOCLE is a liquidity rental market for Montra tokens on Elysium. A project rents HYPE depth just below its token's price for a set term. LPs provide that depth with their own Uniswap v4 positions in the token's Montra pool and are paid rent in HYPE every hour by the project.

SOCLE has no contract and no wallet that holds funds. The server reads chain data, builds each transaction, runs a guard over its calldata and simulates it from your address. Your wallet signs. Every listing and payment carries a short tag in its calldata, which is how SOCLE finds and checks them on chain without a database.

Listing a token

A project lists its Montra token from List a token. It sets:

• Depth: the HYPE it wants resting below the price, from 1 to 100,000 HYPE.
• Band: how far below the price a position may sit and still count, from 2% to 60%.
• Rate: the yearly rent rate on each LP's counted HYPE, from 1% to 1000%.
• Term: 1 to 90 days.
• Guard floor: a price at or below the bottom of the band. See the price guard.

The listing is one plain HYPE transfer of the 0.1 HYPE listing fee to the SOCLE treasury, with the terms written into its calldata as socle:v1:post: followed by JSON. The socle's id is that transaction's hash. SOCLE serves Montra tokens paired with native HYPE whose pools accept outside liquidity.

Joining as an LP

An LP opens a HYPE only position through Uniswap's official v4 PositionManager, in the token's own Montra pool, from just below the current price down to the bottom of the band. SOCLE computes the range and the exact liquidity, simulates the mint from the LP's address and shows what leaves the wallet. Leftover HYPE returns in the same transaction.

The position NFT goes to the LP's wallet. Only the LP can add to it, collect from it or close it. The smallest position that earns rent holds 0.05 HYPE.

Positions count toward the target in the order they joined. Once the target is full, later positions still show on the socle but earn nothing until room opens.

Rent, every hour

Rent accrues per whole minute on each eligible position's counted HYPE: rent = counted × rate × seconds ÷ (10,000 × 31,536,000), rounded down. Every 60 minutes the project signs one Multicall3 aggregate3Value batch that pays every eligible LP their rent in native HYPE, plus 10% on top to the SOCLE treasury, in the same transaction.

Rent is paid by the project, not escrowed. An LP trusts the project for at most about one hour of rent, and can leave at any time. Each batch names the positions it pays and the minute it pays through, so the socle page shows a paid through mark for every LP.

The price guard

Uniswap v4 pools have no built in price history, so SOCLE builds one from the pool's swap records: a time weighted price over the last 20 minutes. The guard trips when that whole window is covered and most of it sat below the project's floor.

When it trips, joining pauses and every LP sees an alert with a one click exit on the socle page and in their portfolio. The guard never moves funds by itself. It watches from the moment of listing but can trip only after one full window has passed.

Flags and late projects

• Late: when the oldest unpaid rent is more than one hour plus a 15 minute grace old, the socle is marked late, with the number of missed hours, for everyone to see. Paying catches up and clears it.
• Pulled out: an LP who removes liquidity during the term stops earning from that moment and the position is marked as pulled out.
• Not counted: positions outside the band, below the minimum, opened after the term or past the target show the plain reason they earn nothing.

Fees and the LP line

Projects pay 0.1 HYPE once to list and 10% on top of the rent they pay. LPs pay SOCLE nothing.

Montra switches on trading fees for outside LPs only once a token passes its LP line. Until then, an LP position in a Montra pool earns no trading fees, so rent is the whole return. Every socle shows whether its pool has LP fees on.

When a socle stands

A socle ends at its term, or earlier if the project ends it. SOCLE also tracks the organic depth in the band (everything that is not rented here) against the depth at listing. When organic depth has grown by the whole target, the socle is marked as standing alone: the price has a base without rented help.

Wallets and RPC

Any EVM wallet works with Elysium (chain id 99901). If you added Elysium through Montra, your wallet may be using Montra's RPC, which only carries Montra trades and refuses Uniswap positions and Multicall3 batches. SOCLE detects it when you connect and offers a one click switch to the public RPC, https://rpc.elysium.kinetiq.xyz.

Risks

• Price risk: if the price falls into your range, part of your HYPE becomes the token. There is no loss cover.
• Payment risk: rent is paid by the project each hour, not held in escrow. A project can stop paying; it is then marked late.
• Chain risk: Elysium is a young network with a single sequencer.

Contracts used

SOCLE deploys nothing. It only builds calls to these existing contracts on Elysium:

• Uniswap v4 PositionManager 0x1d1C51b9d07fD27d36412A2b66CC23D19Eb3E518
• Uniswap v4 StateView 0x27eD73aE0652fdCf71d6793412A7525f32bE9dfE
• Multicall3 0xcA11bde05977b3631167028862bE2a173976CA11
• Montra registry 0xF1E2FA75422F889e565F3142bdbf60B28dce2aa7 (Montra's hook, pool manager and router are read from it)

API basics

JSON over HTTPS, no key. Amounts are exact wei as decimal strings; prices are token prices in HYPE. Read routes are limited to 120 requests a minute per IP, builders to 30. Errors come back as { "error": "…" } with a 4xx or 503 status.

Read routes

A listing

The shape of GET /api/listings/{id}, abridged:

{
  "id": "0x<listing tx hash>",
  "project": "0x…",
  "pool": { "poolId": "0x…", "token": "0x…", "symbol": "…", "lpFeeActive": false },
  "terms": { "target": "<wei>", "bandBps": 2000, "rateBps": 10000, "end": 1794000000, "floorPrice": 0.0000026 },
  "phase": "open | late | tripped | turned | ended",
  "canJoin": true,
  "joinRange": [tickLower, tickUpper],
  "spot": { "tick": 0, "price": 0.0000032 },
  "depth": { "segments": [{ "price": 0.0000031, "wei": "<wei>", "rented": "<wei>" }], "total": "<wei>", "rented": "<wei>" },
  "positions": [{ "tokenId": "…", "owner": "0x…", "counted": "<wei>", "eligible": true, "flagged": false, "paidThrough": 1794000000, "owed": "<wei>" }],
  "rent": { "payments": [{ "tx": "0x…", "through": 1794000000, "total": "<wei>" }], "owedTotal": "<wei>", "late": false, "missedEpochs": 0 },
  "guard": { "tripped": false, "warming": false, "belowSecs": 0, "window": 1200, "meanD": 0, "spotBelow": false }
}

Transaction builders

POST /api/build/{action} with a JSON body. Each builder validates against chain state, runs the transaction guard (only the PositionManager, Multicall3 and the treasury are reachable; HYPE can only go to your own position, declared LPs or the treasury), simulates from the signer and returns the unsigned transaction with a preview. Positions accept from 0.05 HYPE.

{ "project": "0x…", "pool": "0x<pool id>", "targetHype": 10, "bandBps": 2000, "rateBps": 10000, "termDays": 7, "floorBps": 3000 }

{ "lp": "0x…", "listing": "0x<listing id>", "amount": "1.5" }

{ "lp": "0x…", "listing": "0x…", "tokenId": "1234", "amount": "0.5" }

{ "lp": "0x…", "tokenId": "1234" }

{ "lp": "0x…", "tokenId": "1234" }

{ "project": "0x…", "listing": "0x…" }

{ "project": "0x…", "listing": "0x…" }

curl https://<host>/api/build/join \
  -H "content-type: application/json" \
  -d '{"lp":"0xYourAddress","listing":"0xListingId","amount":"1"}'

What a builder returns

{
  "chainId": 99901,
  "to": "0x…",
  "data": "0x…",
  "value": "<wei>",
  "gas": "<gas limit>",
  "label": "Open a position in …",
  "lines": [{ "label": "HYPE into your own position", "wei": "<wei>" }],
  "hypeOut": "<wei, value plus network fee at most>",
  "networkFee": "<wei>"
}

Send to, data, value and gas from the signer's wallet on chain 99901 through the public Elysium RPC.

On chain tag format

Every SOCLE transaction that matters carries one UTF 8 tag at the end of its calldata. A listing's calldata is the whole tag; a rent batch appends it after the ABI encoded Multicall3 call, which Solidity ignores.

socle:v1:post:{"pool":"0x…","token":"0x…","target":"<wei>","band":2000,"rate":10000,"end":<unix>,"open":<tick>,"floor":<tick>,"base":"<wei>"}

socle:v1:rent:<listing id>:<paid through, unix>:<tokenId>=<liquidity>,<tokenId>=<liquidity>

socle:v1:end:<listing id>

• target, base: wei strings. band, rate: basis points.
• open, floor: depth ticks (pool ticks measured downward in price from the listing).
• A rent tag names 1 to 40 positions, one per payment leg, and the minute it pays through.

How tags are verified

A tag is never trusted alone. SOCLE finds candidates through the explorer's transaction list for the treasury and re-reads each transaction and receipt over RPC. A listing counts only if it succeeded, paid the treasury at least the listing fee and carries valid JSON. A rent batch counts only if it succeeded, came from the listing's project, names one position per payment leg and pays the treasury its share. LP positions are found from the pool's own liquidity events and their owners read from the PositionManager.