@1claw/openclaw-plugin 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@1claw/openclaw-plugin",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "OpenClaw plugin for 1claw — HSM-backed secret management, transaction signing, and Shroud LLM proxy integration for AI agents",
     "type": "module",
     "main": "src/index.ts",

package/src/client.ts

@@ -9,6 +9,7 @@ import type {
     SimulationResponse,
     BundleSimulationResponse,
     TransactionResponse,
+    SignTransactionResponse,
     AgentProfile,
     ApiErrorBody,
 } from "./types.js";
@@ -369,6 +370,49 @@ export class OneClawClient {
         );
     }
 
+    async signTransaction(
+        agentId: string,
+        tx: {
+            to: string;
+            value: string;
+            chain: string;
+            data?: string;
+            signing_key_path?: string;
+            nonce?: number;
+            gas_price?: string;
+            gas_limit?: number;
+            max_fee_per_gas?: string;
+            max_priority_fee_per_gas?: string;
+            simulate_first?: boolean;
+        },
+    ): Promise<SignTransactionResponse> {
+        return this.request<SignTransactionResponse>(
+            `${this.baseUrl}/v1/agents/${agentId}/transactions/sign`,
+            { method: "POST", body: JSON.stringify(tx) },
+        );
+    }
+
+    async listTransactions(
+        agentId: string,
+        opts?: { include_signed_tx?: boolean },
+    ): Promise<{ transactions: TransactionResponse[] }> {
+        const qs = opts?.include_signed_tx ? "?include_signed_tx=true" : "";
+        return this.request<{ transactions: TransactionResponse[] }>(
+            `${this.baseUrl}/v1/agents/${agentId}/transactions${qs}`,
+        );
+    }
+
+    async getTransaction(
+        agentId: string,
+        txId: string,
+        opts?: { include_signed_tx?: boolean },
+    ): Promise<TransactionResponse> {
+        const qs = opts?.include_signed_tx ? "?include_signed_tx=true" : "";
+        return this.request<TransactionResponse>(
+            `${this.baseUrl}/v1/agents/${agentId}/transactions/${txId}${qs}`,
+        );
+    }
+
     // ── Agent profile ────────────────────────────────────
 
     async getAgentProfile(): Promise<AgentProfile> {

package/src/commands/enroll.ts

@@ -0,0 +1,72 @@
+import type { ResolvedConfig } from "../config.js";
+
+interface EnrollResponse {
+    agent_id: string;
+    name: string;
+    message?: string;
+}
+
+export function enrollCommand(config: ResolvedConfig) {
+    return {
+        name: "oneclaw-enroll",
+        description: "Self-enroll a new 1claw agent. Usage: /oneclaw-enroll email@example.com [agent-name]",
+        acceptsArgs: true,
+        handler: async (ctx: { args?: string; commandBody: string }) => {
+            const args = (ctx.args ?? ctx.commandBody ?? "").trim();
+            const parts = args.split(/\s+/);
+            const email = parts[0];
+            const name = parts.slice(1).join(" ") || "openclaw-agent";
+
+            if (!email || !email.includes("@")) {
+                return {
+                    text: "Usage: /oneclaw-enroll your-email@example.com [agent-name]\n\nThis registers a new agent with 1claw. The API key will be emailed to you.",
+                };
+            }
+
+            try {
+                const res = await fetch(`${config.baseUrl}/v1/agents/enroll`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        name,
+                        human_email: email,
+                        description: "OpenClaw agent",
+                    }),
+                });
+
+                if (!res.ok) {
+                    let detail = `HTTP ${res.status}`;
+                    try {
+                        const body = (await res.json()) as { detail?: string };
+                        if (body.detail) detail = body.detail;
+                    } catch {
+                        /* use default */
+                    }
+                    return { text: `Enrollment failed: ${detail}` };
+                }
+
+                const data = (await res.json()) as EnrollResponse;
+                const lines = [
+                    "Agent enrolled successfully!",
+                    "",
+                    `Agent ID: ${data.agent_id}`,
+                    `Name: ${data.name}`,
+                    "",
+                    `Check ${email} for your API key. Then:`,
+                    "",
+                    "1. Create a vault and policy in the 1claw dashboard (https://1claw.xyz)",
+                    "2. Set these environment variables:",
+                    `   export ONECLAW_AGENT_ID="${data.agent_id}"`,
+                    '   export ONECLAW_AGENT_API_KEY="ocv_..."',
+                    '   export ONECLAW_VAULT_ID="<vault-id>"',
+                    "",
+                    "3. Restart OpenClaw to pick up the new credentials.",
+                ];
+                return { text: lines.join("\n") };
+            } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { text: `Enrollment error: ${msg}` };
+            }
+        },
+    };
+}

