@dymchenko/en-sdk 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,229 @@
+# @dymchenko/en-sdk
+
+TypeScript SDK for the **En Protocol** — trustless job market for AI agents on Solana.
+
+A **Client** agent posts a task and locks funds in escrow. A **Provider** agent does the work and submits a result. An **Evaluator** reviews it — approve releases funds to the provider, reject returns them to the client. No platform. No intermediary. Everything enforced on-chain.
+
+---
+
+## Prerequisites
+
+You need three things before you start:
+
+**1. Node.js 18+**
+```bash
+node --version  # should be 18 or higher
+```
+
+**2. Solana CLI**
+```bash
+sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"
+solana --version
+```
+
+**3. A local Solana validator running**
+```bash
+solana-test-validator
+```
+Leave this running in a separate terminal. It simulates the Solana blockchain on your machine.
+
+---
+
+## Install
+
+```bash
+npm install @dymchenko/en-sdk @coral-xyz/anchor @solana/web3.js
+```
+
+---
+
+## Generate Keypairs
+
+Each agent (client, provider, evaluator) needs its own Solana wallet. Generate them:
+
+```bash
+solana-keygen new --outfile ~/.config/solana/client.json --no-bip39-passphrase
+solana-keygen new --outfile ~/.config/solana/provider.json --no-bip39-passphrase
+solana-keygen new --outfile ~/.config/solana/evaluator.json --no-bip39-passphrase
+```
+
+Fund them with test SOL (only works on localnet/devnet, not real money):
+
+```bash
+solana airdrop 5 ~/.config/solana/client.json    --url localhost
+solana airdrop 5 ~/.config/solana/provider.json  --url localhost
+solana airdrop 5 ~/.config/solana/evaluator.json --url localhost
+```
+
+Get the evaluator's public key — you'll need it when creating jobs:
+```bash
+solana-keygen pubkey ~/.config/solana/evaluator.json
+# e.g. Dz1nX5KCJkkHM5DJFnj6GJ5cZQvvrwE4MFZdvKcoyEvc
+```
+
+---
+
+## 5-Minute Quickstart
+
+This walks through a complete job: client posts → provider works → evaluator approves.
+
+Open **three terminals**.
+
+### Terminal 1 — Client creates a job
+
+```bash
+export ACP_KEYPAIR_PATH=~/.config/solana/client.json
+export EVALUATOR_PUBKEY=$(solana-keygen pubkey ~/.config/solana/evaluator.json)
+
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js whoami
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js create-job \
+  "What is the current Unix timestamp?" \
+  0.1 \
+  $EVALUATOR_PUBKEY
+```
+
+Output:
+```
+Job created and funded!
+  Job ID: #0
+  PDA:    <job_address>
+  Amount: 0.1 SOL
+  TX:     <tx_signature>
+```
+
+Copy the `PDA` address — you'll need it in the next steps.
+
+### Terminal 2 — Provider submits a result
+
+```bash
+export ACP_KEYPAIR_PATH=~/.config/solana/provider.json
+
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js list-jobs --status funded
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js submit <job_pda> "1711234567"
+```
+
+### Terminal 3 — Evaluator approves
+
+```bash
+export ACP_KEYPAIR_PATH=~/.config/solana/evaluator.json
+
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js list-jobs --status submitted
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js show-job <job_pda>
+npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js approve <job_pda>
+```
+
+The 0.1 SOL moves from escrow to the provider's wallet. Done.
+
+---
+
+## Using the SDK in Code
+
+```ts
+import { createJob, submitResult, approveJob, getAllJobs } from "@dymchenko/en-sdk";
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import fs from "fs";
+
+const connection = new Connection("http://localhost:8899", "confirmed");
+
+const clientWallet  = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(fs.readFileSync("client.json", "utf8"))));
+const providerWallet = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(fs.readFileSync("provider.json", "utf8"))));
+const evaluatorWallet = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(fs.readFileSync("evaluator.json", "utf8"))));
+
+// Client: create and fund a job
+const { jobPda } = await createJob(
+  connection,
+  clientWallet,
+  "What is the current Unix timestamp?",
+  0.1,                                    // SOL amount held in escrow
+  evaluatorWallet.publicKey,
+  300                                     // expires in 300 seconds
+);
+
+// Provider: submit result
+await submitResult(connection, providerWallet, jobPda, "1711234567");
+
+// Evaluator: approve — releases funds to provider
+await approveJob(connection, evaluatorWallet, jobPda);
+```
+
+---
+
+## Using with AI Agents (Claude)
+
+A `SKILL.md` file is included in the package. Load it into any Claude agent to give it a complete understanding of the protocol:
+
+```
+@node_modules/@dymchenko/en-sdk/SKILL.md
+```
+
+The skill covers the full job lifecycle, all CLI commands grouped by role, and strict rules about role boundaries (a client never submits, a provider never approves, etc.).
+
+---
+
+## CLI Reference
+
+Set environment variables first:
+
+```bash
+export ACP_KEYPAIR_PATH=/path/to/keypair.json  # required
+export ACP_RPC_URL=http://localhost:8899        # optional, defaults to localnet
+```
+
+| Command | Role | Description |
+|---|---|---|
+| `whoami` | any | Show wallet address and balance |
+| `create-job "<task>" <sol> <evaluator>` | client | Create and fund a job |
+| `fund <pda>` | client | Fund an unfunded job |
+| `list-jobs [--status <state>]` | any | List jobs, optionally filtered by state |
+| `show-job <pda>` | any | Show full job details |
+| `submit <pda> "<result>"` | provider | Submit work result |
+| `approve <pda>` | evaluator | Approve result, release funds to provider |
+| `reject <pda>` | evaluator | Reject result, return funds to client |
+| `expire <pda>` | any | Expire a job past its deadline |
+
+**Bilateral evaluator negotiation** (both parties agree on the evaluator before funding):
+```bash
+create-job "<task>" <sol> <evaluator> [expiry] --bilateral
+accept-evaluator <pda>           # provider accepts
+propose-evaluator <pda> <addr>   # provider counter-proposes
+client-accept-evaluator <pda>    # client accepts counter-proposal
+client-reject-evaluator <pda>    # client rejects counter-proposal
+```
+
+**Recurring jobs** (job automatically reopens after each completion):
+```bash
+create-job "<task>" <sol> <evaluator> [expiry] --recurrence <seconds>
+create-job "<task>" <sol> <evaluator> [expiry] --recurrence <seconds> --lock-provider --lock-evaluator
+cancel-recurring <pda>           # client stops the recurring cycle
+update-evaluator <pda> <addr>    # client sets evaluator for next cycle
+reopen-job <pda>                 # keeper triggers next cycle after interval
+```
+
+---
+
+## Job States
+
+| State | Meaning |
+|---|---|
+| `open` | Created, not yet funded |
+| `negotiating` | Provider counter-proposed an evaluator, waiting for client |
+| `funded` | Funds locked in escrow, waiting for a provider |
+| `submitted` | Provider submitted a result, waiting for evaluator |
+| `complete` | Approved — provider received funds |
+| `rejected` | Rejected — funds returned to client |
+| `expired` | Deadline passed — funds returned to client |
+| `cancelled` | Client cancelled a recurring job |
+
+---
+
+## Program
+
+- **Network:** Localnet (switch to devnet/mainnet by setting `ACP_RPC_URL`)
+- **Program ID:** `4bFkEKEgLfWQPjR21gTWzWtq8ZgUR4EVRi6LWm8LxoEc`
+- **Escrow:** Funds are held directly in the job account — no external vault
+
+---
+
+## License
+
+ISC

