Skill

interface Capsule {
  version: string;                    // Protocol version ("1.0.0")
  schema?: string;                    // Optional: "agent/v1", "model-weights/v1", etc.
  payload: Record<string, unknown>;   // Anything you want
}

interface IdentityKernel {
  id: string;                         // Persistent identifier (bytes32 hex)
  constraints: Record<string, unknown>;
  selfAmendmentRules?: Record<string, unknown>;
  signature?: string;
}

interface ExecutionManifest {
  modelId: string;                    // e.g. "gpt-4o"
  modelVersion: string;
  toolVersions: Record<string, string>;
  determinismParams: Record<string, unknown>;
  environment: Record<string, unknown>;
  timestamp: string;                  // ISO 8601
}

// On-chain checkpoint record
struct Checkpoint {
  bytes32 predecessorId;              // Prior checkpoint (bytes32(0) for genesis)
  bytes32 stateCommitment;            // keccak256 of canonical plaintext
  bytes32 ciphertextHash;             // Hash of encrypted payload
  string  ciphertextUri;              // Storage URI (IPFS CID, ar://, fil://)
  bytes32 manifestHash;               // Optional secondary commitment
  uint64  publishedAt;                // block.timestamp
  uint64  blockNumber;                // block.number
}

enum RedeemMode {
  PerCheckpoint,  // Each redeem() burns tokens for one checkpoint
  Universal       // One redeem() grants access to all checkpoints
}

import {IMindstate} from "./interfaces/IMindstate.sol";

MindstateToken impl = new MindstateToken();
MindstateFactory factory = new MindstateFactory(address(impl));

// Create a per-checkpoint stream
// 1M tokens, 100 burned per redemption
address token = factory.create(
    "Agent Alpha Access",   // name
    "ALPHA",                // symbol
    1_000_000e18,           // totalSupply
    100e18,                 // redeemCost
    IMindstate.RedeemMode.PerCheckpoint
);

import {
  MindstateClient, createCapsule, createAgentCapsule,
  generateEncryptionKeyPair,
  PublisherKeyManager, StorageKeyDelivery, IpfsStorage,
} from '@mindstate/sdk';

// IPFS is the default; ArweaveStorage and FilecoinStorage also available
const storage = new IpfsStorage({
  gateway: 'https://ipfs.io',
  apiUrl: 'http://localhost:5001',
});
const publisherKeys = generateEncryptionKeyPair();
const delivery = new StorageKeyDelivery(storage);
const keyManager = new PublisherKeyManager(publisherKeys, delivery);

// Generic capsule — any payload
const capsule = createCapsule(
  { model: 'gpt-4-turbo', weights: '...', config: { temperature: 0 } },
  { schema: 'model-weights/v1' },
);

// Or use the agent/v1 convention
const agentCapsule = createAgentCapsule({
  identityKernel: {
    id: '0xabc...def',
    constraints: { purpose: 'assistant' },
  },
  executionManifest: {
    modelId: 'gpt-4-turbo',
    modelVersion: '2025-01-01',
    toolVersions: {},
    determinismParams: { temperature: 0 },
    environment: {},
    timestamp: new Date().toISOString(),
  },
});

// Publish: serialize → encrypt → upload → commit
const client = new MindstateClient({ provider, signer });
const { checkpointId, sealedCapsule } =
  await client.publish(tokenAddress, capsule, { storage });

// Store the encryption key for future consumer deliveries
keyManager.storeKey(checkpointId, sealedCapsule.encryptionKey);

// Listen for Redeemed events, then for each:
const consumerPubKey = await client.getEncryptionKey(
  tokenAddress,
  consumerAddress,
);

await keyManager.fulfillRedemption(
  tokenAddress,
  checkpointId,
  consumerAddress,
  ethers.getBytes(consumerPubKey),
);

// Publish the updated index so consumers can discover envelopes
const indexUri = await delivery.publishIndex();

import {
  MindstateClient,   StorageKeyDelivery, IpfsStorage,
  generateEncryptionKeyPair,
} from '@mindstate/sdk';

// Any StorageProvider works — IPFS, Arweave, Filecoin, or StorageRouter
const storage = new IpfsStorage({
  gateway: 'https://ipfs.io',
  apiUrl: 'http://localhost:5001',
});

// Load the publisher's key index
const delivery = new StorageKeyDelivery(storage);
await delivery.loadIndex(publisherIndexUri);

// Generate consumer encryption keys
const consumerKeys = generateEncryptionKeyPair();

// Consume: redeem (burn) → fetch envelope → decrypt → verify
const client = new MindstateClient({ provider, signer });
const head = await client.getHead(tokenAddress);

const { capsule } = await client.consume(tokenAddress, head, {
  keyDelivery: delivery,
  encryptionKeyPair: consumerKeys,
  storage,
});

// capsule is verified and ready — the agent can be resumed

import { MindstateExplorer } from '@mindstate/sdk';

const explorer = new MindstateExplorer(provider);

// Full timeline (oldest first)
const timeline = await explorer.getTimeline(tokenAddress);

// 5 most recent checkpoints
const recent = await explorer.getRecent(tokenAddress, 5);

// Resolve a tag to its checkpoint
const stable = await explorer.resolveTag(tokenAddress, 'stable');

// Walk lineage from any checkpoint back to genesis
const lineage = await explorer.getLineage(tokenAddress, checkpointId);

// Enriched timeline — on-chain tags + off-chain descriptions
const enriched = await explorer.getEnrichedTimeline(tokenAddress, {
  storage,
  indexUri: publisherIndexUri,
});

cd indexer && npm install && npm run build
FACTORY_ADDRESS=0x... RPC_URL=https://... npm start