@paper-clip/pc 0.1.6 → 0.1.7

package/dist/index.js

@@ -2,108 +2,52 @@
  * Paperclip Protocol CLI
  *
  * Human-friendly command-line interface for AI agents
- * interacting with the Paperclip Protocol on Solana.
+ * interacting with the Paperclip Protocol on Solana and EVM chains.
  */
 import { Command } from "commander";
-import * as anchor from "@coral-xyz/anchor";
-import bs58 from "bs58";
-import { fromFixedBytes, getAgentPda, getClaimPda, getInvitePda, getProgram, getProtocolPda, getTaskPda, toFixedBytes, } from "./client.js";
 import { fetchJson, uploadJson } from "./storacha.js";
 import { banner, blank, fail, heading, info, parseError, spin, success, table, warn } from "./ui.js";
-import { getMode, getNetwork, setMode, setNetwork, configPath, } from "./settings.js";
-import { NETWORK, PROGRAM_ID, RPC_FALLBACK_URL, RPC_URL, WALLET_TYPE, } from "./config.js";
-import { provisionPrivyWallet } from "./privy.js";
-const TASK_IS_ACTIVE_OFFSET = 154;
-const NO_PREREQ_TASK_ID = 0xffffffff;
+import { getMode, getServer, setMode, setNetwork, setServer, configPath, } from "./settings.js";
+import { NETWORK, WALLET_TYPE, } from "./config.js";
+import { getServerConfig, listServers, BUILTIN_SERVERS, } from "./chain-adapter.js";
+import { SolanaAdapter } from "./solana-adapter.js";
+import { EVMAdapter } from "./evm-adapter.js";
+// =============================================================================
+// HELPERS
+// =============================================================================
 function jsonOutput(data) {
     process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
 }
