Story.foundation Anchor

[steven-tomlinson]

Goal: Make “Story” a first-class Anchor for Lockb0x so a Codex Entry (CE) can (a) register on Story as IP, (b) attach a PIL license, (c) maintain bidirectional provenance links, and (d) verify on-chain with low friction.

Why Story?
   •   Purpose-built IP L1: fast traversal of IP graphs (derivatives, remixes) + native PoC. 
   •   Programmable IP License (PIL): machine-readable terms that pair well with Lockb0x’s CE rights metadata. 
   •   EVM-equivalent: we can reuse our EVM anchor patterns and infra (Alchemy/QuickNode RPC, JSON-RPC, logs). 
   •   Whitepaper alignment: universal ledger of creative/scientific assets with composable interface for apps/AI. 

Architecture mapping (Lockb0x ↔ Story)
   •   Codex Entry (CE) → Story IP NFT
CE’s asset.integrity (ni-URI over the content hash) maps to the NFT’s on-chain metadata CID; CE’s provenance maps to Story’s PoC lineage edges (parents/derivatives). 
   •   CE license → PIL instance
CE continues to carry human-/machine-readable license fields; the Story side mints/attaches the chosen PIL flavor and returns on-chain license refs we embed in CE anchors[].evidence. 
   •   CE anchors[] → Story Anchor
New type: "story" anchor records network (aeneid/mainnet), contract, tokenId, tx, block, and a mirror pointer to the PIL. Quick verification uses RPC providers (Alchemy/QuickNode). 

Minimal Viable Path (MVP)
1. Register CE on IPFS (unchanged): produce content hash and ni-URI.
2. Mint Story IP: deploy or use canonical IP contract; mint NFT with metadata URI → IPFS CID; attach PIL. 
3. Write back the Anchor into CE: include tx hash, block, chainId, contract, tokenId, PIL id/url.
4. Verifier: given a CE, resolve Story anchor → fetch tokenURI, fetch metadata CID, hash content → match CE ni-URI; verify PIL binding and (optionally) PoC lineage.

Implementation plan (phased)

Phase 1 — Foundations (1–2 days of coding)
   •   Adapter SDK (@lockb0x/anchor-story):
      •   register({ niUri, metadataCid, pilTemplate, pilParams }) -> {tx, tokenId, contract, network}
      •   verify(ce) -> {ok, failures[], details}
      •   JSON-RPC providers pluggable; default to Alchemy/QuickNode Story endpoints. 
   •   Schema extension (see diff below): add "story" anchor type.
   •   CLI: lbx story register / lbx story verify.

Phase 2 — Licensing integration (PIL)
   •   PIL selector: map common CE license intents (commercial remix allowed? share-alike?) to Story PIL flavors; persist chosen flavor + parameters both on-chain and in CE. 

Phase 3 — Proof-of-Creativity (PoC) lineage
   •   Add optional inputs to declare parents/origins when minting; write PoC edges; mirror edge refs into CE provenance.links[]. 

Phase 4 — Derivative/Remix flows
   •   Fork & Derive command: given a parent CE, create a derived Story IP with PIL-compliant terms; auto-populate CE provenance and Story PoC graph. 

Spec changes (target: appendix-b-schema + anchoring.md)

Anchors array: add story type.

--- a/spec/appendix-b-schema.json
+++ b/spec/appendix-b-schema.json
@@ -120,6 +120,36 @@
"type": "object",
"required": ["type"],
"properties": {

•        "type": { "enum": ["stellar", "evm", "ipns", "dns", "timestamp-authority"] }
  

•        "type": { "enum": ["stellar", "evm", "ipns", "dns", "timestamp-authority", "story"] }
       }
     }
   ]
  

  }

--- a/spec/anchoring.md
+++ b/spec/anchoring.md
@@ -210,6 +210,54 @@

EVM Anchor

(unchanged)

+### Story Anchor
+Overview. The Story Network is an EVM-equivalent L1 optimized for IP graphs and programmable licensing (PIL). A Story Anchor binds a Codex Entry (CE) to a Story IP NFT and—optionally—a PIL instance.
+
+Fields.
+```jsonc
+{

• "type": "story",
• "network": "aeneid|mainnet",
• "chainId": 1513, // example
• "contract": "0x...IPContract",
• "tokenId": "12345",
• "tx": "0x...mintTx",
• "block": 1234567,
• "pil": { "id": "pil://v1/flavor/xyz", "url": "https://docs.story.foundation/..." },
• "evidence": [
• {"type":"json-rpc","url":"https://story-mainnet.g.alchemy.com/v2/{KEY}"},
• {"type":"json-rpc","url":"wss://story-mainnet.quiknode.pro/{KEY}"}
• ]
  +}
  +```

