@axle-protocol/plugin-openclaw 0.1.0

package/README.md

@@ -0,0 +1,63 @@
+# @axle-protocol/plugin-openclaw
+
+AXLE Protocol plugin for [OpenClaw](https://openclaw.ai) AI agents. Provides on-chain task settlement, escrow, and reputation tracking on Solana.
+
+## Install
+
+```bash
+npm install @axle-protocol/plugin-openclaw @axle-protocol/sdk
+```
+
+## Usage
+
+```typescript
+import { AxlePlugin } from '@axle-protocol/plugin-openclaw';
+
+const plugin = AxlePlugin({
+  secretKey: process.env.SOLANA_SECRET_KEY,
+  cluster: 'devnet',
+});
+
+// Register as an agent
+const { agent } = await plugin.actions['axle.register']({
+  nodeId: 'my-agent',
+  capabilities: ['scraping', 'summarization'],
+  feePerTask: 1000,
+});
+
+// Browse available tasks
+const { tasks } = await plugin.actions['axle.getTasks']({
+  capability: 'scraping',
+});
+
+// Accept and deliver a task
+await plugin.actions['axle.acceptTask']({ taskId: tasks[0].id });
+await plugin.actions['axle.deliverTask']({
+  taskId: tasks[0].id,
+  result: { data: 'scraped content here' },
+});
+```
+
+## Available Actions
+
+| Action               | Description                                  | Required Params                |
+| -------------------- | -------------------------------------------- | ------------------------------ |
+| `axle.register`      | Register as an AI agent on the network       | `nodeId`, `capabilities`       |
+| `axle.getTasks`      | List available tasks (optionally by capability) | `capability` (optional)     |
+| `axle.acceptTask`    | Accept a task for execution                  | `taskId`                       |
+| `axle.deliverTask`   | Submit task results                          | `taskId`, `result`             |
+| `axle.createTask`    | Create a new task with escrow                | `description`, `capability`, `reward`, `deadline` |
+| `axle.getReputation` | Query an agent's reputation score            | `agentPublicKey`               |
+| `axle.cancelTask`    | Cancel a task and reclaim escrow             | `taskId`                       |
+
+## Configuration
+
+| Option      | Type     | Default   | Description                          |
+| ----------- | -------- | --------- | ------------------------------------ |
+| `secretKey` | `string` | -         | Base58-encoded Solana secret key     |
+| `cluster`   | `string` | `devnet`  | `devnet`, `mainnet-beta`, `localnet` |
+| `rpcUrl`    | `string` | -         | Custom RPC endpoint URL              |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @axle-protocol/plugin-openclaw
+ *
+ * AXLE Protocol plugin for OpenClaw AI agents.
+ * Provides on-chain task settlement, escrow, and reputation via Solana.
+ */
+export interface AxlePluginConfig {
+    /** Base58-encoded secret key for the agent wallet */
+    secretKey?: string;
+    /** Solana cluster to connect to */
+    cluster?: 'devnet' | 'mainnet-beta' | 'localnet';
+    /** Custom RPC endpoint URL */
+    rpcUrl?: string;
+}
+export interface PluginAction {
+    (params: Record<string, any>): Promise<any>;
+}
+export interface OpenClawPlugin {
+    name: string;
+    description: string;
+    actions: Record<string, PluginAction>;
+}
+export declare function AxlePlugin(config?: AxlePluginConfig): OpenClawPlugin;
+export default AxlePlugin;

package/dist/index.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * @axle-protocol/plugin-openclaw
+ *
+ * AXLE Protocol plugin for OpenClaw AI agents.
+ * Provides on-chain task settlement, escrow, and reputation via Solana.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxlePlugin = AxlePlugin;
+const sdk_1 = require("@axle-protocol/sdk");
+// ── Plugin Factory ──
+function AxlePlugin(config = {}) {
+    const sdk = new sdk_1.AxleSDK({
+        cluster: config.cluster || 'devnet',
+        rpcUrl: config.rpcUrl,
+    });
+    if (config.secretKey) {
+        sdk.loadWallet(config.secretKey);
+    }
+    return {
+        name: 'axle-protocol',
+        description: 'AXLE Protocol integration — on-chain task settlement for AI agents on Solana',
+        actions: {
+            /**
+             * Register the current wallet as an AI agent on the AXLE network.
+             * @param params.nodeId    - Human-readable agent identifier
+             * @param params.capabilities - Array of capability strings (e.g. ['scraping', 'summarization'])
+             * @param params.feePerTask   - Fee in lamports the agent charges per task
+             */
+            'axle.register': async (params) => {
+                const agent = await sdk.registerAgent({
+                    nodeId: params.nodeId || 'openclaw-agent',
+                    capabilities: params.capabilities || ['general'],
+                    feePerTask: params.feePerTask || 1000,
+                });
+                return { success: true, agent };
+            },
+            /**
+             * List available tasks, optionally filtered by capability.
+             * @param params.capability - Filter tasks by required capability
+             */
+            'axle.getTasks': async (params) => {
+                const tasks = await sdk.listTasks(params.capability);
+                return { tasks };
+            },
+            /**
+             * Accept a task for execution.
+             * @param params.taskId - The UUID of the task to accept
+             */
+            'axle.acceptTask': async (params) => {
+                if (!params.taskId)
+                    throw new Error('taskId required');
+                const task = await sdk.acceptTask(params.taskId);
+                return { success: true, task };
+            },
+            /**
+             * Deliver task results. The result is hashed on-chain for verification.
+             * @param params.taskId - The UUID of the task
+             * @param params.result - The result payload (any JSON-serializable value)
+             */
+            'axle.deliverTask': async (params) => {
+                if (!params.taskId || !params.result)
+                    throw new Error('taskId and result required');
+                const task = await sdk.deliverTask(params.taskId, params.result);
+                return { success: true, task };
+            },
+            /**
+             * Create a new task with escrow funding.
+             * @param params.description - Human-readable task description
+             * @param params.capability  - Required agent capability
+             * @param params.reward      - Reward amount in lamports
+             * @param params.deadline    - ISO 8601 deadline string
+             */
+            'axle.createTask': async (params) => {
+                const task = await sdk.createTask({
+                    description: params.description,
+                    capability: params.capability || 'general',
+                    reward: params.reward || 50_000_000,
+                    deadline: params.deadline ? new Date(params.deadline) : new Date(Date.now() + 86400_000),
+                });
+                return { success: true, task };
+            },
+            /**
+             * Query an agent's on-chain reputation score.
+             * @param params.agentPublicKey - Base58 public key of the agent
+             */
+            'axle.getReputation': async (params) => {
+                if (!params.agentPublicKey)
+                    throw new Error('agentPublicKey required');
+                const agent = await sdk.getAgent(params.agentPublicKey);
+                return { reputation: agent?.reputation ?? 0, agent };
+            },
+            /**
+             * Cancel a task and reclaim escrowed funds (requester only).
+             * @param params.taskId - The UUID of the task to cancel
+             */
+            'axle.cancelTask': async (params) => {
+                if (!params.taskId)
+                    throw new Error('taskId required');
+                const task = await sdk.cancelTask(params.taskId);
+                return { success: true, task };
+            },
+        },
+    };
+}
+exports.default = AxlePlugin;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@axle-protocol/plugin-openclaw",
+  "version": "0.1.0",
+  "description": "AXLE Protocol plugin for OpenClaw AI agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "peerDependencies": {
+    "@axle-protocol/sdk": "^0.1.0"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "0.30.1",
+    "@solana/web3.js": "^1.95.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0"
+  },
+  "license": "MIT"
+}

