@paper-clip/pc 0.1.6 → 0.1.8

package/dist/privy-evm.js

@@ -0,0 +1,113 @@
+/**
+ * Privy EVM Integration
+ *
+ * Provides server-side Ethereum wallet management and gas-sponsored
+ * transaction sending via Privy's REST API.
+ *
+ * Agents never touch raw private keys — signing happens on Privy's servers.
+ * Gas fees are sponsored by Privy, so agents can transact without holding
+ * native tokens (MON, ETH, etc.).
+ *
+ * This module is only used when WALLET_TYPE === "privy" and chain === "evm".
+ */
+import { privyFetch } from "./privy.js";
+import { loadSettings, saveSettings } from "./settings.js";
+// ---------------------------------------------------------------------------
+// Wallet provisioning
+// ---------------------------------------------------------------------------
+/**
+ * Create a new Ethereum server wallet via Privy.
+ * Called once during `pc init` for EVM chains.
+ */
+export async function createPrivyEvmWallet() {
+    const data = await privyFetch("/wallets", {
+        method: "POST",
+        body: JSON.stringify({ chain_type: "ethereum" }),
+    });
+    return { id: data.id, address: data.address };
+}
+/**
+ * Get an existing EVM wallet's info from Privy.
+ */
+export async function getPrivyEvmWalletInfo(walletId) {
+    const data = await privyFetch(`/wallets/${walletId}`);
+    return { id: data.id, address: data.address };
+}
+// ---------------------------------------------------------------------------
+// Sponsored transaction sending
+// ---------------------------------------------------------------------------
+/**
+ * Send a gas-sponsored EVM transaction via Privy.
+ *
+ * Uses `eth_sendTransaction` with `sponsor: true` — Privy pays gas.
+ * Returns the transaction hash.
+ *
+ * @param walletId   Privy wallet ID
+ * @param chainId    EVM chain ID (e.g. 10143 for Monad testnet)
+ * @param tx         Transaction parameters (to, data, value?)
+ */
+export async function sendSponsoredEvmTransaction(walletId, chainId, tx) {
+    const caip2 = `eip155:${chainId}`;
+    const transaction = {
+        to: tx.to,
+        data: tx.data,
+    };
+    if (tx.value) {
+        transaction.value = tx.value;
+    }
+    const data = await privyFetch(`/wallets/${walletId}/rpc`, {
+        method: "POST",
+        body: JSON.stringify({
+            method: "eth_sendTransaction",
+            caip2,
+            sponsor: true,
+            params: { transaction },
+        }),
+    });
+    const hash = data?.data?.hash ||
+        data?.hash ||
+        data?.data?.transaction_hash;
+    if (typeof hash !== "string" || hash.length === 0) {
+        throw new Error(`Invalid Privy eth_sendTransaction response: ${JSON.stringify(data)}`);
+    }
+    return hash;
+}
+// ---------------------------------------------------------------------------
+// Provision + persist
+// ---------------------------------------------------------------------------
+/**
+ * Provision a new EVM wallet and save to settings.
+ * Called during `pc init` when using Privy mode on an EVM chain.
+ * Returns the wallet address.
+ */
+export async function provisionPrivyEvmWallet() {
+    const settings = loadSettings();
+    // Already provisioned?
+    if (settings.privyEvmWalletId && settings.privyEvmWalletAddress) {
+        return {
+            id: settings.privyEvmWalletId,
+            address: settings.privyEvmWalletAddress,
+        };
+    }
+    // Create new wallet
+    const info = await createPrivyEvmWallet();
+    // Persist
+    settings.privyEvmWalletId = info.id;
+    settings.privyEvmWalletAddress = info.address;
+    saveSettings(settings);
+    return info;
+}
+/**
+ * Get existing EVM Privy wallet info from settings.
+ * Throws if no wallet has been provisioned yet.
+ */
+export function getPersistedEvmWallet() {
+    const settings = loadSettings();
+    if (!settings.privyEvmWalletId || !settings.privyEvmWalletAddress) {
+        throw new Error("No Privy EVM wallet found. Run `pc init` to create one.");
+    }
+    return {
+        id: settings.privyEvmWalletId,
+        address: settings.privyEvmWalletAddress,
+    };
+}

package/dist/privy.js