+Verification.
+1. Resolve contract/tokenId → tokenURI via JSON-RPC.
+2. Fetch tokenURI → IPFS CID; recompute ni-URI and compare to CE asset.integrity.
+3. If pil present, fetch license doc; ensure flavor/parameters are compliant with CE license.
+4. (Optional) Traverse PoC lineage to validate declared provenance.

Example Codex Entry (excerpt)

(abbreviated for clarity; conforms to ni-URI rule and required fields)

{
"version": "0.0.2",
"asset": {
"name": "example.txt",
"integrity": "ni:///sha-256;A1B2C3...=="
},
"license": { "intent": "remix-allowed-noncommercial-sharealike" },
"provenance": { "created": "2025-10-08T19:12:00Z" },
"anchors": [
{
"type": "story",
"network": "mainnet",
"chainId": 1513,
"contract": "0xIPContract...",
"tokenId": "90210",
"tx": "0xMintHash...",
"block": 1234567,
"pil": { "id": "pil://v1/cc-by-sa-nc", "url": "https://docs.story.foundation/..." },
"evidence": [
{"type":"json-rpc","url":"https://story-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}"}
]
}
]
}

Developer tasks

SDK (@lockb0x/anchor-story)
   •   StoryProvider: wraps Alchemy/QuickNode endpoints (Aeneid testnet + Mainnet). 
   •   mintIp({metadataCid, pil}) → returns {tx, tokenId, contract, block}.
   •   bindPil(tokenId, pilFlavor, params) if separate. 
   •   verifyFromCE(ce) → strict checks (ni-URI match, tokenURI match, optional PoC lineage traversal).

Contracts
   •   Prefer canonical Story IP contract if the ecosystem has one; otherwise ship a minimal ERC-721 with metadata frozen to the CE CID + PIL pointer (upgradeable proxies optional). (Docs indicate EVM-equivalence; 721/6551 patterns are supported.) 

CLI
   •   lbx story:mint --ce ./entry.json --pil pil://v1/cc-by-sa-nc --network aeneid
   •   lbx story:verify --ce ./entry.json --rpc https://...

Testnet & Ops
   •   Start on Aeneid (Story testnet), then flip to Mainnet; set up RPC fallbacks and rate-limit handling. 

Verification algorithm (concise)
1. Parse CE → locate "type":"story" anchor.
2. eth_call tokenURI(tokenId) on contract via Story RPC. 
3. Resolve tokenURI (IPFS): compute SHA-256 → encode ni-URI; compare to CE asset.integrity.
4. If pil: fetch license doc; compare flavor/params against CE license policy matrix from signatures.md/rights.md (local rules). 
5. Optional: read PoC edges to confirm declared parents in CE provenance. 

Risk & compliance notes
   •   Deletions / immutability: Even if a Story token were burned, CE retains IPFS ni-URI + other anchors (multi-anchor guidance remains valid). (Your earlier “what if GDrive is deleted?” concern applies here too—redundancy via multiple anchors is recommended.)
   •   Licensing authority: PIL reduces ambiguity but you should continue to keep a human-readable rights doc hashed and pinned (CE embeds both). 
   •   Ecosystem maturity: Story launched whitepaper and network in 2024/2025; toolchains are growing (Alchemy/QuickNode support), but expect changes—keep adapter version-gated. 

References (key docs)
   •   Story docs (Intro, PIL, PoC, architecture). 
   •   Story Network overview (EVM-equivalent, graph exec layer). 
   •   Vision blog (provenance, licensing, remixing). 
   •   Whitepaper (universal ledger, composable interface). 
   •   RPC support: Alchemy & QuickNode for Story. 

⸻

If you want, I can generate a small reference repo (lockb0x-anchor-story/) with the adapter, a minimal 721 contract, and two lbx CLI commands wired to Aeneid so you can mint + verify a demo CE in under 10 minutes.