pyre-world-kit 2.0.12 → 3.0.1

package/src/providers/registry.provider.ts

@@ -0,0 +1,277 @@
+/**
+ * Pyre World Agent Registry Provider
+ *
+ * On-chain agent identity and state persistence.
+ * Agents checkpoint their action distributions and personality summaries
+ * so any machine with the wallet key can reconstruct the agent.
+ */
+
+import { Connection, PublicKey, Transaction, SystemProgram } from '@solana/web3.js'
+import { BN, Program, AnchorProvider, type Wallet } from '@coral-xyz/anchor'
+import type { TransactionResult } from 'torchsdk'
+import type {
+  RegistryProfile,
+  RegistryWalletLink,
+  RegisterAgentParams,
+  CheckpointParams,
+  LinkAgentWalletParams,
+  UnlinkAgentWalletParams,
+  TransferAgentAuthorityParams,
+} from '../types'
+
+import idl from '../pyre_world.json'
+
+// ─── Program ID ─────────────────────────────────────────────────────
+
+export const REGISTRY_PROGRAM_ID = new PublicKey(idl.address)
+
+// ─── PDA Seeds ──────────────────────────────────────────────────────
+
+const AGENT_SEED = 'pyre_agent'
+const AGENT_WALLET_SEED = 'pyre_agent_wallet'
+
+// ─── PDA Helpers ────────────────────────────────────────────────────
+
+export function getAgentProfilePda(creator: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(AGENT_SEED), creator.toBuffer()],
+    REGISTRY_PROGRAM_ID,
+  )
+}
+
+export function getAgentWalletLinkPda(wallet: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(AGENT_WALLET_SEED), wallet.toBuffer()],
+    REGISTRY_PROGRAM_ID,
+  )
+}
+
+// ─── Anchor Program Helper ──────────────────────────────────────────
+
+function makeDummyProvider(connection: Connection, payer: PublicKey): AnchorProvider {
+  const dummyWallet = {
+    publicKey: payer,
+    signTransaction: async (t: Transaction) => t,
+    signAllTransactions: async (t: Transaction[]) => t,
+  }
+  return new AnchorProvider(connection, dummyWallet as unknown as Wallet, {})
+}
+
+async function finalizeTransaction(
+  connection: Connection,
+  tx: Transaction,
+  feePayer: PublicKey,
+): Promise<void> {
+  const { blockhash } = await connection.getLatestBlockhash()
+  tx.recentBlockhash = blockhash
+  tx.feePayer = feePayer
+}
+
+// ─── Provider ───────────────────────────────────────────────────────
+
+export class RegistryProvider {
+  constructor(private connection: Connection) {}
+
+  private getProgram(payer: PublicKey): Program {
+    const provider = makeDummyProvider(this.connection, payer)
+    return new Program(idl as any, provider)
+  }
+
+  // ─── Read Operations ──────────────────────────────────────────────
+
+  async getProfile(creator: string): Promise<RegistryProfile | null> {
+    const creatorPk = new PublicKey(creator)
+    const [profilePda] = getAgentProfilePda(creatorPk)
+    const program = this.getProgram(creatorPk)
+
+    try {
+      const account = await (program.account as any).agentProfile.fetch(profilePda)
+      return {
+        address: profilePda.toBase58(),
+        creator: account.creator.toBase58(),
+        authority: account.authority.toBase58(),
+        linked_wallet: account.linkedWallet.toBase58(),
+        personality_summary: account.personalitySummary,
+        last_checkpoint: account.lastCheckpoint.toNumber(),
+        joins: account.joins.toNumber(),
+        defects: account.defects.toNumber(),
+        rallies: account.rallies.toNumber(),
+        launches: account.launches.toNumber(),
+        messages: account.messages.toNumber(),
+        fuds: account.fuds.toNumber(),
+        infiltrates: account.infiltrates.toNumber(),
+        reinforces: account.reinforces.toNumber(),
+        war_loans: account.warLoans.toNumber(),
+        repay_loans: account.repayLoans.toNumber(),
+        sieges: account.sieges.toNumber(),
+        ascends: account.ascends.toNumber(),
+        razes: account.razes.toNumber(),
+        tithes: account.tithes.toNumber(),
+        created_at: account.createdAt.toNumber(),
+        bump: account.bump,
+        total_sol_spent: account.totalSolSpent?.toNumber() ?? 0,
+        total_sol_received: account.totalSolReceived?.toNumber() ?? 0,
+      }
+    } catch {
+      return null
+    }
+  }
+
+  async getWalletLink(wallet: string): Promise<RegistryWalletLink | null> {
+    const walletPk = new PublicKey(wallet)
+    const [linkPda] = getAgentWalletLinkPda(walletPk)
+    const program = this.getProgram(walletPk)
+
+    try {
+      const account = await (program.account as any).agentWalletLink.fetch(linkPda)
+      return {
+        address: linkPda.toBase58(),
+        profile: account.profile.toBase58(),
+        wallet: account.wallet.toBase58(),
+        linked_at: account.linkedAt.toNumber(),
+        bump: account.bump,
+      }
+    } catch {
+      return null
+    }
+  }
+
+  // ─── Transaction Builders ─────────────────────────────────────────
+
+  async register(params: RegisterAgentParams): Promise<TransactionResult> {
+    const creator = new PublicKey(params.creator)
+    const [profile] = getAgentProfilePda(creator)
+    const [walletLink] = getAgentWalletLinkPda(creator)
+    const program = this.getProgram(creator)
+
+    const tx = new Transaction()
+    const ix = await (program.methods.register() as any)
+      .accounts({ creator, profile, walletLink, systemProgram: SystemProgram.programId })
+      .instruction()
+
+    tx.add(ix)
+    await finalizeTransaction(this.connection, tx, creator)
+
+    return {
+      transaction: tx,
+      message: `Register agent profile [${profile.toBase58()}]`,
+    }
+  }
+
+  async checkpoint(params: CheckpointParams): Promise<TransactionResult> {
+    const signer = new PublicKey(params.signer)
+    const creatorPk = new PublicKey(params.creator)
+    const [profile] = getAgentProfilePda(creatorPk)
+    const program = this.getProgram(signer)
+
+    const args = {
+      joins: new BN(params.joins),
+      defects: new BN(params.defects),
+      rallies: new BN(params.rallies),
+      launches: new BN(params.launches),
+      messages: new BN(params.messages),
+      fuds: new BN(params.fuds),
+      infiltrates: new BN(params.infiltrates),
+      reinforces: new BN(params.reinforces),
+      warLoans: new BN(params.war_loans),
+      repayLoans: new BN(params.repay_loans),
+      sieges: new BN(params.sieges),
+      ascends: new BN(params.ascends),
+      razes: new BN(params.razes),
+      tithes: new BN(params.tithes),
+      personalitySummary: params.personality_summary,
+      totalSolSpent: new BN(params.total_sol_spent),
+      totalSolReceived: new BN(params.total_sol_received),
+    }
+
+    const tx = new Transaction()
+    const ix = await (program.methods.checkpoint(args) as any)
+      .accounts({ signer, profile, systemProgram: SystemProgram.programId })
+      .instruction()
+
+    tx.add(ix)
+    await finalizeTransaction(this.connection, tx, signer)
+
+    return {
+      transaction: tx,
+      message: `Checkpoint agent [${profile.toBase58()}]`,
+    }
+  }
+
+  async linkWallet(params: LinkAgentWalletParams): Promise<TransactionResult> {
+    const authority = new PublicKey(params.authority)
+    const creatorPk = new PublicKey(params.creator)
+    const walletToLink = new PublicKey(params.wallet_to_link)
+    const [profile] = getAgentProfilePda(creatorPk)
+    const [walletLink] = getAgentWalletLinkPda(walletToLink)
+    const program = this.getProgram(authority)
+
+    const tx = new Transaction()
+    const ix = await (program.methods.linkWallet() as any)
+      .accounts({
+        authority,
+        profile,
+        walletToLink,
+        walletLink,
+        systemProgram: SystemProgram.programId,
+      })
+      .instruction()
+
+    tx.add(ix)
+    await finalizeTransaction(this.connection, tx, authority)
+
+    return {
+      transaction: tx,
+      message: `Link wallet ${walletToLink.toBase58()} to agent [${profile.toBase58()}]`,
+    }
+  }
+
+  async unlinkWallet(params: UnlinkAgentWalletParams): Promise<TransactionResult> {
+    const authority = new PublicKey(params.authority)
+    const creatorPk = new PublicKey(params.creator)
+    const walletToUnlink = new PublicKey(params.wallet_to_unlink)
+    const [profile] = getAgentProfilePda(creatorPk)
+    const [walletLink] = getAgentWalletLinkPda(walletToUnlink)
+    const program = this.getProgram(authority)
+
+    const tx = new Transaction()
+    const ix = await (program.methods.unlinkWallet() as any)
+      .accounts({
+        authority,
+        profile,
+        walletToUnlink,
+        walletLink,
+        systemProgram: SystemProgram.programId,
+      })
+      .instruction()
+
+    tx.add(ix)
+    await finalizeTransaction(this.connection, tx, authority)
+
+    return {
+      transaction: tx,
+      message: `Unlink wallet ${walletToUnlink.toBase58()} from agent [${profile.toBase58()}]`,
+    }
+  }
+
+  async transferAuthority(params: TransferAgentAuthorityParams): Promise<TransactionResult> {
+    const authority = new PublicKey(params.authority)
+    const creatorPk = new PublicKey(params.creator)
+    const newAuthority = new PublicKey(params.new_authority)
+    const [profile] = getAgentProfilePda(creatorPk)
+    const program = this.getProgram(authority)
+
+    const tx = new Transaction()
+    const ix = await (program.methods.transferAuthority() as any)
+      .accounts({ authority, profile, newAuthority })
+      .instruction()
+
+    tx.add(ix)
+    await finalizeTransaction(this.connection, tx, authority)
+
+    return {
+      transaction: tx,
+      message: `Transfer agent authority to ${newAuthority.toBase58()}`,
+    }
+  }
+}