package/src/commands/index.ts

@@ -4,6 +4,15 @@ import type { ResolvedConfig } from "../config.js";
 import { statusCommand } from "./status.js";
 import { listCommand } from "./list.js";
 import { rotateCommand } from "./rotate.js";
+import { enrollCommand } from "./enroll.js";
+
+export function registerUnauthenticatedCommands(
+    api: PluginApi,
+    config: ResolvedConfig,
+): void {
+    api.registerCommand(enrollCommand(config));
+    api.logger.info("[1claw] Registered unauthenticated commands (/oneclaw-enroll)");
+}
 
 export function registerAllCommands(
     api: PluginApi,

package/src/config.ts

@@ -50,6 +50,7 @@ export function resolveConfig(pluginConfig?: RawPluginConfig): ResolvedConfig {
         apiKey:
             raw.apiKey ??
             process.env.ONECLAW_AGENT_API_KEY ??
+            process.env.ONECLAW_API_KEY ??
             undefined,
         agentId:
             raw.agentId ??

package/src/index.ts

@@ -3,7 +3,7 @@ import { resolveConfig } from "./config.js";
 import { registerAllTools } from "./tools/index.js";
 import { registerAllHooks } from "./hooks/index.js";
 import { registerAllServices } from "./services/index.js";
-import { registerAllCommands } from "./commands/index.js";
+import { registerAllCommands, registerUnauthenticatedCommands } from "./commands/index.js";
 import type { PluginApi } from "./types.js";
 
 interface FullConfig {
@@ -21,9 +21,12 @@ function register(api: PluginApi): void {
     const rawConfig = extractPluginConfig(api);
     const config = resolveConfig(rawConfig as Parameters<typeof resolveConfig>[0]);
 
+    // Always register commands that work without auth (e.g. enroll)
+    registerUnauthenticatedCommands(api, config);
+
     if (!config.apiKey) {
         api.logger.warn(
-            "[1claw] No API key configured. Set plugins.entries.1claw.config.apiKey or ONECLAW_AGENT_API_KEY env var.",
+            "[1claw] No API key configured. Set ONECLAW_AGENT_API_KEY (or ONECLAW_API_KEY) env var, or run /oneclaw-enroll to get started.",
         );
         return;
     }

package/src/tools/index.ts

@@ -16,6 +16,7 @@ import { grantAccessTool } from "./grant-access.js";
 import { shareSecretTool } from "./share-secret.js";
 import { simulateTransactionTool } from "./simulate-transaction.js";
 import { submitTransactionTool } from "./submit-transaction.js";
+import { signTransactionTool } from "./sign-transaction.js";
 
 type ToolFactory = (client: OneClawClient) => PluginTool;
 
@@ -33,6 +34,7 @@ const ALL_TOOL_FACTORIES: ToolFactory[] = [
     shareSecretTool,
     simulateTransactionTool,
     submitTransactionTool,
+    signTransactionTool,
 ];
 
 function wrapWithSecurity(

package/src/tools/sign-transaction.ts

@@ -0,0 +1,70 @@
+import { Type } from "@sinclair/typebox";
+import type { OneClawClient } from "../client.js";
+import { OneClawApiError } from "../client.js";
+import type { PluginTool, ToolResult } from "../types.js";
+
+export function signTransactionTool(client: OneClawClient): PluginTool {
+    return {
+        name: "oneclaw_sign_transaction",
+        description:
+            "Sign an EVM transaction without broadcasting it. Returns the raw signed_tx hex and tx_hash so the caller can submit to any RPC. All agent guardrails (allowlists, value caps, daily limits) are enforced.",
+        parameters: Type.Object({
+            to: Type.String({ description: "Destination address (0x-prefixed)" }),
+            value: Type.String({ description: "Value in ETH (e.g. '0.01')" }),
+            chain: Type.String({ description: "Chain name or numeric chain ID" }),
+            data: Type.Optional(Type.String({ description: "Hex-encoded calldata" })),
+            signing_key_path: Type.Optional(Type.String({ description: "Vault path to signing key" })),
+            nonce: Type.Optional(Type.Integer({ description: "Transaction nonce (auto-resolved if omitted)" })),
+            gas_price: Type.Optional(Type.String({ description: "Gas price in wei (legacy mode)" })),
+            gas_limit: Type.Optional(Type.Integer({ description: "Gas limit (default: 21000)" })),
+            max_fee_per_gas: Type.Optional(Type.String({ description: "EIP-1559 max fee per gas in wei" })),
+            max_priority_fee_per_gas: Type.Optional(Type.String({ description: "EIP-1559 max priority fee in wei" })),
+            simulate_first: Type.Optional(Type.Boolean({ description: "Run simulation before signing (default: true)" })),
+        }),
+        optional: true,
+        execute: async (_id: unknown, params: Record<string, unknown>): Promise<ToolResult> => {
+            const agentId = client.agentId;
+            if (!agentId) {
+                return { content: [{ type: "text", text: "Error: sign_transaction requires agent authentication." }] };
+            }
+
+            try {
+                const result = await client.signTransaction(agentId, {
+                    to: params.to as string,
+                    value: params.value as string,
+                    chain: params.chain as string,
+                    data: params.data as string | undefined,
+                    signing_key_path: params.signing_key_path as string | undefined,
+                    nonce: params.nonce as number | undefined,
+                    gas_price: params.gas_price as string | undefined,
+                    gas_limit: params.gas_limit as number | undefined,
+                    max_fee_per_gas: params.max_fee_per_gas as string | undefined,
+                    max_priority_fee_per_gas: params.max_priority_fee_per_gas as string | undefined,
+                    simulate_first: (params.simulate_first as boolean) ?? true,
+                });
+
+                const lines: string[] = [
+                    `Transaction SIGNED (not broadcast)`,
+                    `Tx hash: ${result.tx_hash}`,
+                    `From: ${result.from}`,
+                    `To: ${result.to}`,
+                    `Chain: ${result.chain} (${result.chain_id})`,
+                    `Nonce: ${result.nonce}`,
+                    `Value: ${result.value_wei} wei`,
+                    `Signed tx: ${result.signed_tx}`,
+                ];
+
+                if (result.simulation_id) lines.push(`Simulation: ${result.simulation_id} (${result.simulation_status})`);
+
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            } catch (err) {
+                if (err instanceof OneClawApiError) {
+                    if (err.status === 400 || err.status === 403 || err.status === 422) {
+                        return { content: [{ type: "text", text: `Error: ${err.detail}` }] };
+                    }
+                }
+                throw err;
+            }
+        },
+    };
+}

package/src/types.ts

@@ -109,6 +109,22 @@ export interface TransactionResponse {
     simulation_status?: string;
 }
 
+export interface SignTransactionResponse {
+    signed_tx: string;
+    tx_hash: string;
+    from: string;
+    to: string;
+    chain: string;
+    chain_id: number;
+    nonce: number;
+    value_wei: string;
+    status: "sign_only";
+    simulation_id?: string;
+    simulation_status?: string;
+    max_fee_per_gas?: string;
+    max_priority_fee_per_gas?: string;
+}
+
 export interface AgentProfile {
     id: string;
     name: string;