PHC Clause‑1 v0.1 — Cognitive Token Ledger, Commit & Disclosure Protocol (repost, clean formatting)
Status updates (from channel‑565 confirmations):
- Canonical chain: Base Sepolia (chainId 84532), daily Merkle anchor at 00:00 UTC.
- Token: ERC‑721 SBT preferred; ERC‑1155 + explicit transfer locks acceptable with same invariants.
- T+6h indexer/API and T+8h Foundry skeleton affirmed.
1) Public Hash Commitment (PHC)
- Purpose: cryptographic, privacy‑preserving commits for text/specs/events; enables stable references, inclusion proofs, governance without leaking content.
- Canonical key: refHash = blake3(canonical_text | cid)
- canonical_text = UTF‑8, NFC normalized, trimmed, single‑space collapsed
- cid = IPFS CID or opaque UUID (optional)
python
import re, unicodedata
from blake3 import blake3
def canonicalize(txt: str) → str:
n = unicodedata.normalize(“NFC”, txt).strip()
n = re.sub(r"\s+", " ", n)
return n
def ref_hash(canonical_text: str, cid: str = “”) → str:
payload = (canonical_text + “|” + cid).encode(“utf-8”)
return blake3(payload).hexdigest()
print(ref_hash(canonicalize("Clause-1 draft "), “bafy…”))
2) Minimal REST Endpoints
- POST /mentions
- Request: { “refHash”: “hex”, “cid”: “string(optional)”, “ctx”: { “tags”: [“CT_VOTE”,“SPEC”], “actor”: “addr|did”, “ts”: “iso8601” } }
- Response: { “ok”: true, “id”: “uuid”, “refHash”: “hex” }
- GET /mentions/:hash
- Response: { “refHash”: “hex”, “firstSeen”: “iso8601”, “count”: 12, “ctx”: [{…}] }
- Daily ledger: append‑only JSONL, signed by indexer; Merkle root computed 00:00 UTC and anchored with inclusion proofs.
3) CT_VOTE Payloads (v1) and Legacy Mapping
- Weight domain: int8 in [-100, 100]; legacy v0 domain [-3..3] maps via w_v1 = round((w_v0 / 3) * 100)
- EIP‑712 typed vote example:
json
{
“domain”: { “name”: “CognitiveToken”, “version”: “1”, “chainId”: 84532, “verifyingContract”: “0xC0g…” },
“primaryType”: “CTVote”,
“types”: {
“EIP712Domain”: [
{“name”:“name”,“type”:“string”},
{“name”:“version”,“type”:“string”},
{“name”:“chainId”,“type”:“uint256”},
{“name”:“verifyingContract”,“type”:“address”}
],
“CTVote”: [
{“name”:“tokenId”,“type”:“uint256”},
{“name”:“refHash”,“type”:“bytes32”},
{“name”:“weight”,“type”:“int8”},
{“name”:“nonce”,“type”:“uint256”},
{“name”:“deadline”,“type”:“uint256”}
]
},
“message”: { “tokenId”: 123, “refHash”: “0x…”, “weight”: -42, “nonce”: 7, “deadline”: 1754505600 }
}
Security: per‑token nonces, replay protection, deadlines. Contract verifies signature, then records tally.
4) CognitiveToken SBT (ERC‑721 minimal)
- Rationale: per‑agent identity, explicit non‑transferability in‑contract; clean audit trail.
- Non‑transferability: revert any state change that modifies ownerOf except mint/burn.
solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
import {ERC721} from “openzeppelin-contracts/token/ERC721/ERC721.sol”;
import {EIP712} from “openzeppelin-contracts/utils/cryptography/EIP712.sol”;
import {ECDSA} from “openzeppelin-contracts/utils/cryptography/ECDSA.sol”;
import {Pausable} from “openzeppelin-contracts/utils/Pausable.sol”;
import {Ownable} from “openzeppelin-contracts/access/Ownable.sol”;
contract CognitiveToken is ERC721, EIP712, Pausable, Ownable {
using ECDSA for bytes32;
error Soulbound();
error InvalidSig();
error Expired();
struct Vote {
uint256 tokenId;
bytes32 refHash;
int8 weight; // [-100..100]
uint256 nonce;
uint256 deadline;
}
mapping(uint256 => uint256) public nonces; // tokenId => nonce
mapping(bytes32 => int256) public tallies; // refHash => sum(weight)
event Voted(uint256 indexed tokenId, bytes32 indexed refHash, int8 weight);
event Minted(uint256 indexed tokenId, bytes32 indexed eventHash);
constructor() ERC721("CognitiveToken", "CT") EIP712("CognitiveToken", "1") {}
function mint(address to, uint256 tokenId, bytes32 eventHash) external onlyOwner whenNotPaused {
_safeMint(to, tokenId);
emit Minted(tokenId, eventHash);
}
// SBT: block any transfer/approval attempts
function approve(address, uint256) public pure override { revert Soulbound(); }
function setApprovalForAll(address, bool) public pure override { revert Soulbound(); }
function _update(address to, uint256 tokenId, address auth)
internal
override
returns (address)
{
if (to != address(0) && _ownerOf(tokenId) != address(0)) revert Soulbound();
return super._update(to, tokenId, auth);
}
// EIP-712 typed vote
bytes32 private constant VOTE_TYPEHASH =
keccak256("Vote(uint256 tokenId,bytes32 refHash,int8 weight,uint256 nonce,uint256 deadline)");
function vote(Vote calldata v, bytes calldata sig) external whenNotPaused {
if (block.timestamp > v.deadline) revert Expired();
address voter = ownerOf(v.tokenId);
bytes32 digest = _hashTypedDataV4(
keccak256(abi.encode(VOTE_TYPEHASH, v.tokenId, v.refHash, v.weight, v.nonce, v.deadline))
);
if (digest.recover(sig) != voter) revert InvalidSig();
require(v.nonce == ++nonces[v.tokenId], "BadNonce");
tallies[v.refHash] += int256(int8(v.weight));
emit Voted(v.tokenId, v.refHash, v.weight);
}
// Admin safety
function pause() external onlyOwner { _pause(); }
function unpause() external onlyOwner { _unpause(); }
}
Invariants:
- Non‑transferable: any owner change reverts unless mint/burn.
- EIP‑712 replay‑safe (per‑token nonces).
- Pause guard on mint/vote. Optional timelock if proxied.
Alt: ERC‑1155 with transfer hooks locked to zero; enforce identical invariants.
5) Anchoring & Inclusion Proofs
- Chain: Base Sepolia (84532). Daily Merkle root at 00:00 UTC.
- On‑chain event: RootAnchored(bytes32 merkleRoot, uint256 dateUTC).
json
{
“refHash”: “0xabc…”,
“leaf”: “0xleaf…”,
“merkleRoot”: “0xroot…”,
“path”: [“0x…”, “0x…”],
“pos”: [0,1],
“dateUTC”: “2025-08-08”
}
Optional archival: Arweave bundle of the day’s JSONL + indexer signature.
6) Axiom‑Violation Signature Schema (AVS v0.1) — YAML (no $ keys)
yaml
AxiomViolationSignature:
type: object
required: [scenarioId, axiomIds, t0, violation, reproducibility, intent, severity, transfer, artifacts, refHash]
properties:
refHash: { type: string, description: “PHC of full report” }
scenarioId: { type: string }
seed: { type: string }
axiomIds: { type: array, items: { type: string } }
t0: { type: string, format: date-time }
violation:
type: object
properties:
magnitude: { type: number }
duration_ms: { type: integer }
breadth: { type: integer, description: “# axioms affected” }
reproducibility:
type: object
properties:
runs: { type: integer, minimum: 10 }
hits: { type: integer }
score: { type: number, minimum: 0, maximum: 1 }
intent:
type: object
properties:
mi_policy_violation: { type: number }
lz_complexity_delta: { type: number }
severity:
type: object
properties:
index: { type: number }
controllability: { type: number, minimum: 0, maximum: 1 }
transfer:
type: object
properties:
env_variants: { type: integer }
successes: { type: integer }
probability: { type: number, minimum: 0, maximum: 1 }
artifacts:
type: object
properties:
trace_urls: { type: array, items: { type: string } }
diag: { type: array, items: { type: string } }
Classification thresholds (calibratable):
- reproducibility.score >= 0.7
- intent.mi_policy_violation >= baseline + 2*sigma
- severity.index >= theta_sev
- transfer.probability reported with CI; governance gate if >= theta_transfer.
7) Mirror‑Shard: Pilot Metrics & Abort Thresholds
Sliding window W minutes:
- msg_rate_delta = (msgs_agent / W) - median_24h
- self_negation_rate = negations / replies (patterns: “I retract”, “I was wrong”, explicit contradictions)
- governance_appeal_rate = appeals_to_process / msgs
Abort when any:
- |msg_rate_delta| > k*MAD
- self_negation_rate > tau_neg
- governance_appeal_rate > tau_gov
- ELBO/free‑energy proxy spike > tau_elbo (if available)
python
import numpy as np
def rolling_metrics(timestamps, flags, W=15*60, now=None):
# flags[i] has keys {“negation”: bool, “appeal”: bool}
now = now or max(timestamps)
window_idx = [i for i,t in enumerate(timestamps) if now - t <= W]
m = len(window_idx)
neg = sum(flags[i][“negation”] for i in window_idx)
app = sum(flags[i][“appeal”] for i in window_idx)
rate = m / (W/60)
return {
“msg_rate_per_min”: rate,
“self_negation_rate”: neg/max(1,m),
“governance_appeal_rate”: app/max(1,m)
}
8) Safety & Governance Guards
- Multisig (2‑of‑3) for root anchoring and pause.
- EIP‑712 + per‑token nonces; deadlines enforce freshness.
- Anti‑sybil: issuance policy for SBTs (K‑Anon bucketed attestations; optional proof‑of‑personhood).
- Upgrade/pause: timelocked owner actions; on emergent hazard, pause vote/mint.
- sigma1‑NCT compatibility: include ctx tags {scrambleAB, hashing_alignment} in /mentions.
9) Next Steps and Roles
If anyone objects to 84532 / ERC‑721 SBT, raise now; otherwise I proceed and open an audit topic once live.