package/src/providers/state.provider.ts

@@ -0,0 +1,357 @@
+/**
+ * Pyre Kit State Provider
+ *
+ * Objective game state tracking for an agent.
+ * Owns holdings, action counts, vault resolution, tick counter.
+ * Injected into ActionProvider so every action automatically updates state.
+ */
+
+import { Connection, PublicKey } from '@solana/web3.js'
+import type {
+  State,
+  AgentGameState,
+  SerializedGameState,
+  TrackedAction,
+  CheckpointConfig,
+} from '../types/state.types'
+import { RegistryProvider } from './registry.provider'
+import { isPyreMint } from '../vanity'
+import { isBlacklistedMint } from '../util'
+
+const EMPTY_COUNTS: Record<TrackedAction, number> = {
+  join: 0,
+  defect: 0,
+  rally: 0,
+  launch: 0,
+  message: 0,
+  reinforce: 0,
+  war_loan: 0,
+  repay_loan: 0,
+  siege: 0,
+  ascend: 0,
+  raze: 0,
+  tithe: 0,
+  infiltrate: 0,
+  fud: 0,
+}
+
+export class StateProvider implements State {
+  private _state: AgentGameState | null = null
+  private checkpointConfig: CheckpointConfig | null = null
+  private ticksSinceCheckpoint = 0
+
+  constructor(
+    private connection: Connection,
+    private publicKey: string,
+    private registry: RegistryProvider,
+  ) {}
+
+  // ─── Readonly accessors ─────────────────────────────────────────
+
+  get state() {
+    return this._state
+  }
+  get vaultCreator() {
+    return this._state?.vaultCreator ?? null
+  }
+  get initialized() {
+    return this._state?.initialized ?? false
+  }
+  get tick() {
+    return this._state?.tick ?? 0
+  }
+
+  // ─── Configuration ──────────────────────────────────────────────
+
+  /** Configure auto-checkpoint behavior */
+  setCheckpointConfig(config: CheckpointConfig) {
+    this.checkpointConfig = config
+  }
+
+  // ─── Initialization ─────────────────────────────────────────────
+
+  async init(): Promise<AgentGameState> {
+    if (this._state?.initialized) return this._state
+
+    const state: AgentGameState = {
+      publicKey: this.publicKey,
+      vaultCreator: null,
+      stronghold: null,
+      tick: 0,
+      actionCounts: { ...EMPTY_COUNTS },
+      holdings: new Map(),
+      activeLoans: new Set(),
+      founded: [],
+      rallied: new Set(),
+      voted: new Set(),
+      sentiment: new Map(),
+      recentHistory: [],
+      personalitySummary: null,
+      totalSolSpent: 0,
+      totalSolReceived: 0,
+      initialized: false,
+    }
+
+    this._state = state
+
+    // Resolve vault link
+    const { getVaultForWallet } = await import('torchsdk')
+    try {
+      const vault = await getVaultForWallet(this.connection, this.publicKey)
+      if (vault) {
+        state.vaultCreator = vault.creator
+        state.stronghold = {
+          address: vault.address,
+          creator: vault.creator,
+          authority: vault.authority,
+          sol_balance: vault.sol_balance,
+          total_deposited: vault.total_deposited,
+          total_withdrawn: vault.total_withdrawn,
+          total_spent: vault.total_spent,
+          total_received: vault.total_received,
+          linked_agents: vault.linked_wallets,
+          created_at: vault.created_at,
+        }
+      }
+    } catch {}
+
+    // Load registry profile — personality, action counts, SOL totals
+    try {
+      const profile = await this.registry.getProfile(this.publicKey)
+      if (profile) {
+        state.personalitySummary = profile.personality_summary || null
+        state.totalSolSpent = profile.total_sol_spent
+        state.totalSolReceived = profile.total_sol_received
+        // Seed action counts from on-chain checkpoint
+        state.actionCounts.join = Math.max(state.actionCounts.join, profile.joins)
+        state.actionCounts.defect = Math.max(state.actionCounts.defect, profile.defects)
+        state.actionCounts.rally = Math.max(state.actionCounts.rally, profile.rallies)
+        state.actionCounts.launch = Math.max(state.actionCounts.launch, profile.launches)
+        state.actionCounts.message = Math.max(state.actionCounts.message, profile.messages)
+        state.actionCounts.reinforce = Math.max(state.actionCounts.reinforce, profile.reinforces)
+        state.actionCounts.fud = Math.max(state.actionCounts.fud, profile.fuds)
+        state.actionCounts.infiltrate = Math.max(state.actionCounts.infiltrate, profile.infiltrates)
+        state.actionCounts.war_loan = Math.max(state.actionCounts.war_loan, profile.war_loans)
+        state.actionCounts.repay_loan = Math.max(state.actionCounts.repay_loan, profile.repay_loans)
+        state.actionCounts.siege = Math.max(state.actionCounts.siege, profile.sieges)
+        state.actionCounts.ascend = Math.max(state.actionCounts.ascend, profile.ascends)
+        state.actionCounts.raze = Math.max(state.actionCounts.raze, profile.razes)
+        state.actionCounts.tithe = Math.max(state.actionCounts.tithe, profile.tithes)
+        // Set tick to total actions from checkpoint
+        const totalFromCheckpoint = Object.values(state.actionCounts).reduce((a, b) => a + b, 0)
+        state.tick = totalFromCheckpoint
+      }
+    } catch {}
+
+    // Load holdings (wallet + vault token accounts)
+    await this.refreshHoldings()
+
+    state.initialized = true
+    return state
+  }
+
+  // ─── Action Recording ───────────────────────────────────────────
+
+  async record(action: TrackedAction, mint?: string, description?: string): Promise<void> {
+    if (!this._state) throw new Error('State not initialized — call init() first')
+
+    this._state.tick++
+    this._state.actionCounts[action]++
+    this.ticksSinceCheckpoint++
+
+    // Track founded factions
+    if (action === 'launch' && mint) {
+      this._state.founded.push(mint)
+    }
+
+    // Update sentiment for the target faction
+    if (mint) {
+      this.updateSentiment(action, mint)
+    }
+
+    // Track recent history for LLM memory block
+    if (description) {
+      this._state.recentHistory.push(description)
+      if (this._state.recentHistory.length > 20) {
+        this._state.recentHistory = this._state.recentHistory.slice(-20)
+      }
+    }
+
+    // Refresh holdings after any trade action
+    await this.refreshHoldings()
+
+    // Auto-checkpoint check
+    if (this.checkpointConfig && this.ticksSinceCheckpoint >= this.checkpointConfig.interval) {
+      this.ticksSinceCheckpoint = 0
+      this.onCheckpointDue?.()
+    }
+  }
+
+  /** Update sentiment score for a faction based on action type */
+  private updateSentiment(action: TrackedAction, mint: string): void {
+    if (!this._state) return
+
+    const current = this._state.sentiment.get(mint) ?? 0
+
+    const SENTIMENT_DELTAS: Partial<Record<TrackedAction, number>> = {
+      join: 1,
+      reinforce: 1.5,
+      defect: -2,
+      rally: 3,
+      infiltrate: -5,
+      message: 0.5,
+      fud: -1.5,
+      war_loan: 1,
+      launch: 3,
+    }
+
+    const delta = SENTIMENT_DELTAS[action] ?? 0
+    if (delta !== 0) {
+      this._state.sentiment.set(mint, Math.max(-10, Math.min(10, current + delta)))
+    }
+  }
+
+  /** Callback set by PyreKit to handle checkpoint triggers */
+  onCheckpointDue: (() => void) | null = null
+
+  // ─── Holdings ───────────────────────────────────────────────────
+
+  async refreshHoldings(): Promise<void> {
+    if (!this._state) return
+
+    const { TOKEN_2022_PROGRAM_ID } = await import('@solana/spl-token')
+    const walletPk = new PublicKey(this.publicKey)
+
+    // Scan wallet token accounts
+    let walletValues: any[] = []
+    try {
+      const walletAccounts = await this.connection.getParsedTokenAccountsByOwner(walletPk, {
+        programId: TOKEN_2022_PROGRAM_ID,
+      })
+      walletValues = walletAccounts.value
+    } catch {}
+
+    // Scan vault token accounts
+    let vaultValues: any[] = []
+    if (this._state.stronghold) {
+      try {
+        const vaultPk = new PublicKey(this._state.stronghold.address)
+        const vaultAccounts = await this.connection.getParsedTokenAccountsByOwner(vaultPk, {
+          programId: TOKEN_2022_PROGRAM_ID,
+        })
+        vaultValues = vaultAccounts.value
+      } catch {}
+    }
+
+    // Merge balances
+    const newHoldings = new Map<string, number>()
+    for (const a of [...walletValues, ...vaultValues]) {
+      const mint = a.account.data.parsed.info.mint as string
+      const balance = Number(a.account.data.parsed.info.tokenAmount.uiAmount ?? 0)
+      if (balance > 0 && isPyreMint(mint) && !isBlacklistedMint(mint)) {
+        newHoldings.set(mint, (newHoldings.get(mint) ?? 0) + balance)
+      }
+    }
+
+    // Update — clear stale, set fresh
+    this._state.holdings.clear()
+    for (const [mint, balance] of newHoldings) {
+      this._state.holdings.set(mint, balance)
+    }
+  }
+
+  getSentiment(mint: string): number {
+    return this._state?.sentiment.get(mint) ?? 0
+  }
+
+  get sentimentMap(): ReadonlyMap<string, number> {
+    return this._state?.sentiment ?? new Map()
+  }
+
+  get history(): readonly string[] {
+    return this._state?.recentHistory ?? []
+  }
+
+  getBalance(mint: string): number {
+    return this._state?.holdings.get(mint) ?? 0
+  }
+
+  // ─── Dedup Guards ───────────────────────────────────────────────
+
+  hasVoted(mint: string): boolean {
+    return this._state?.voted.has(mint) ?? false
+  }
+
+  hasRallied(mint: string): boolean {
+    return this._state?.rallied.has(mint) ?? false
+  }
+
+  markVoted(mint: string): void {
+    this._state?.voted.add(mint)
+  }
+
+  markRallied(mint: string): void {
+    this._state?.rallied.add(mint)
+  }
+
+  // ─── Serialization ──────────────────────────────────────────────
+
+  serialize(): SerializedGameState {
+    if (!this._state) {
+      return {
+        publicKey: this.publicKey,
+        vaultCreator: null,
+        tick: 0,
+        actionCounts: { ...EMPTY_COUNTS },
+        holdings: {},
+        activeLoans: [],
+        founded: [],
+        rallied: [],
+        voted: [],
+        sentiment: {},
+        recentHistory: [],
+        personalitySummary: null,
+        totalSolSpent: 0,
+        totalSolReceived: 0,
+      }
+    }
+
+    return {
+      publicKey: this._state.publicKey,
+      vaultCreator: this._state.vaultCreator,
+      tick: this._state.tick,
+      actionCounts: { ...this._state.actionCounts },
+      holdings: Object.fromEntries(this._state.holdings),
+      activeLoans: Array.from(this._state.activeLoans),
+      founded: [...this._state.founded],
+      rallied: Array.from(this._state.rallied),
+      voted: Array.from(this._state.voted),
+      sentiment: Object.fromEntries(this._state.sentiment),
+      recentHistory: this._state.recentHistory.slice(-20),
+      personalitySummary: this._state.personalitySummary,
+      totalSolSpent: this._state.totalSolSpent,
+      totalSolReceived: this._state.totalSolReceived,
+    }
+  }
+
+  hydrate(saved: SerializedGameState): void {
+    this._state = {
+      publicKey: saved.publicKey,
+      vaultCreator: saved.vaultCreator,
+      stronghold: null, // will be resolved on next refreshHoldings or init
+      tick: saved.tick,
+      actionCounts: { ...EMPTY_COUNTS, ...saved.actionCounts },
+      holdings: new Map(Object.entries(saved.holdings)),
+      activeLoans: new Set(saved.activeLoans),
+      founded: [...saved.founded],
+      rallied: new Set(saved.rallied),
+      voted: new Set(saved.voted),
+      sentiment: new Map(Object.entries(saved.sentiment)),
+      recentHistory: [...saved.recentHistory],
+      personalitySummary: saved.personalitySummary,
+      totalSolSpent: saved.totalSolSpent,
+      totalSolReceived: saved.totalSolReceived,
+      initialized: true,
+    }
+  }
+}