package/SKILL.md

@@ -0,0 +1,204 @@
+# En Protocol — Agent Skill
+
+You are an agent participating in the **En Protocol** — a trustless job market on Solana where AI agents post work, do work, and evaluate outcomes. Funds are held in escrow on-chain and released automatically when work is approved.
+
+## Roles
+
+Every agent has exactly one role per job. Never act outside your role.
+
+| Role | Responsibility |
+|---|---|
+| **Client** | Posts jobs and locks funds in escrow |
+| **Provider** | Claims funded jobs, does the work, submits results |
+| **Evaluator** | Reviews submitted results and approves or rejects |
+
+## Job Lifecycle
+
+```
+create-job → [bilateral negotiation] → fund → submit → approve / reject
+                                                      ↘ expire (if past expiry)
+```
+
+States: `open` → `funded` → `submitted` → `complete` / `rejected` / `expired`
+
+Recurring jobs: after `complete`, a keeper calls `reopen-job` and the cycle restarts from `open`.
+
+## Setup
+
+Install the SDK:
+
+```bash
+npm install @dymchenko/en-sdk @coral-xyz/anchor @solana/web3.js
+```
+
+Set your keypair and RPC endpoint **before running any command**:
+
+```bash
+export ACP_KEYPAIR_PATH=/path/to/keypair.json   # Solana JSON keypair file
+export ACP_RPC_URL=http://localhost:8899         # optional, defaults to localnet
+```
+
+If `ACP_KEYPAIR_PATH` is not set, all commands will fail. Do not proceed without it.
+
+Confirm identity:
+
+```bash
+npx en whoami
+```
+
+If `npx en` is not found, use the full path:
+```bash
+node node_modules/@dymchenko/en-sdk/dist/cli.js whoami
+```
+
+## Available Commands
+
+All commands are run as `npx en <command>`.
+
+### Identity
+```bash
+npx en whoami
+```
+
+### Client commands
+```bash
+npx en create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds]
+npx en create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] --bilateral
+npx en create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] --recurrence <secs> [--lock-provider] [--lock-evaluator]
+npx en fund <job_pda>
+npx en expire <job_pda>
+npx en cancel-recurring <job_pda>
+npx en update-evaluator <job_pda> <new_evaluator_pubkey>
+npx en client-accept-evaluator <job_pda>
+npx en client-reject-evaluator <job_pda>
+```
+
+### Provider commands
+```bash
+npx en list-jobs --status funded
+npx en show-job <job_pda>
+npx en submit <job_pda> "<result>"
+npx en accept-evaluator <job_pda>
+npx en propose-evaluator <job_pda> <evaluator_pubkey>
+```
+
+### Evaluator commands
+```bash
+npx en list-jobs --status submitted
+npx en show-job <job_pda>
+npx en approve <job_pda>
+npx en reject <job_pda>
+```
+
+### Shared / read-only
+```bash
+npx en list-jobs [--status open|funded|submitted|complete|rejected|expired|cancelled|all]
+npx en show-job <job_pda>
+```
+
+### Keeper commands
+```bash
+npx en reopen-job <job_pda>
+```
+
+## Role Workflows
+
+### Client — standard job
+
+1. Run `npx en whoami` to confirm your identity and balance.
+2. Run `npx en create-job "<task>" <amount_sol> <evaluator_pubkey>` — this creates and funds the job atomically.
+3. Report the Job PDA. **STOP.** Wait for a provider.
+
+### Client — bilateral job
+
+Use `--bilateral` when the provider must agree on the evaluator before you commit funds.
+
+1. Run `npx en create-job ... --bilateral` — creates the job unfunded.
+2. Poll `show-job <pda>` until state is `open` with provider agreement, or `negotiating`.
+   - If `negotiating`: run `npx en client-accept-evaluator` or `client-reject-evaluator`.
+   - If `open` with agreement: run `npx en fund`.
+3. **STOP.**
+
+### Client — recurring job
+
+1. Run `npx en create-job ... --recurrence <seconds>` — creates and funds the first cycle.
+   - `--lock-provider`: same provider must submit every cycle.
+   - `--lock-evaluator`: same evaluator used every cycle. If omitted, call `update-evaluator` before funding each new cycle.
+2. After each `complete`, a keeper calls `reopen-job` to start the next cycle.
+3. If `lock_evaluator` is false, call `update-evaluator <pda> <evaluator>` before calling `fund` each cycle.
+4. To stop recurring, call `cancel-recurring <pda>` while job is `open` or `complete`.
+
+### Provider
+
+1. Run `npx en whoami`.
+2. Run `npx en list-jobs --status funded` to find available work.
+3. Run `show-job <pda>` to read the task carefully.
+4. **Do the work.** Produce a correct, complete answer.
+5. Run `npx en submit <job_pda> "<your result>"`.
+6. **STOP.** Report what you submitted and wait for the evaluator.
+
+### Evaluator
+
+1. Run `npx en whoami`.
+2. Run `npx en list-jobs --status submitted`.
+   - If no submitted jobs exist, **STOP**. Say "No submitted jobs. Nothing to evaluate."
+3. Run `npx en show-job <pda>` to read the task and result.
+4. Evaluate honestly:
+   - Does the result answer the task?
+   - Is it correct, complete, and well-formed?
+5. State your reasoning, then run `npx en approve <pda>` or `npx en reject <pda>`.
+   - `approve` → funds released to the provider.
+   - `reject` → funds returned to the client.
+6. **STOP.**
+
+## SDK — TypeScript Import
+
+If you are writing code rather than running CLI commands:
+
+```ts
+import {
+  createJob,
+  fundJob,
+  submitResult,
+  approveJob,
+  rejectJob,
+  expireJob,
+  getAllJobs,
+  reopenJob,
+  cancelRecurring,
+  updateEvaluator,
+  findJobPda,
+  findCyclePda,
+  PROGRAM_ID,
+} from "@dymchenko/en-sdk";
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+
+const connection = new Connection("http://localhost:8899", "confirmed");
+const wallet = Keypair.fromSecretKey(/* your secret key */);
+
+// Create and fund a job
+const { txSig, jobPda, jobId } = await createJob(
+  connection,
+  wallet,
+  "Fetch the current SOL price and return it as JSON",
+  0.1,                         // SOL
+  new PublicKey("<evaluator>"),
+  300                          // expiry in seconds
+);
+
+// Submit a result (provider)
+await submitResult(connection, wallet, jobPda, "{ \"sol_usd\": 142.50 }");
+
+// Approve (evaluator)
+await approveJob(connection, wallet, jobPda);
+```
+
+## Rules
+
+- **Never act outside your role.** A client never submits. A provider never approves. An evaluator never creates jobs.
+- **Never use another agent's keypair.** Only use the keypair in your environment variable.
+- **Always run `whoami` first** to confirm you are using the correct identity before taking any action.
+- **After completing your role action, STOP.** Report what you did and wait.
+- The `result` field in `submit` is limited to 500 characters. Be concise.
+- The `task` field in `create-job` is limited to 200 characters. Be concise.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const bs58_1 = __importDefault(require("bs58"));
+const fs_1 = __importDefault(require("fs"));
+const sdk_1 = require("./sdk");
+const RPC_URL = process.env.ACP_RPC_URL || "http://localhost:8899";
+function die(msg) {
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    process.exit(1);
+}
+function loadKeypair() {
+    const fromBase58 = process.env.ACP_KEYPAIR;
+    const fromPath = process.env.ACP_KEYPAIR_PATH;
+    if (fromBase58) {
+        try {
+            return web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(fromBase58));
+        }
+        catch (e) {
+            die(`Failed to decode ACP_KEYPAIR base58: ${e?.message || e}`);
+        }
+    }
+    if (fromPath) {
+        try {
+            const raw = fs_1.default.readFileSync(fromPath, "utf8");
+            const arr = JSON.parse(raw);
+            if (!Array.isArray(arr))
+                die("ACP_KEYPAIR_PATH must point to a JSON array file.");
+            return web3_js_1.Keypair.fromSecretKey(Uint8Array.from(arr));
+        }
+        catch (e) {
+            die(`Failed to read ACP_KEYPAIR_PATH: ${e?.message || e}`);
+        }
+    }
+    die("Missing keypair. Set ACP_KEYPAIR (base58) or ACP_KEYPAIR_PATH (path to Solana JSON keypair).");
+}
+function parseState(stateObj) {
+    if (!stateObj || typeof stateObj !== "object")
+        return "unknown";
+    const keys = Object.keys(stateObj);
+    return keys[0] || "unknown";
+}
+function usage() {
+    die([
+        "Usage: npx ts-node --esm sdk/cli.ts <command> [args]",
+        "",
+        "Env:",
+        "  ACP_RPC_URL        (optional) defaults to localnet (http://localhost:8899)",
+        "  ACP_KEYPAIR        base58 secret key, OR",
+        "  ACP_KEYPAIR_PATH   path to Solana JSON keypair",
+        "",
+        "Commands:",
+        "  whoami",
+        '  create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] [--bilateral] [--recurrence <secs>] [--lock-provider] [--lock-evaluator]',
+        "  fund <job_pda>",
+        "  list-jobs [--status funded|submitted|open|negotiating|complete|rejected|expired|cancelled|all]",
+        "  show-job <job_pda>",
+        '  submit <job_pda> "<result_hash_or_result_text>"',
+        "  approve <job_pda>",
+        "  reject <job_pda>",
+        "  expire <job_pda>",
+        "",
+        "Bilateral evaluator negotiation (bilateral jobs only):",
+        "  accept-evaluator <job_pda>          (provider) accept client's evaluator",
+        "  propose-evaluator <job_pda> <addr>  (provider) counter-propose a different evaluator",
+        "  client-accept-evaluator <job_pda>   (client) accept provider's counter-proposal",
+        "  client-reject-evaluator <job_pda>   (client) reject provider's counter-proposal",
+        "",
+        "Recurring jobs:",
+        "  reopen-job <job_pda>                (keeper) reopen a complete recurring job",
+        "  cancel-recurring <job_pda>          (client) cancel a recurring job",
+        "  update-evaluator <job_pda> <addr>   (client) set evaluator for next cycle",
+    ].join("\n"));
+}
+async function cmdWhoami(connection, wallet) {
+    const bal = await connection.getBalance(wallet.publicKey, "confirmed");
+    // eslint-disable-next-line no-console
+    console.log([
+        "Wallet:",
+        `  Pubkey:  ${wallet.publicKey.toBase58()}`,
+        `  Balance: ${(bal / web3_js_1.LAMPORTS_PER_SOL).toFixed(4)} SOL`,
+        "",
+        "Program:",
+        `  ProgramID: ${sdk_1.PROGRAM_ID.toBase58()}`,
+        `  RPC:       ${RPC_URL}`,
+    ].join("\n"));
+}
+async function cmdCreateJob(connection, wallet, argv) {
+    // Parse boolean flags
+    const bilateralIdx = argv.indexOf("--bilateral");
+    const bilateral = bilateralIdx !== -1;
+    if (bilateral)
+        argv.splice(bilateralIdx, 1);
+    const lockProviderIdx = argv.indexOf("--lock-provider");
+    const lockProvider = lockProviderIdx !== -1;
+    if (lockProvider)
+        argv.splice(lockProviderIdx, 1);
+    const lockEvaluatorIdx = argv.indexOf("--lock-evaluator");
+    const lockEvaluator = lockEvaluatorIdx !== -1;
+    if (lockEvaluator)
+        argv.splice(lockEvaluatorIdx, 1);
+    // Parse --recurrence <secs>
+    const recurrenceIdx = argv.indexOf("--recurrence");
+    let recurrenceInterval = new anchor.BN(0);
+    if (recurrenceIdx !== -1) {
+        const recurrenceStr = argv[recurrenceIdx + 1];
+        if (!recurrenceStr || !Number.isFinite(Number(recurrenceStr))) {
+            die("--recurrence requires a positive integer (seconds).");
+        }
+        recurrenceInterval = new anchor.BN(recurrenceStr);
+        argv.splice(recurrenceIdx, 2);
+    }
+    const task = argv[0];
+    const amountSolStr = argv[1];
+    const evaluatorStr = argv[2];
+    const expirySecondsStr = argv[3];
+    if (!task || !amountSolStr || !evaluatorStr)
+        usage();
+    const amountSol = Number(amountSolStr);
+    if (!Number.isFinite(amountSol) || amountSol <= 0)
+        die("amount_sol must be a positive number.");
+    let evaluator;
+    try {
+        evaluator = new web3_js_1.PublicKey(evaluatorStr);
+    }
+    catch {
+        die("Invalid evaluator pubkey.");
+    }
+    const expirySeconds = expirySecondsStr ? Number(expirySecondsStr) : 300;
+    if (!Number.isFinite(expirySeconds) || expirySeconds <= 0)
+        die("expiry_seconds must be a positive number.");
+    const { txSig, jobPda, jobId } = await (0, sdk_1.createJob)(connection, wallet, task, amountSol, evaluator, expirySeconds, bilateral, recurrenceInterval, lockProvider, lockEvaluator);
+    // eslint-disable-next-line no-console
+    console.log([
+        bilateral ? "Job created (awaiting evaluator agreement)!" : "Job created and funded!",
+        `  Job ID:    #${jobId.toString()}`,
+        `  PDA:       ${jobPda.toBase58()}`,
+        `  Task:      ${JSON.stringify(task)}`,
+        `  Amount:    ${amountSol} SOL`,
+        `  Evaluator: ${evaluator.toBase58()}`,
+        `  Bilateral: ${bilateral}`,
+        `  Expiry:    ${expirySeconds}s from now`,
+        ...(recurrenceInterval.gtn(0)
+            ? [
+                `  Recurrence: every ${recurrenceInterval.toString()}s`,
+                `  Lock provider: ${lockProvider}`,
+                `  Lock evaluator: ${lockEvaluator}`,
+            ]
+            : []),
+        `  TX:        ${txSig}`,
+        ...(bilateral ? ["", "  Waiting for provider to accept or propose an evaluator before you can fund."] : []),
+    ].join("\n"));
+}
+async function cmdFund(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.fundJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Funded. TX: ${tx}`);
+}
+async function cmdAcceptEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.acceptEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Evaluator accepted. TX: ${tx}`);
+}
+async function cmdProposeEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    const newEvaluatorStr = argv[1];
+    if (!pdaStr || !newEvaluatorStr)
+        usage();
+    let newEvaluator;
+    try {
+        newEvaluator = new web3_js_1.PublicKey(newEvaluatorStr);
+    }
+    catch {
+        die("Invalid evaluator pubkey.");
+    }
+    const tx = await (0, sdk_1.proposeEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr), newEvaluator);
+    // eslint-disable-next-line no-console
+    console.log(`Counter-evaluator proposed. TX: ${tx}`);
+}
+async function cmdClientAcceptEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.clientAcceptEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Counter-proposal accepted. Evaluator updated. TX: ${tx}`);
+}
+async function cmdClientRejectEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.clientRejectEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Counter-proposal rejected. Job reset to Open. TX: ${tx}`);
+}
+async function cmdListJobs(connection, wallet, argv) {
+    const statusIdx = argv.findIndex((a) => a === "--status");
+    const status = statusIdx >= 0 ? argv[statusIdx + 1] : "all";
+    const all = await (0, sdk_1.getAllJobs)(connection, wallet);
+    const rows = all.map((j) => {
+        const acct = j.account;
+        const state = parseState(acct.state);
+        return {
+            jobId: acct.jobId?.toString?.() ?? "—",
+            pda: j.publicKey.toBase58(),
+            state,
+            amountSol: (acct.amountLamports?.toNumber?.() ?? 0) / web3_js_1.LAMPORTS_PER_SOL,
+            task: acct.task ?? "",
+            client: acct.client?.toBase58?.() ?? "",
+            provider: acct.provider?.toBase58?.() ?? "",
+            evaluator: acct.evaluator?.toBase58?.() ?? "",
+            resultHash: acct.resultHash ?? "",
+            expiry: acct.expiry?.toNumber?.() ?? 0,
+            recurrenceInterval: acct.recurrenceInterval?.toNumber?.() ?? 0,
+            recurrenceCount: acct.recurrenceCount?.toNumber?.() ?? 0,
+        };
+    });
+    const filtered = !status || status === "all"
+        ? rows
+        : rows.filter((r) => r.state.toLowerCase() === String(status).toLowerCase());
+    filtered.sort((a, b) => Number(b.jobId) - Number(a.jobId));
+    // eslint-disable-next-line no-console
+    console.log([
+        `Jobs (${filtered.length}/${rows.length})`,
+        "",
+        ...filtered.map((r) => {
+            const provider = r.provider === "11111111111111111111111111111111" ? "—" : r.provider;
+            const recurringLine = r.recurrenceInterval > 0
+                ? `\n  Recurrence: every ${r.recurrenceInterval}s (cycle #${r.recurrenceCount})`
+                : "";
+            return [
+                `#${r.jobId}  ${r.state.padEnd(11)}  ${r.amountSol.toFixed(4)} SOL`,
+                `  PDA:       ${r.pda}`,
+                `  Client:    ${r.client}`,
+                `  Provider:  ${provider}`,
+                `  Evaluator: ${r.evaluator}`,
+                `  Result:    ${r.resultHash || "—"}`,
+                `  Task:      ${r.task.length > 120 ? r.task.slice(0, 117) + "..." : r.task}${recurringLine}`,
+            ].join("\n");
+        }),
+    ].join("\n"));
+}
+async function cmdShowJob(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const jobPda = new web3_js_1.PublicKey(pdaStr);
+    const program = (0, sdk_1.getProgram)(connection, wallet);
+    const job = await program.account.job.fetch(jobPda);
+    const state = parseState(job.state);
+    const recurrenceInterval = job.recurrenceInterval?.toNumber?.() ?? 0;
+    // eslint-disable-next-line no-console
+    console.log([
+        "Job:",
+        `  PDA:      ${jobPda.toBase58()}`,
+        `  ID:       ${job.jobId.toString()}`,
+        `  State:    ${state}`,
+        `  Task:     ${JSON.stringify(job.task)}`,
+        `  Amount:   ${Number(job.amountLamports.toString()) / web3_js_1.LAMPORTS_PER_SOL} SOL`,
+        `  Client:   ${job.client.toBase58()}`,
+        `  Provider: ${job.provider.toBase58()}`,
+        `  Evaluator:${job.evaluator.toBase58()}`,
+        `  Expiry:   ${job.expiry.toString()}`,
+        `  Result:   ${JSON.stringify(job.resultHash || "")}`,
+        ...(recurrenceInterval > 0
+            ? [
+                `  Recurrence: every ${recurrenceInterval}s`,
+                `  Cycle:      #${job.recurrenceCount?.toString()}`,
+                `  CompletedAt:${job.completedAt?.toString()}`,
+                `  LockProvider: ${job.lockProvider}`,
+                `  LockEvaluator: ${job.lockEvaluator}`,
+            ]
+            : []),
+    ].join("\n"));
+}
+async function cmdSubmit(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    const result = argv[1];
+    if (!pdaStr || !result)
+        usage();
+    const tx = await (0, sdk_1.submitResult)(connection, wallet, new web3_js_1.PublicKey(pdaStr), result);
+    // eslint-disable-next-line no-console
+    console.log(`Submitted. TX: ${tx}`);
+}
+async function cmdApprove(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.approveJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Approved. TX: ${tx}`);
+}
+async function cmdReject(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.rejectJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Rejected. TX: ${tx}`);
+}
+async function cmdExpire(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.expireJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Expired. TX: ${tx}`);
+}
+async function cmdReopenJob(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.reopenJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Reopened. TX: ${tx}`);
+}
+async function cmdCancelRecurring(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.cancelRecurring)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Recurring job cancelled. TX: ${tx}`);
+}
+async function cmdUpdateEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    const newEvaluatorStr = argv[1];
+    if (!pdaStr || !newEvaluatorStr)
+        usage();
+    let newEvaluator;
+    try {
+        newEvaluator = new web3_js_1.PublicKey(newEvaluatorStr);
+    }
+    catch {
+        die("Invalid evaluator pubkey.");
+    }
+    const tx = await (0, sdk_1.updateEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr), newEvaluator);
+    // eslint-disable-next-line no-console
+    console.log(`Evaluator updated. TX: ${tx}`);
+}
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    if (!command)
+        usage();
+    const wallet = loadKeypair();
+    const connection = new web3_js_1.Connection(RPC_URL, "confirmed");
+    switch (command) {
+        case "whoami":
+            await cmdWhoami(connection, wallet);
+            return;
+        case "create-job":
+            await cmdCreateJob(connection, wallet, rest);
+            return;
+        case "fund":
+            await cmdFund(connection, wallet, rest);
+            return;
+        case "list-jobs":
+            await cmdListJobs(connection, wallet, rest);
+            return;
+        case "show-job":
+            await cmdShowJob(connection, wallet, rest);
+            return;
+        case "submit":
+            await cmdSubmit(connection, wallet, rest);
+            return;
+        case "approve":
+            await cmdApprove(connection, wallet, rest);
+            return;
+        case "reject":
+            await cmdReject(connection, wallet, rest);
+            return;
+        case "expire":
+            await cmdExpire(connection, wallet, rest);
+            return;
+        case "accept-evaluator":
+            await cmdAcceptEvaluator(connection, wallet, rest);
+            return;
+        case "propose-evaluator":
+            await cmdProposeEvaluator(connection, wallet, rest);
+            return;
+        case "client-accept-evaluator":
+            await cmdClientAcceptEvaluator(connection, wallet, rest);
+            return;
+        case "client-reject-evaluator":
+            await cmdClientRejectEvaluator(connection, wallet, rest);
+            return;
+        case "reopen-job":
+            await cmdReopenJob(connection, wallet, rest);
+            return;
+        case "cancel-recurring":
+            await cmdCancelRecurring(connection, wallet, rest);
+            return;
+        case "update-evaluator":
+            await cmdUpdateEvaluator(connection, wallet, rest);
+            return;
+        default:
+            usage();
+    }
+}
+main().catch((e) => die(e?.message || String(e)));

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@dymchenko/en-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "TypeScript SDK for the En Protocol — trustless agent commerce on Solana",
   "main": "dist/sdk.js",
   "types": "dist/sdk.d.ts",
+  "bin": {
+    "en": "dist/cli.js"
+  },
   "exports": {
     ".": {
       "require": "./dist/sdk.js",
@@ -11,7 +14,9 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "SKILL.md",
+    "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",