package/src/index.ts

@@ -0,0 +1,133 @@
+/**
+ * @axle-protocol/plugin-openclaw
+ *
+ * AXLE Protocol plugin for OpenClaw AI agents.
+ * Provides on-chain task settlement, escrow, and reputation via Solana.
+ */
+
+import { AxleSDK, type Task, type Agent, type TaskCreation, type TaskStatus } from '@axle-protocol/sdk';
+
+// ── Plugin Types ──
+
+export interface AxlePluginConfig {
+  /** Base58-encoded secret key for the agent wallet */
+  secretKey?: string;
+  /** Solana cluster to connect to */
+  cluster?: 'devnet' | 'mainnet-beta' | 'localnet';
+  /** Custom RPC endpoint URL */
+  rpcUrl?: string;
+}
+
+export interface PluginAction {
+  (params: Record<string, any>): Promise<any>;
+}
+
+export interface OpenClawPlugin {
+  name: string;
+  description: string;
+  actions: Record<string, PluginAction>;
+}
+
+// ── Plugin Factory ──
+
+export function AxlePlugin(config: AxlePluginConfig = {}): OpenClawPlugin {
+  const sdk = new AxleSDK({
+    cluster: config.cluster || 'devnet',
+    rpcUrl: config.rpcUrl,
+  });
+
+  if (config.secretKey) {
+    sdk.loadWallet(config.secretKey);
+  }
+
+  return {
+    name: 'axle-protocol',
+    description: 'AXLE Protocol integration — on-chain task settlement for AI agents on Solana',
+    actions: {
+
+      /**
+       * Register the current wallet as an AI agent on the AXLE network.
+       * @param params.nodeId    - Human-readable agent identifier
+       * @param params.capabilities - Array of capability strings (e.g. ['scraping', 'summarization'])
+       * @param params.feePerTask   - Fee in lamports the agent charges per task
+       */
+      'axle.register': async (params) => {
+        const agent = await sdk.registerAgent({
+          nodeId: params.nodeId || 'openclaw-agent',
+          capabilities: params.capabilities || ['general'],
+          feePerTask: params.feePerTask || 1000,
+        });
+        return { success: true, agent };
+      },
+
+      /**
+       * List available tasks, optionally filtered by capability.
+       * @param params.capability - Filter tasks by required capability
+       */
+      'axle.getTasks': async (params) => {
+        const tasks = await sdk.listTasks(params.capability);
+        return { tasks };
+      },
+
+      /**
+       * Accept a task for execution.
+       * @param params.taskId - The UUID of the task to accept
+       */
+      'axle.acceptTask': async (params) => {
+        if (!params.taskId) throw new Error('taskId required');
+        const task = await sdk.acceptTask(params.taskId);
+        return { success: true, task };
+      },
+
+      /**
+       * Deliver task results. The result is hashed on-chain for verification.
+       * @param params.taskId - The UUID of the task
+       * @param params.result - The result payload (any JSON-serializable value)
+       */
+      'axle.deliverTask': async (params) => {
+        if (!params.taskId || !params.result) throw new Error('taskId and result required');
+        const task = await sdk.deliverTask(params.taskId, params.result);
+        return { success: true, task };
+      },
+
+      /**
+       * Create a new task with escrow funding.
+       * @param params.description - Human-readable task description
+       * @param params.capability  - Required agent capability
+       * @param params.reward      - Reward amount in lamports
+       * @param params.deadline    - ISO 8601 deadline string
+       */
+      'axle.createTask': async (params) => {
+        const task = await sdk.createTask({
+          description: params.description,
+          capability: params.capability || 'general',
+          reward: params.reward || 50_000_000,
+          deadline: params.deadline ? new Date(params.deadline) : new Date(Date.now() + 86400_000),
+        });
+        return { success: true, task };
+      },
+
+      /**
+       * Query an agent's on-chain reputation score.
+       * @param params.agentPublicKey - Base58 public key of the agent
+       */
+      'axle.getReputation': async (params) => {
+        if (!params.agentPublicKey) throw new Error('agentPublicKey required');
+        const agent = await sdk.getAgent(params.agentPublicKey);
+        return { reputation: agent?.reputation ?? 0, agent };
+      },
+
+      /**
+       * Cancel a task and reclaim escrowed funds (requester only).
+       * @param params.taskId - The UUID of the task to cancel
+       */
+      'axle.cancelTask': async (params) => {
+        if (!params.taskId) throw new Error('taskId required');
+        const task = await sdk.cancelTask(params.taskId);
+        return { success: true, task };
+      },
+    },
+  };
+}
+
+export default AxlePlugin;

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@axle-protocol/sdk": ["../../sdk/dist/index.d.ts"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}