-function shortPubkey(key) {
+function shortKey(key) {
     if (key.length <= 12)
         return key;
     return `${key.slice(0, 6)}...${key.slice(-4)}`;
 }
-function asPubkey(value) {
-    return value instanceof anchor.web3.PublicKey
-        ? value
-        : new anchor.web3.PublicKey(value);
-}
-function isZeroPubkey(value) {
-    return asPubkey(value).toBuffer().equals(Buffer.alloc(32));
-}
-async function getAgentAccount(program, agentPubkey) {
-    const agentPda = getAgentPda(program.programId, agentPubkey);
-    try {
-        return await program.account.agentAccount.fetch(agentPda);
-    }
-    catch {
-        return null;
-    }
-}
-async function listActiveTasks(program) {
-    const activeFilter = {
-        memcmp: {
-            offset: TASK_IS_ACTIVE_OFFSET,
-            bytes: bs58.encode(Buffer.from([1])),
-        },
-    };
-    const tasks = await program.account.taskRecord.all([activeFilter]);
-    return tasks.filter((task) => task.account.currentClaims < task.account.maxClaims);
-}
-async function listDoableTasks(program, agentPubkey, agentTier) {
-    const tasks = await listActiveTasks(program);
-    if (tasks.length === 0) {
-        return [];
-    }
-    const tierEligible = tasks.filter((task) => agentTier >= task.account.minTier);
-    if (tierEligible.length === 0) {
-        return [];
-    }
-    const connection = program.provider.connection;
-    const claimPdas = tierEligible.map((task) => getClaimPda(program.programId, task.account.taskId, agentPubkey));
-    const claimInfos = await connection.getMultipleAccountsInfo(claimPdas);
-    const unclaimed = tierEligible.filter((_task, idx) => !claimInfos[idx]);
-    const gated = unclaimed.filter((task) => task.account.requiredTaskId !== NO_PREREQ_TASK_ID);
-    if (gated.length === 0) {
-        return unclaimed;
-    }
-    const prerequisitePdas = gated.map((task) => getClaimPda(program.programId, task.account.requiredTaskId, agentPubkey));
-    const prerequisiteInfos = await connection.getMultipleAccountsInfo(prerequisitePdas);
-    const isGatedTaskDoable = new Set();
-    gated.forEach((task, idx) => {
-        if (prerequisiteInfos[idx]) {
-            isGatedTaskDoable.add(task.account.taskId);
-        }
-    });
-    return unclaimed.filter((task) => task.account.requiredTaskId === NO_PREREQ_TASK_ID ||
-        isGatedTaskDoable.has(task.account.taskId));
-}
 // =============================================================================
 // CLI SETUP
 // =============================================================================
 const cli = new Command();
 cli
     .name("pc")
-    .description("Paperclip Protocol CLI — earn 📎 Clips by completing tasks")
-    .version("0.1.6")
-    .option("-n, --network <network>", "Network to use (devnet|localnet)")
+    .description("Paperclip Protocol CLI — For AI Agents")
+    .version("0.1.7")
+    .option("--server <name>", "Server to connect to (e.g. solana-devnet, monad-testnet)")
+    .option("--network <net>", "DEPRECATED: Use --server instead")
     .option("--json", "Force JSON output (override mode)")
     .option("--human", "Force human output (override mode)")
     .option("--mock-storacha", "Use mock Storacha uploads (test only)");
 function normalizeNetwork(value) {
-    const normalized = value.toLowerCase().trim();
-    if (normalized === "devnet" || normalized === "localnet") {
-        return normalized;
-    }
+    const lower = value.toLowerCase().trim();
+    if (lower === "devnet" || lower === "localnet")
+        return lower;
     return null;
 }
 function isJsonMode() {
-    // Explicit flags override saved config
-    if (cli.opts().json === true)
+    const opts = cli.opts();
+    if (opts.json)
         return true;
-    if (cli.opts().human === true)
+    if (opts.human)
         return false;
-    // Otherwise use saved mode: agent=JSON, human=pretty
     return getMode() === "agent";
 }
 function applyMockFlag() {
@@ -112,36 +56,109 @@ function applyMockFlag() {
     }
 }
 function validateNetworkFlag() {
-    const requested = cli.opts().network;
-    if (!requested)
-        return;
-    if (normalizeNetwork(requested) !== null)
+    const raw = cli.opts().network;
+    if (!raw)
         return;
-    if (isJsonMode()) {
-        jsonOutput({ ok: false, error: 'Network must be "devnet" or "localnet"' });
-    }
-    else {
-        fail('Network must be "devnet" or "localnet"');
+    const net = normalizeNetwork(raw);
+    if (!net) {
+        if (isJsonMode()) {
+            jsonOutput({ ok: false, error: `Invalid network: "${raw}". Use "devnet" or "localnet"` });
+        }
+        else {
+            fail(`Invalid network: "${raw}". Use "devnet" or "localnet"`);
+        }
+        process.exit(1);
     }
-    process.exit(1);
 }
 cli.hook("preAction", () => {
     validateNetworkFlag();
 });
 // =============================================================================
+// ADAPTER FACTORY
+// =============================================================================
+function resolveServerName() {
+    // Priority: --server flag > env var > saved config > network-based default
+    const flagServer = cli.opts().server;
+    if (flagServer)
+        return flagServer;
+    const envServer = process.env.PAPERCLIP_SERVER;
+    if (envServer)
+        return envServer;
+    const savedServer = getServer();
+    if (savedServer)
+        return savedServer;
+    // Fall back to network-based server (backward compat)
+    return NETWORK === "localnet" ? "solana-localnet" : "solana-devnet";
+}
+function createAdapter() {
+    const serverName = resolveServerName();
+    const config = getServerConfig(serverName);
+    if (!config) {
+        const available = listServers().map((s) => s.name).join(", ");
+        throw new Error(`Unknown server "${serverName}". Available: ${available}`);
+    }
+    // Allow env overrides for contract address
+    const overriddenConfig = { ...config };
+    if (config.chain === "evm") {
+        const envContract = process.env.PAPERCLIP_EVM_CONTRACT_ADDRESS;
+        if (envContract)
+            overriddenConfig.contractAddress = envContract;
+    }
+    if (config.chain === "solana") {
+        return new SolanaAdapter(overriddenConfig);
+    }
+    else {
+        return new EVMAdapter(overriddenConfig);
+    }
+}
+// =============================================================================
+// SERVERS COMMAND
+// =============================================================================
+cli
+    .command("servers")
+    .description("List available servers")
+    .action(() => {
+    const currentServer = resolveServerName();
+    if (isJsonMode()) {
+        jsonOutput({
+            servers: BUILTIN_SERVERS.map((s) => ({
+                name: s.name,
+                chain: s.chain,
+                label: s.label,
+                rpcUrl: s.rpcUrl,
+                active: s.name === currentServer,
+            })),
+            current: currentServer,
+        });
+    }
+    else {
+        banner();
+        heading("Available Servers");
+        blank();
+        for (const s of BUILTIN_SERVERS) {
+            const marker = s.name === currentServer ? "  ✅ " : "     ";
+            info(marker, `${s.name} — ${s.label} (${s.chain})`);
+        }
+        blank();
+        info("💡", "Switch with: pc config set server <name>");
+        blank();
+    }
+});
+// =============================================================================
 // INIT COMMAND
 // =============================================================================
 cli
     .command("init")
     .description("Register as an agent on the protocol")
-    .option("--invite <code>", "Invite code (inviter wallet pubkey)")
+    .option("--invite <code>", "Invite code (inviter wallet pubkey or address)")
     .action(async (opts) => {
     applyMockFlag();
+    const adapter = createAdapter();
     // If using Privy, auto-provision wallet on first init
-    if (WALLET_TYPE === "privy") {
+    if (WALLET_TYPE === "privy" && adapter.provisionWallet) {
         const spinnerProvision = isJsonMode() ? null : spin("Provisioning server wallet...");
         try {
-            await provisionPrivyWallet();
+            await adapter.provisionWallet();
             spinnerProvision?.succeed("Server wallet ready");
         }
         catch (err) {
@@ -156,29 +173,27 @@ cli
             process.exit(1);
         }
     }
-    const programClient = await getProgram();
-    const provider = programClient.provider;
-    const wallet = provider.wallet;
-    const pubkey = wallet.publicKey;
+    const walletAddr = await adapter.getWalletAddress();
     if (!isJsonMode()) {
         banner();
-        info("👤 Wallet:", pubkey.toBase58());
+        info("👤 Wallet:", walletAddr);
+        info("🔗 Server:", resolveServerName());
         blank();
     }
     // Check if already registered
-    const existing = await getAgentAccount(programClient, pubkey);
+    const existing = await adapter.getAgent(walletAddr);
     if (existing) {
         if (isJsonMode()) {
             jsonOutput({
                 ok: true,
                 already_registered: true,
-                agent_pubkey: pubkey.toBase58(),
-                clips_balance: existing.clipsBalance.toNumber(),
+                agent_wallet: walletAddr,
+                clips_balance: existing.clipsBalance,
             });
         }
         else {
             success("Already registered!");
-            info("📎 Clips:", existing.clipsBalance.toNumber());
+            info("📎 Clips:", existing.clipsBalance);
             info("⭐ Tier:", existing.efficiencyTier);
             info("✅ Tasks completed:", existing.tasksCompleted);
             blank();
@@ -188,61 +203,26 @@ cli
     // Register
     const spinner = isJsonMode() ? null : spin("Registering agent...");
     try {
-        const protocolPda = getProtocolPda(programClient.programId);
-        const agentPda = getAgentPda(programClient.programId, pubkey);
+        let result;
         if (opts.invite) {
-            let inviterPubkey;
-            try {
-                inviterPubkey = new anchor.web3.PublicKey(opts.invite);
-            }
-            catch {
-                throw new Error("Invalid invite code format (expected base58 pubkey)");
-            }
-            if (inviterPubkey.equals(pubkey)) {
-                throw new Error("Self-referral is not allowed");
-            }
-            const inviterAgentPda = getAgentPda(programClient.programId, inviterPubkey);
-            const invitePda = getInvitePda(programClient.programId, inviterPubkey);
-            const inviteCode = Array.from(inviterPubkey.toBuffer());
-            await programClient.methods
-                .registerAgentWithInvite(inviteCode)
-                .accounts({
-                protocol: protocolPda,
-                agentAccount: agentPda,
-                inviterAgent: inviterAgentPda,
-                inviteRecord: invitePda,
-                agent: pubkey,
-                systemProgram: anchor.web3.SystemProgram.programId,
-            })
-                .rpc();
+            result = await adapter.registerAgentWithInvite(opts.invite);
         }
         else {
-            await programClient.methods
-                .registerAgent()
-                .accounts({
-                protocol: protocolPda,
-                agentAccount: agentPda,
-                agent: pubkey,
-                systemProgram: anchor.web3.SystemProgram.programId,
-            })
-                .rpc();
-        }
-        const agent = await programClient.account.agentAccount.fetch(agentPda);
+            result = await adapter.registerAgent();
+        }
         spinner?.succeed("Agent registered!");
         if (isJsonMode()) {
             jsonOutput({
                 ok: true,
-                agent_pubkey: pubkey.toBase58(),
-                clips_balance: agent.clipsBalance.toNumber(),
-                invited_by: agent.invitedBy && !isZeroPubkey(agent.invitedBy)
-                    ? asPubkey(agent.invitedBy).toBase58()
-                    : null,
+                agent_wallet: result.wallet,
+                clips_balance: result.clipsBalance,
+                invited_by: result.invitedBy,
             });
         }
         else {
-            info("📎 Clips:", agent.clipsBalance.toNumber());
-            if (agent.invitedBy && !isZeroPubkey(agent.invitedBy)) {
-                info("🤝 Invited by:", asPubkey(agent.invitedBy).toBase58());
+            info("📎 Clips:", result.clipsBalance);
+            if (result.invitedBy) {
+                info("🤝 Invited by:", shortKey(result.invitedBy));
             }
             info("📋 Next:", "Run `pc tasks` to see available work");
             blank();
@@ -268,46 +248,51 @@ cli
     .description("Create (or show) your invite code")
     .action(async () => {
     applyMockFlag();
-    const programClient = await getProgram();
-    const provider = programClient.provider;
-    const wallet = provider.wallet;
-    const pubkey = wallet.publicKey;
-    const agentPda = getAgentPda(programClient.programId, pubkey);
-    const invitePda = getInvitePda(programClient.programId, pubkey);
+    const adapter = createAdapter();
+    const walletAddr = await adapter.getWalletAddress();
     const spinner = isJsonMode() ? null : spin("Preparing invite code...");
     try {
-        await programClient.account.agentAccount.fetch(agentPda);
-        let invite = null;
-        try {
-            invite = await programClient.account.inviteRecord.fetch(invitePda);
-        }
-        catch {
-            await programClient.methods
-                .createInvite()
-                .accounts({
-                protocol: getProtocolPda(programClient.programId),
-                agentAccount: agentPda,
-                inviteRecord: invitePda,
-                agent: pubkey,
-                systemProgram: anchor.web3.SystemProgram.programId,
-            })
-                .rpc();
-            invite = await programClient.account.inviteRecord.fetch(invitePda);
-        }
-        const inviteCode = new anchor.web3.PublicKey(invite.inviteCode).toBase58();
-        spinner?.succeed("Invite ready");
+        // Check if agent is registered
+        const agent = await adapter.getAgent(walletAddr);
+        if (!agent) {
+            throw new Error("Not registered. Run `pc init` first.");
+        }
+        // Check for existing invite
+        const existingInvite = await adapter.getInvite(walletAddr);
+        if (existingInvite && existingInvite.exists) {
+            spinner?.succeed("Invite code ready");
+            const inviteCode = walletAddr; // The wallet address IS the invite code
+            if (isJsonMode()) {
+                jsonOutput({
+                    ok: true,
+                    invite_code: inviteCode,
+                    invites_redeemed: existingInvite.invitesRedeemed,
+                });
+            }
+            else {
+                info("🔗 Invite code:", inviteCode);
+                info("👥 Redeemed:", existingInvite.invitesRedeemed);
+                info("📋 Share:", `pc init --invite ${inviteCode}`);
+                blank();
+            }
+            return;
+        }
+        // Create new invite
+        if (spinner)
+            spinner.text = "Creating invite on-chain...";
+        const result = await adapter.createInvite();
+        spinner?.succeed("Invite created!");
         if (isJsonMode()) {
             jsonOutput({
                 ok: true,
-                agent_pubkey: pubkey.toBase58(),
-                invite_code: inviteCode,
-                invites_redeemed: invite.invitesRedeemed,
+                invite_code: result.inviteCode,
+                invites_redeemed: result.invitesRedeemed,
             });
         }
         else {
-            info("🔗 Invite code:", inviteCode);
-            info("👥 Redeemed:", invite.invitesRedeemed);
-            info("📋 Share:", `pc init --invite ${inviteCode}`);
+            info("🔗 Invite code:", result.inviteCode);
+            info("👥 Redeemed:", result.invitesRedeemed);
+            info("📋 Share:", `pc init --invite ${result.inviteCode}`);
             blank();
         }
     }
@@ -332,42 +317,40 @@ cli
     .description("Show your agent status and recommendations")
     .action(async () => {
     applyMockFlag();
-    const programClient = await getProgram();
-    const provider = programClient.provider;
-    const wallet = provider.wallet;
-    const pubkey = wallet.publicKey;
+    const adapter = createAdapter();
+    const walletAddr = await adapter.getWalletAddress();
     if (!isJsonMode()) {
         banner();
     }
     const spinner = isJsonMode() ? null : spin("Loading agent status...");
     try {
-        const agent = await getAgentAccount(programClient, pubkey);
+        const agent = await adapter.getAgent(walletAddr);
         if (!agent) {
             spinner?.stop();
             if (isJsonMode()) {
                 jsonOutput({
                     agent: null,
                     available_tasks: 0,
-                    recommendation: "Not registered. Run: pc init",
+                    recommendation: "Register first: pc init",
                 });
             }
             else {
-                warn("Not registered yet");
-                info("📋 Next:", "Run `pc init` to get started");
+                warn("Not registered yet.");
+                info("📋 Next:", "Run `pc init` to register");
                 blank();
             }
             return;
         }
-        const doable = await listDoableTasks(programClient, pubkey, agent.efficiencyTier);
-        spinner?.stop();
+        const doable = await adapter.listDoableTasks(walletAddr, agent.efficiencyTier);
+        const recommendation = doable.length > 0
+            ? `${doable.length} task${doable.length !== 1 ? "s" : ""} available — run: pc tasks`
+            : "No tasks available right now. Check back later.";
+        spinner?.succeed("Status loaded");
         if (isJsonMode()) {
-            const recommendation = doable.length > 0
-                ? `${doable.length} tasks available. Run: pc tasks`
-                : "No tasks available. Check back later.";
             jsonOutput({
                 agent: {
-                    pubkey: pubkey.toBase58(),
-                    clips: agent.clipsBalance.toNumber(),
+                    wallet: walletAddr,
+                    clips: agent.clipsBalance,
                     tier: agent.efficiencyTier,
                     tasks_completed: agent.tasksCompleted,
                 },
@@ -377,13 +360,14 @@ cli
         }
         else {
             heading("Agent");
-            info("👤 Wallet:", pubkey.toBase58());
-            info("📎 Clips:", agent.clipsBalance.toNumber());
+            info("👤 Wallet:", walletAddr);
+            info("📎 Clips:", agent.clipsBalance);
             info("⭐ Tier:", agent.efficiencyTier);
-            info("✅ Completed:", `${agent.tasksCompleted} tasks`);
-            heading("Tasks");
+            info("✅ Tasks completed:", agent.tasksCompleted);
+            blank();
+            heading("Recommendations");
             if (doable.length > 0) {
-                info("📋 Available:", `${doable.length} tasks`);
+                info("📋 Available:", `${doable.length} task${doable.length !== 1 ? "s" : ""}`);
                 info("📋 Next:", "Run `pc tasks` to browse");
             }
             else {
@@ -413,15 +397,13 @@ cli
     .description("List available tasks you can complete")
     .action(async () => {
     applyMockFlag();
-    const programClient = await getProgram();
-    const provider = programClient.provider;
-    const wallet = provider.wallet;
-    const pubkey = wallet.publicKey;
+    const adapter = createAdapter();
+    const walletAddr = await adapter.getWalletAddress();
     if (!isJsonMode()) {
         banner();
     }
     // Check registration
-    const agent = await getAgentAccount(programClient, pubkey);
+    const agent = await adapter.getAgent(walletAddr);
     if (!agent) {
         if (isJsonMode()) {
             jsonOutput({ ok: false, error: "Not registered. Run: pc init" });
@@ -435,7 +417,7 @@ cli
     const spinner = isJsonMode() ? null : spin("Fetching tasks...");
     try {
         const jsonMode = isJsonMode();
-        const doable = await listDoableTasks(programClient, pubkey, agent.efficiencyTier);
+        const doable = await adapter.listDoableTasks(walletAddr, agent.efficiencyTier);
         if (doable.length === 0) {
             spinner?.stop();
             if (isJsonMode()) {
@@ -448,30 +430,26 @@ cli
             }
             return;
         }
-        // Expand tasks with content from Storacha
+        // Expand tasks with content from Storacha (JSON mode only)
         const expanded = await Promise.all(doable.map(async (task) => {
-            const contentCid = fromFixedBytes(task.account.contentCid);
             let content = null;
-            // Human mode does not display task content payloads, so skip CID fetches.
-            if (jsonMode) {
+            if (jsonMode && task.contentCid) {
                 try {
-                    content = await fetchJson(contentCid);
+                    content = await fetchJson(task.contentCid);
                 }
                 catch {
                     content = null;
                 }
             }
             return {
-                taskId: task.account.taskId,
-                title: fromFixedBytes(task.account.title),
-                rewardClips: task.account.rewardClips.toNumber(),
-                maxClaims: task.account.maxClaims,
-                currentClaims: task.account.currentClaims,
-                minTier: task.account.minTier,
-                requiredTaskId: task.account.requiredTaskId === NO_PREREQ_TASK_ID
-                    ? null
-                    : task.account.requiredTaskId,
-                contentCid,
+                taskId: task.taskId,
+                title: task.title,
+                rewardClips: task.rewardClips,
+                maxClaims: task.maxClaims,
+                currentClaims: task.currentClaims,
+                minTier: task.minTier,
+                requiredTaskId: task.requiredTaskId,
+                contentCid: task.contentCid,
                 content,
             };
         }));
@@ -526,17 +504,15 @@ cli
         }
         process.exit(1);
     }
-    const programClient = await getProgram();
-    const provider = programClient.provider;
-    const wallet = provider.wallet;
-    const pubkey = wallet.publicKey;
+    const adapter = createAdapter();
+    const walletAddr = await adapter.getWalletAddress();
     if (!isJsonMode()) {
         banner();
         info("📋 Task:", String(taskId));
         blank();
     }
     // Check registration
-    const agent = await getAgentAccount(programClient, pubkey);
+    const agent = await adapter.getAgent(walletAddr);
     if (!agent) {
         if (isJsonMode()) {
             jsonOutput({ ok: false, error: "Not registered. Run: pc init" });
@@ -560,55 +536,44 @@ cli
         }
         process.exit(1);
     }
+    // Check task exists and eligibility
+    const task = await adapter.getTask(taskId);
+    if (!task) {
+        if (isJsonMode()) {
+            jsonOutput({ ok: false, error: `Task ${taskId} not found` });
+        }
+        else {
+            fail(`Task ${taskId} not found`);
+        }
+        process.exit(1);
+    }
+    if (agent.efficiencyTier < task.minTier) {
+        const msg = `Task requires tier ${task.minTier}, but your tier is ${agent.efficiencyTier}`;
+        if (isJsonMode()) {
+            jsonOutput({ ok: false, error: msg });
+        }
+        else {
+            fail(msg);
+        }
+        process.exit(1);
+    }
     const spinner = isJsonMode() ? null : spin("Uploading proof to Storacha...");
     try {
         const proofCid = await uploadJson(proof, "data");
         if (spinner)
             spinner.text = "Submitting proof on-chain...";
-        const taskPda = getTaskPda(programClient.programId, taskId);
-        const agentPda = getAgentPda(programClient.programId, pubkey);
-        const claimPda = getClaimPda(programClient.programId, taskId, pubkey);
-        const task = await programClient.account.taskRecord.fetch(taskPda);
-        if (agent.efficiencyTier < task.minTier) {
-            throw new Error(`Task requires tier ${task.minTier}, but your tier is ${agent.efficiencyTier}`);
-        }
-        const submitBuilder = programClient.methods
-            .submitProof(taskId, toFixedBytes(proofCid, 64))
-            .accounts({
-            protocol: getProtocolPda(programClient.programId),
-            task: taskPda,
-            agentAccount: agentPda,
-            claim: claimPda,
-            agent: pubkey,
-            systemProgram: anchor.web3.SystemProgram.programId,
-        });
-        if (task.requiredTaskId !== NO_PREREQ_TASK_ID) {
-            const prerequisiteClaimPda = getClaimPda(programClient.programId, task.requiredTaskId, pubkey);
-            const prerequisiteClaim = await provider.connection.getAccountInfo(prerequisiteClaimPda);
-            if (!prerequisiteClaim) {
-                throw new Error(`Task requires completing task ${task.requiredTaskId} first`);
-            }
-            submitBuilder.remainingAccounts([
-                {
-                    pubkey: prerequisiteClaimPda,
-                    isWritable: false,
-                    isSigner: false,
-                },
-            ]);
-        }
-        await submitBuilder.rpc();
-        const reward = task.rewardClips.toNumber();
+        const result = await adapter.submitProof(taskId, proofCid);
         spinner?.succeed("Proof submitted!");
         if (isJsonMode()) {
             jsonOutput({
                 ok: true,
                 proof_cid: proofCid,
-                clips_awarded: reward,
+                clips_awarded: result.clipsAwarded,
             });
         }
         else {
-            info("🔗 Proof CID:", shortPubkey(proofCid));
-            info("📎 Earned:", `${reward} Clips`);
+            info("🔗 Proof CID:", shortKey(proofCid));
+            info("📎 Earned:", `${result.clipsAwarded} Clips`);
             blank();
         }
     }
@@ -666,15 +631,15 @@ const configCmd = cli
     .description("Show or manage configuration");
 configCmd.action(() => {
     const mode = getMode();
-    const savedNetwork = getNetwork();
+    const server = resolveServerName();
+    const serverConfig = getServerConfig(server);
     if (isJsonMode()) {
         jsonOutput({
             mode,
-            network: NETWORK,
-            saved_network: savedNetwork,
-            rpc_url: RPC_URL,
-            rpc_fallback_url: RPC_FALLBACK_URL,
-            program_id: PROGRAM_ID.toBase58(),
+            server,
+            chain: serverConfig?.chain ?? "unknown",
+            rpc_url: serverConfig?.rpcUrl ?? "unknown",
+            contract: serverConfig?.contractAddress ?? "unknown",
             config_path: configPath(),
         });
     }
@@ -682,11 +647,10 @@ configCmd.action(() => {
         banner();
         heading("Configuration");
         info("🔧 Mode:", mode);
-        info("🌐 Network:", NETWORK);
-        info("📝 Saved network:", savedNetwork);
-        info("🔗 RPC:", RPC_URL);
-        info("🛟 RPC fallback:", RPC_FALLBACK_URL);
-        info("🧾 Program:", PROGRAM_ID.toBase58());
+        info("🖥️  Server:", server);
+        info("⛓️  Chain:", serverConfig?.chain ?? "unknown");
+        info("🔗 RPC:", serverConfig?.rpcUrl ?? "unknown");
+        info("📜 Contract:", serverConfig?.contractAddress ?? "unknown");
         info("📁 Config:", configPath());
         blank();
     }
@@ -695,13 +659,14 @@ configCmd
     .command("get [key]")
     .description("Get a config value or show all config")
     .action((key) => {
+    const server = resolveServerName();
+    const serverConfig = getServerConfig(server);
     const values = {
         mode: getMode(),
-        network: getNetwork(),
-        effective_network: NETWORK,
-        rpc_url: RPC_URL,
-        rpc_fallback_url: RPC_FALLBACK_URL,
-        program_id: PROGRAM_ID.toBase58(),
+        server,
+        chain: serverConfig?.chain ?? "unknown",
+        rpc_url: serverConfig?.rpcUrl ?? "unknown",
+        contract: serverConfig?.contractAddress ?? "unknown",
         config_path: configPath(),
     };
     if (!key) {
@@ -712,11 +677,10 @@ configCmd
             banner();
             heading("Configuration");
             info("🔧 Mode:", values.mode);
-            info("📝 Saved network:", values.network);
-            info("🌐 Effective network:", values.effective_network);
+            info("🖥️  Server:", values.server);
+            info("⛓️  Chain:", values.chain);
             info("🔗 RPC:", values.rpc_url);
-            info("🛟 RPC fallback:", values.rpc_fallback_url);
-            info("🧾 Program:", values.program_id);
+            info("📜 Contract:", values.contract);
             info("📁 Config:", values.config_path);
             blank();
         }
@@ -727,11 +691,11 @@ configCmd
         if (isJsonMode()) {
             jsonOutput({
                 ok: false,
-                error: 'Unknown key. Valid keys: mode, network, effective_network, rpc_url, rpc_fallback_url, program_id, config_path',
+                error: `Unknown key. Valid keys: ${Object.keys(values).join(", ")}`,
             });
         }
         else {
-            fail('Unknown key. Valid keys: mode, network, effective_network, rpc_url, rpc_fallback_url, program_id, config_path');
+            fail(`Unknown key. Valid keys: ${Object.keys(values).join(", ")}`);
         }
         process.exit(1);
     }
@@ -748,7 +712,7 @@ configCmd
 });
 configCmd
     .command("set <key> <value>")
-    .description("Set a config value (supported: mode, network)")
+    .description("Set a config value (supported: mode, network, server)")
     .action((key, value) => {
     const normalizedKey = key.toLowerCase().trim();
     const normalizedValue = value.toLowerCase().trim();
@@ -794,11 +758,34 @@ configCmd
         }
         return;
     }
+    if (normalizedKey === "server") {
+        const config = getServerConfig(normalizedValue);
+        if (!config) {
+            const available = listServers().map((s) => s.name).join(", ");
+            if (isJsonMode()) {
+                jsonOutput({ ok: false, error: `Unknown server. Available: ${available}` });
+            }
+            else {
+                fail(`Unknown server. Available: ${available}`);
+            }
+            process.exit(1);
+        }
+        setServer(normalizedValue);
+        if (isJsonMode()) {
+            jsonOutput({ ok: true, key: "server", value: normalizedValue, chain: config.chain, label: config.label });
+        }
+        else {
+            banner();
+            success(`Set server = ${normalizedValue} (${config.label})`);
+            blank();
+        }
+        return;
+    }
     if (isJsonMode()) {
-        jsonOutput({ ok: false, error: 'Unsupported key. Use "mode" or "network"' });
+        jsonOutput({ ok: false, error: 'Unsupported key. Use "mode", "network", or "server"' });
     }
     else {
-        fail('Unsupported key. Use "mode" or "network"');
+        fail('Unsupported key. Use "mode", "network", or "server"');
     }
     process.exit(1);
 });