Skip to main content

Glossary

A reference for the terms used across these docs and in the contract code.

Auction​

A single sealed-bid lot for licensing one IP. Created by a seller, accepting bids from anyone until a fixed deadline.

auctionId​

A uint256 identifier assigned by the SealedAuction contract when an auction is created. Monotonically increasing from 1.

AuctionRevealCondition​

A SealedIP contract that gates CDR validator share publishing. Returns true for a uuid only when both conditions are true simultaneously:

  1. block.timestamp >= auction.deadline
  2. SealedAuction.isTriggered(auctionId) == true

This replaced the earlier time-only approach. Both bid vaults and the seller's reserveUuid vault are registered on this contract. CDR validators call checkReadCondition(uint32 uuid, bytes, bytes, address) view returns (bool) before contributing a decryption share.

Bid​

A commitment to pay a specific amount in WIP for the license terms attached to an IP. Submitted as an encrypted payload during the auction's open phase.

bidIndex​

A uint256 index within an auction identifying a specific bid slot. Ranges from 0 to bidCount - 1.

BidPayload​

A 149-byte plaintext structure committed inside each TDH2 ciphertext: address bidder (20 bytes) || uint256 amount (32) || bytes32 nonce (32) || bytes65 signature. The inner digest is keccak256(abi.encode(auctionId, signer, amount, nonce)); the signed hash uses the Ethereum personal-sign prefix. The same structure is used for both bids (signer = bidder) and the seller's sealed reserve (signer = seller).

BidReveal​

A struct passed to settle() representing one decrypted bid: { uint256 bidIndex; uint256 amount; bytes32 nonce; bytes signature }.

bidSlot​

The contract's escrow record for one bid: the bidder's address, deposit amount, ciphertext uuid, and whether ciphertext has been written.

CDR​

Confidential Data Rails — the threshold-decryption network operated by piplabs. The on-chain contract is at 0xCCCcCC0000000000000000000000000000000005.

Ciphertext​

The TDH2-encrypted bytes representing a payload (bid or reserve). Stored on-chain in the CDR contract; decryptable only by a quorum of CDR validators after the AuctionRevealCondition passes.

ciphertextUuid​

A unique identifier issued by CDR for each ciphertext. Bound to the auction's AuctionRevealCondition so it can only be decrypted after both the deadline passes and the auction is triggered.

Deadline​

A unix timestamp past which the auction stops accepting bids and can be triggered. Immutable after createAuction.

Deposit​

The amount of WIP a bidder escrows when allocating a slot. Acts as the upper bound on the bid: the contract enforces bid.amount ≤ deposit at settle.

ERC-6551​

The token-bound-account standard. Story Protocol's IP accounts are ERC-6551 accounts owned by their bound NFT.

IP​

Intellectual property registered on Story Protocol. Represented on-chain as an ERC-6551 account address.

ipId​

The address of an IP account. Sometimes called "IP id" in documentation.

License terms​

A bundle of PIL fields (commercial use, derivatives, royalty, transferability, etc.) that grant specific rights to the holder of a license token.

licenseTermsId​

A uint256 identifier for a registered PIL terms struct. Story's PILicenseTemplate assigns these.

License token​

An ERC-721 NFT representing one grant of license terms over one IP. Minted to the auction winner at settlement.

LicenseRegistry​

Story Protocol contract storing the (IP → attached terms) mapping. Source of truth for "which terms are attached to which IP".

LicensingModule​

Story Protocol contract that performs term attachment and license token minting. Called by SealedAuction at settle.

Orchestrator​

The off-chain service that reads CDR plaintext after a trigger and submits the BidReveal[] array and ReserveReveal to SealedAuction.settle. The SealedIP-operated orchestrator is the default but anyone can run one.

PIL​

Programmable IP License — Story Protocol's standard for expressing IP license terms as on-chain data.

PILicenseTemplate​

The Story Protocol contract that registers PIL terms structs and mints license tokens.