@@ -17,7 +17,7 @@ const DUMMY_RECENT_BLOCKHASH = "11111111111111111111111111111111";
 // ---------------------------------------------------------------------------
 // HTTP helpers
 // ---------------------------------------------------------------------------
-function authHeaders() {
+export function authHeaders() {
     const encoded = Buffer.from(`${PRIVY_APP_ID}:${PRIVY_APP_SECRET}`).toString("base64");
     return {
         Authorization: `Basic ${encoded}`,
@@ -25,7 +25,7 @@ function authHeaders() {
         "Content-Type": "application/json",
     };
 }
-async function privyFetch(path, init = {}) {
+export async function privyFetch(path, init = {}) {
     const url = `${PRIVY_API_BASE}${path}`;
     const headers = {
         ...authHeaders(),

package/dist/settings.js

@@ -70,6 +70,14 @@ export function setNetwork(network) {
     settings.network = network;
     saveSettings(settings);
 }
+export function getServer() {
+    return loadSettings().server;
+}
+export function setServer(server) {
+    const settings = loadSettings();
+    settings.server = server;
+    saveSettings(settings);
+}
 export function configPath() {
     return CONFIG_FILE;
 }

package/dist/solana-adapter.js

@@ -0,0 +1,299 @@
+/**
+ * Solana Adapter
+ *
+ * Wraps the existing Anchor client code into the ChainAdapter interface.
+ * No logic changes — just reorganization of existing code from index.ts and client.ts.
+ */
+import * as anchor from "@coral-xyz/anchor";
+import bs58 from "bs58";
+import { fromFixedBytes, getAgentPda, getClaimPda, getInvitePda, getProgram, getProtocolPda, getTaskPda, toFixedBytes, } from "./client.js";
+import { provisionPrivyWallet } from "./privy.js";
+import { WALLET_TYPE } from "./config.js";
+const NO_PREREQ_TASK_ID = 0xffffffff;
+const TASK_IS_ACTIVE_OFFSET = 154;
+export class SolanaAdapter {
+    chain = "solana";
+    serverName;
+    serverConfig;
+    _program = null;
+    constructor(config) {
+        this.serverConfig = config;
+        this.serverName = config.name;
+    }
+    async program() {
+        if (!this._program) {
+            this._program = await getProgram();
+        }
+        return this._program;
+    }
+    async provider() {
+        const p = await this.program();
+        return p.provider;
+    }
+    async pubkey() {
+        const prov = await this.provider();
+        return prov.wallet.publicKey;
+    }
+    async getWalletAddress() {
+        return (await this.pubkey()).toBase58();
+    }
+    async getAgent(wallet) {
+        const p = await this.program();
+        const walletPubkey = new anchor.web3.PublicKey(wallet);
+        const agentPda = getAgentPda(p.programId, walletPubkey);
+        try {
+            const acct = await p.account.agentAccount.fetch(agentPda);
+            return {
+                exists: true,
+                wallet,
+                clipsBalance: acct.clipsBalance.toNumber(),
+                efficiencyTier: acct.efficiencyTier,
+                tasksCompleted: acct.tasksCompleted,
+                registeredAt: acct.registeredAt?.toNumber?.() ?? acct.registeredAt,
+                lastActiveAt: acct.lastActiveAt?.toNumber?.() ?? acct.lastActiveAt,
+                invitesSent: acct.invitesSent,
+                invitesRedeemed: acct.invitesRedeemed,
+                invitedBy: this.isZeroPubkey(acct.invitedBy) ? null : this.asPubkeyStr(acct.invitedBy),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getTask(taskId) {
+        const p = await this.program();
+        const taskPda = getTaskPda(p.programId, taskId);
+        try {
+            const acct = await p.account.taskRecord.fetch(taskPda);
+            return this.mapTask(acct);
+        }
+        catch {
+            return null;
+        }
+    }
+    async getClaim(taskId, agent) {
+        const p = await this.program();
+        const agentPubkey = new anchor.web3.PublicKey(agent);
+        const claimPda = getClaimPda(p.programId, taskId, agentPubkey);
+        try {
+            const acct = await p.account.claimRecord.fetch(claimPda);
+            return {
+                exists: true,
+                taskId: acct.taskId,
+                agent,
+                proofCid: fromFixedBytes(acct.proofCid),
+                clipsAwarded: acct.clipsAwarded.toNumber(),
+                completedAt: acct.completedAt?.toNumber?.() ?? acct.completedAt,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getInvite(inviter) {
+        const p = await this.program();
+        const inviterPubkey = new anchor.web3.PublicKey(inviter);
+        const invitePda = getInvitePda(p.programId, inviterPubkey);
+        try {
+            const acct = await p.account.inviteRecord.fetch(invitePda);
+            return {
+                exists: true,
+                inviterWallet: this.asPubkeyStr(acct.inviterWallet),
+                invitesRedeemed: acct.invitesRedeemed,
+                createdAt: acct.createdAt?.toNumber?.() ?? acct.createdAt,
+                isActive: acct.isActive,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async listActiveTasks() {
+        const p = await this.program();
+        const activeFilter = {
+            memcmp: {
+                offset: TASK_IS_ACTIVE_OFFSET,
+                bytes: bs58.encode(Buffer.from([1])),
+            },
+        };
+        const tasks = await p.account.taskRecord.all([activeFilter]);
+        return tasks
+            .filter((t) => t.account.currentClaims < t.account.maxClaims)
+            .map((t) => this.mapTask(t.account));
+    }
+    async listDoableTasks(agentWallet, agentTier) {
+        const p = await this.program();
+        const agentPubkey = new anchor.web3.PublicKey(agentWallet);
+        const allActive = await this.listActiveTasks();
+        if (allActive.length === 0)
+            return [];
+        const tierEligible = allActive.filter((t) => agentTier >= t.minTier);
+        if (tierEligible.length === 0)
+            return [];
+        // Batch check claims
+        const claimPdas = tierEligible.map((t) => getClaimPda(p.programId, t.taskId, agentPubkey));
+        const connection = p.provider.connection;
+        const claimInfos = await connection.getMultipleAccountsInfo(claimPdas);
+        const unclaimed = tierEligible.filter((_t, idx) => !claimInfos[idx]);
+        // Check prerequisites
+        const gated = unclaimed.filter((t) => t.requiredTaskId !== null);
+        if (gated.length === 0)
+            return unclaimed;
+        const prereqPdas = gated.map((t) => getClaimPda(p.programId, t.requiredTaskId, agentPubkey));
+        const prereqInfos = await connection.getMultipleAccountsInfo(prereqPdas);
+        const doableGated = new Set();
+        gated.forEach((t, idx) => {
+            if (prereqInfos[idx])
+                doableGated.add(t.taskId);
+        });
+        return unclaimed.filter((t) => t.requiredTaskId === null || doableGated.has(t.taskId));
+    }
+    async registerAgent() {
+        const p = await this.program();
+        const pk = await this.pubkey();
+        const protocolPda = getProtocolPda(p.programId);
+        const agentPda = getAgentPda(p.programId, pk);
+        await p.methods
+            .registerAgent()
+            .accounts({
+            protocol: protocolPda,
+            agentAccount: agentPda,
+            agent: pk,
+            systemProgram: anchor.web3.SystemProgram.programId,
+        })
+            .rpc();
+        const agent = await p.account.agentAccount.fetch(agentPda);
+        return {
+            wallet: pk.toBase58(),
+            clipsBalance: agent.clipsBalance.toNumber(),
+            invitedBy: this.isZeroPubkey(agent.invitedBy) ? null : this.asPubkeyStr(agent.invitedBy),
+        };
+    }
+    async registerAgentWithInvite(inviteCode) {
+        const p = await this.program();
+        const pk = await this.pubkey();
+        const inviterPubkey = new anchor.web3.PublicKey(inviteCode);
+        const protocolPda = getProtocolPda(p.programId);
+        const agentPda = getAgentPda(p.programId, pk);
+        const inviterAgentPda = getAgentPda(p.programId, inviterPubkey);
+        const invitePda = getInvitePda(p.programId, inviterPubkey);
+        await p.methods
+            .registerAgentWithInvite(Array.from(inviterPubkey.toBuffer()))
+            .accounts({
+            protocol: protocolPda,
+            agentAccount: agentPda,
+            inviterAgent: inviterAgentPda,
+            inviteRecord: invitePda,
+            agent: pk,
+            systemProgram: anchor.web3.SystemProgram.programId,
+        })
+            .rpc();
+        const agent = await p.account.agentAccount.fetch(agentPda);
+        return {
+            wallet: pk.toBase58(),
+            clipsBalance: agent.clipsBalance.toNumber(),
+            invitedBy: this.isZeroPubkey(agent.invitedBy) ? null : this.asPubkeyStr(agent.invitedBy),
+        };
+    }
+    async createInvite() {
+        const p = await this.program();
+        const pk = await this.pubkey();
+        const agentPda = getAgentPda(p.programId, pk);
+        const invitePda = getInvitePda(p.programId, pk);
+        // Check if invite already exists
+        try {
+            const existing = await p.account.inviteRecord.fetch(invitePda);
+            const code = new anchor.web3.PublicKey(existing.inviteCode).toBase58();
+            return { inviteCode: code, invitesRedeemed: existing.invitesRedeemed };
+        }
+        catch {
+            // Invite doesn't exist yet — create it
+        }
+        await p.methods
+            .createInvite()
+            .accounts({
+            protocol: getProtocolPda(p.programId),
+            agentAccount: agentPda,
+            inviteRecord: invitePda,
+            agent: pk,
+            systemProgram: anchor.web3.SystemProgram.programId,
+        })
+            .rpc();
+        const invite = await p.account.inviteRecord.fetch(invitePda);
+        const code = new anchor.web3.PublicKey(invite.inviteCode).toBase58();
+        return { inviteCode: code, invitesRedeemed: invite.invitesRedeemed };
+    }
+    async submitProof(taskId, proofCid) {
+        const p = await this.program();
+        const pk = await this.pubkey();
+        const prov = await this.provider();
+        const taskPda = getTaskPda(p.programId, taskId);
+        const agentPda = getAgentPda(p.programId, pk);
+        const claimPda = getClaimPda(p.programId, taskId, pk);
+        const protocolPda = getProtocolPda(p.programId);
+        const task = await p.account.taskRecord.fetch(taskPda);
+        const submitBuilder = p.methods
+            .submitProof(taskId, toFixedBytes(proofCid, 64))
+            .accounts({
+            protocol: protocolPda,
+            task: taskPda,
+            agentAccount: agentPda,
+            claim: claimPda,
+            agent: pk,
+            systemProgram: anchor.web3.SystemProgram.programId,
+        });
+        if (task.requiredTaskId !== NO_PREREQ_TASK_ID) {
+            const prereqClaimPda = getClaimPda(p.programId, task.requiredTaskId, pk);
+            const prereqInfo = await prov.connection.getAccountInfo(prereqClaimPda);
+            if (!prereqInfo) {
+                throw new Error(`Task requires completing task ${task.requiredTaskId} first`);
+            }
+            submitBuilder.remainingAccounts([
+                { pubkey: prereqClaimPda, isWritable: false, isSigner: false },
+            ]);
+        }
+        await submitBuilder.rpc();
+        return { clipsAwarded: task.rewardClips.toNumber() };
+    }
+    async provisionWallet() {
+        if (WALLET_TYPE === "privy") {
+            await provisionPrivyWallet();
+        }
+    }
+    // =========================================================================
+    // Private helpers
+    // =========================================================================
+    mapTask(acct) {
+        return {
+            taskId: acct.taskId,
+            creator: this.asPubkeyStr(acct.creator),
+            title: fromFixedBytes(acct.title),
+            contentCid: fromFixedBytes(acct.contentCid),
+            rewardClips: acct.rewardClips.toNumber(),
+            maxClaims: acct.maxClaims,
+            currentClaims: acct.currentClaims,
+            isActive: acct.isActive,
+            createdAt: acct.createdAt?.toNumber?.() ?? acct.createdAt,
+            minTier: acct.minTier,
+            requiredTaskId: acct.requiredTaskId === NO_PREREQ_TASK_ID ? null : acct.requiredTaskId,
+        };
+    }
+    asPubkeyStr(value) {
+        if (typeof value === "string")
+            return value;
+        if (value instanceof anchor.web3.PublicKey)
+            return value.toBase58();
+        return new anchor.web3.PublicKey(value).toBase58();
+    }
+    isZeroPubkey(value) {
+        try {
+            const pk = value instanceof anchor.web3.PublicKey
+                ? value
+                : new anchor.web3.PublicKey(value);
+            return pk.toBuffer().equals(Buffer.alloc(32));
+        }
+        catch {
+            return true;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paper-clip/pc",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,6 +28,7 @@
     "bs58": "^5.0.0",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
+    "ethers": "^6.16.0",
     "ora": "^8.2.0"
   },
   "devDependencies": {