Uniscribe — UNI-20 Inscriptions on Uniswap v4

deploy.json

mint.json

transfer.json

hookData payload

$ cat deploy.json
// Register a new UNI-20 ticker
{
  "p":    "uni-20",
  "op":   "deploy",
  "tick": "UNIS",
  "max":  "21000000",
  "lim":  "1000"
}
$ uniscribe inscribe ./deploy.json
// → Inscription #1 · ticker UNIS deployed (max 21M, per-mint 1k)

$ cat mint.json
// Claim 1,000 UNIS from the cap
{
  "p":    "uni-20",
  "op":   "mint",
  "tick": "UNIS",
  "amt":  "1000"
}
$ uniscribe inscribe ./mint.json
// → Inscription #2 · 1,000 UNIS minted to 0xRyZ...eN

$ cat transfer.json
// Move 500 UNIS to another address
{
  "p":    "uni-20",
  "op":   "transfer",
  "tick": "UNIS",
  "amt":  "500",
  "to":   "0xabc0000000000000000000000000000000000123"
}
$ uniscribe inscribe ./transfer.json
// → Inscription #3 · 500 UNIS sent to 0xabc...0123 (no fee)

// Protocol

An open standard for on-chain inscriptions.

UNI-20 borrows what worked about BRC-20 — a declarative, indexable format — and grounds it in EVM-native accounting. Three operations. One hook. Predictable settlement.

Native to Uniswap v4

Inscriptions ride inside the swap you were going to execute. No additional transaction surface, no separate venue to maintain.

Declarative payloads

Three verbs — deploy, mint, transfer — encoded as compact JSON, parsed strictly on-chain.

On-chain accounting

Tickers, supply caps, per-mint limits, and balances live in contract storage. Off-chain indexers are a convenience, not a dependency.

Anti-spam by design

A minimal protocol fee on deploy and mint protects the namespace and routes value to a transparent treasury.

Indexer-friendly

Every op emits a structured Inscription event with the raw payload — drop-in for The Graph, Ponder, Goldsky, or in-house ETL.

Permissionless & ossifiable

MIT-licensed reference. The standard can ossify; applications can innovate at the edges.

// Architecture

One contract. Two entrypoints.

Uniscribe is a single Solidity contract that doubles as a Uniswap v4 BaseHook and as a standalone inscription registry. The v4 path is the canonical integration; the direct path keeps the protocol usable in any environment that can call a contract.

Strict JSON parser implemented in pure Solidity over calldata — no nested objects, no escape sequences.
Atomic settlement — every op completes in the same transaction as the swap that carried it.
Typed events (Inscription, Mint, Transfer, TickerDeployed).
Custom errors for clean reverts — no silent inscriptions.

Uniscribe.sol — beforeSwap

function beforeSwap(
    address sender,
    PoolKey calldata key,
    SwapParams calldata params,
    bytes calldata hookData
) external override onlyPoolManager
  returns (bytes4, int256, uint24)
{
    if (hookData.length > 0) {
        _processInscription(sender, hookData);
    }
    return (BEFORE_SWAP_SELECTOR, 0, 0);
}

// Specification

Three verbs. Strict semantics.

Every UNI-20 payload is a flat JSON object. Numeric fields are quoted strings to preserve 256-bit precision. Unknown keys are ignored for forward-compatibility.

deploy

Register a new ticker

{
  "p":    "uni-20",
  "op":   "deploy",
  "tick": "UNIS",
  "max":  "21000000",
  "lim":  "1000"
}

mint

Claim from the cap

{
  "p":    "uni-20",
  "op":   "mint",
  "tick": "UNIS",
  "amt":  "1000"
}

transfer

Move a balance

{
  "p":    "uni-20",
  "op":   "transfer",
  "tick": "UNIS",
  "amt":  "500",
  "to":   "0xabc...123"
}

event

What indexers consume

event Inscription(
  uint64  indexed inscriptionNo,
  address indexed from,
  bytes32 indexed tick,
  string           op,
  uint256          amount,
  address          to,
  bytes            raw
);

Inscribe tokens through
Uniswap v4 hooks.