Reserve price​

See Sealed reserve. The term "reserve price" in the SealedIP contract refers to the amount revealed at settle. There is no plaintext reservePrice field in the auction struct.

ReserveReveal​

A struct passed to settle() representing the decrypted seller reserve: { uint256 amount; bytes32 nonce; bytes signature }. The contract recovers the signer from the signature and verifies it matches the auction's seller address. Reverts with InvalidReserveReveal if the signer doesn't match. If no reserve was sealed, the orchestrator passes a zero-amount reveal.

reserveUuid​

The CDR ciphertext uuid allocated for the seller's encrypted reserve. Assigned by CDR.allocate during createAuction and registered on AuctionRevealCondition alongside the bid vaults. Stored in the auction struct alongside the reserveHasCiphertext flag.

Reveal​

A decrypted payload. Constructed off-chain by the orchestrator from CDR plaintext and passed to SealedAuction.settle. See also BidReveal and ReserveReveal.

Royalty policy​

A Story Protocol contract that routes commercial revenue from a derivative back to its upstream IPs. SealedIP's commercial presets use RoyaltyPolicyLAP.

Sealed bid​

A bid whose amount is encrypted under the CDR threshold key and committed on-chain. Sealed bids are unreadable until the auction deadline passes, the auction is triggered, and validators publish their decryption shares.

Sealed reserve​

The seller's minimum acceptable bid amount, encrypted into its own CDR vault (identified by reserveUuid). The reserve is not visible to bidders before settlement — it shows as "Sealed" in the UI. The reserve is revealed alongside all bids in the settle() transaction. This is the other half of two-sided sealing.

SealedAuction​

The core SealedIP contract. The state machine that tracks every auction, every bid slot, and every settlement.

Settle / settlement​

The atomic close-out transaction. License mints, payment goes to the seller, overpayment is refunded to the winner, and every losing deposit is refunded. All of this happens in one transaction or not at all.

SPGNFT​

A Story Periphery (SPG) NFT collection. SealedIP mints new IPs into the shared SPGNFT collection.

State​

The on-chain enum value of an auction: Open (0), Triggered (1), Settled (2), ExpiredNoWinner (3), or ExpiredEmpty (4). See State machine.

Story Protocol​

The IP registration and licensing protocol SealedIP builds on. Deployed on Aeneid testnet at chain id 1315. See docs.story.foundation.

Story Periphery (SPG)​

Story Protocol's set of helper contracts that bundle multi-step operations (mint NFT + register IP, attach terms, etc.) into single calls. SealedIP uses SPG in the mint-and-list flow.

TDH2​

Threshold Cramer-Shoup, a threshold variant of public-key encryption. The cryptographic scheme CDR uses for bid and reserve encryption.

Threshold cryptography​

A cryptographic primitive where the decryption key is split across n parties, with at least t of them required to decrypt anything. SealedIP uses TDH2 via CDR for both bids and the seller reserve.

Trigger​

The transition from Open to Triggered. Anyone can call SealedAuction.trigger(auctionId) after the deadline. Triggering is the second gate (alongside the deadline) that opens the AuctionRevealCondition and allows CDR validators to start publishing shares.

Two-sided sealing​

The property that BOTH the bidder's bid amount AND the seller's reserve price are encrypted before the auction runs and only revealed at settle. Bidders don't see the floor; the seller doesn't see the bids. This prevents strategic anchoring from either direction.

Validator​

A node in the CDR threshold network. Holds one share of the threshold decryption key. Publishes partial decryptions when a read condition is satisfied.

WIP​

Wrapped IP — the ERC-20 wrapping Story Aeneid's native IP token. Used for all SealedIP deposits and payouts. Address: 0x1514000000000000000000000000000000000000.

uuid (in CDR context)​

A unique identifier issued by CDR for each ciphertext, bound to a read condition. See ciphertextUuid and reserveUuid above.