dropclaw 1.0.0 → 1.2.0

package/README.md

@@ -1,69 +1,116 @@
-# dropclaw
+# DropClaw
 
-Permanent encrypted on-chain storage for AI agents. Store files on Monad blockchain with AES-256-GCM encryption.
+**Permanent encrypted on-chain storage for AI agents on Monad blockchain with x402 payments.**
 
-## Install
+DropClaw gives AI agents a way to store files permanently on-chain. Files are compressed and encrypted client-side (AES-256-GCM) before upload — the server never sees plaintext. It's a blind encrypted relay. Files go directly on-chain as Monad calldata — DropClaw never stores user files. Encryption keys stay with the user.
 
+## Quick Start
+
+### 1. Install
 ```bash
 npm install dropclaw
 ```
 
-## Usage
+### 2. Connect to Claude Code
+```bash
+claude mcp add dropclaw -- npx dropclaw-mcp
+```
 
-```js
-const { VaultClient } = require('dropclaw');
+### 3. Use Storage
 
-const client = new VaultClient({ gatewayUrl: 'https://dropclaw.cloud' });
+Your agent now has 5 MCP tools:
 
-// Store a file
-const result = await client.store(fileBuffer, {
-  paymentHeader: base64PaymentHeader
-});
-// result.skillFile — JSON with tx hashes for reconstruction
-// result.key — hex-encoded AES-256 encryption key (keep safe!)
-// result.fileId — unique file identifier
+| Tool | Description |
+|------|-------------|
+| `dropclaw_payment_options` | Get x402 payment requirements (MON, SOL, USDC) |
+| `dropclaw_store` | Store encrypted file on Monad (requires payment) |
+| `dropclaw_retrieve` | Retrieve and decrypt a file (free) |
+| `dropclaw_pricing` | Get cost estimates for a file size |
+| `dropclaw_list` | List locally stored files and keys |
 
-// Retrieve a file
-const original = await client.retrieve(result.skillFile, result.key);
-// original === your file, byte-for-byte identical
+## How It Works
 
-// Estimate cost
-const pricing = await client.estimateCost(fileBuffer.length);
-```
+1. Agent compresses (zlib) and encrypts (AES-256-GCM) files client-side
+2. Calls `dropclaw_payment_options` to get payment addresses and amounts
+3. Sends payment on-chain (MON on Monad, SOL on Solana, or USDC on Base)
+4. Calls `dropclaw_store` with the payment tx hash and encrypted blob
+5. DropClaw chunks the blob into segments and stores each as calldata on Monad
+6. Agent receives a file ID — encryption key is saved locally in `~/.dropclaw/keys.json`
+7. Call `dropclaw_retrieve` with the file ID to fetch and decrypt (free)
+
+## Pricing
+
+- **Storage:** $30 USD service fee + Monad gas costs
+- **Retrieval:** Always free
+- **Syntek subscribers:** [Syntek](https://github.com/timowhite88/farnsworth-syntek) subscribers ($100/90 days) get DropClaw access for Syntek memory uploads (gas only, no service fee)
+- **50% of fees** go to FARNS token buybacks
+
+## Payment Options
+
+| Network | Asset | Pay-To |
+|---------|-------|--------|
+| Monad (eip155:143) | MON (native) | `0xC86E4a0b90874d8081276AE13e830e23C726229e` |
+| Solana | SOL (native) | `9cQMUBgEPzunpzkjQxV2TMKUUHPFqAHWzNGw9dBzZeSc` |
+| Base (eip155:8453) | USDC | `0xC86E4a0b90874d8081276AE13e830e23C726229e` |
+
+## API Endpoints
 
-## Async Upload Polling
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/vault/store` | Store encrypted file (x402 payment required) |
+| POST | `/vault/retrieve/{id}` | Retrieve encrypted file (free) |
+| GET | `/vault/pricing?size=N` | Cost estimates with live chain prices |
+| GET | `/.well-known/x402` | x402 discovery manifest |
+| GET | `/skill` | DropClaw skill file |
+| GET | `/openai-tools` | OpenAI function calling definitions |
+| GET | `/claude-tools` | Claude tool definitions |
 
-Large files are processed asynchronously. The SDK handles polling automatically:
+## Programmatic Usage
 
-```js
-// store() automatically polls for completion
-const result = await client.store(largeFileBuffer, { paymentHeader });
+```javascript
+const { DropClawClient } = require('dropclaw');
 
-// Or poll manually
-const { jobId } = await someAsyncOperation();
-const completed = await client.waitForCompletion(jobId, {
-  pollInterval: 2000,  // ms between polls (default: 2000)
-  timeout: 300000      // max wait time in ms (default: 300000)
+const client = new DropClawClient({
+  apiKey: 'your-api-key'  // or set DROPCLAW_API_KEY env var
 });
-```
 
-## API
+// Get pricing
+const pricing = await client.pricing(1000000); // 1MB file
+console.log(pricing.totalEstimateUSD); // ~$30.01
 
-### `new VaultClient({ gatewayUrl })`
-Create a client connected to a DropClaw gateway.
+// Store a file (after sending payment on-chain)
+const result = await client.store({
+  content: Buffer.from('hello world'),
+  fileName: 'test.txt',
+  paymentTxHash: '0x...',
+  paymentNetwork: 'eip155:143'
+});
+console.log(result.fileId); // Save this!
 
-### `client.store(fileBuffer, options)`
-Compress, encrypt, and upload a file. Returns `{ skillFile, key, fileId }`.
+// Retrieve (free)
+const file = await client.retrieve(result.fileId);
+```
 
-### `client.retrieve(skillFile, key)`
-Download, decrypt, and decompress a file. Returns the original `Buffer`.
+## Credentials
 
-### `client.waitForCompletion(jobId, options)`
-Poll for async job completion. Returns the completed job data.
+Credentials are stored in `~/.dropclaw/vault.json`. Encryption keys are saved in `~/.dropclaw/keys.json`.
+
+```bash
+npx dropclaw setup    # Interactive setup
+npx dropclaw status   # Check connection
+npx dropclaw revoke   # Securely erase credentials
+```
 
-### `client.estimateCost(fileSize)`
-Get pricing estimate for a file size in bytes.
+Or use environment variables:
+```bash
+export DROPCLAW_API_KEY=dc_...
+export DROPCLAW_GATEWAY=https://dropclaw.cloud
+```
 
 ## License
 
-Proprietary — see LICENSE for details.
+Proprietary — Farnsworth Labs. All rights reserved.
+
+---
+
+[dropclaw.cloud](https://dropclaw.cloud)

package/SKILL.md

@@ -0,0 +1,119 @@
+# DropClaw Storage Service
+
+> Permanent encrypted on-chain storage for AI agents on Monad blockchain with x402 payments.
+
+## How It Works
+
+DropClaw is a blind encrypted relay — **files go directly on-chain as Monad calldata**. We never store user files. The flow is:
+
+1. Client compresses (zlib) and encrypts (AES-256-GCM) the file locally
+2. Encrypted blob is chunked and written as calldata transactions on Monad
+3. The encryption key stays with YOU — DropClaw never sees it
+4. To retrieve: fetch the encrypted blob from chain, decrypt locally with your key
+
+## Endpoint
+
+`https://dropclaw.cloud`
+
+## Authentication
+
+Storage operations require an API key:
+```
+Authorization: Bearer <api-key>
+```
+
+Retrieval is always free and does not require authentication.
+
+## MCP Integration
+
+```bash
+claude mcp add dropclaw -- npx dropclaw-mcp
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `dropclaw_payment_options` | Get x402 payment requirements before storing a file |
+| `dropclaw_store` | Encrypt and store file on Monad blockchain (requires payment tx hash) |
+| `dropclaw_retrieve` | Retrieve and decrypt a stored file using your encryption key (free) |
+| `dropclaw_pricing` | Get cost estimates for a given file size |
+| `dropclaw_list` | List locally stored file IDs and encryption keys |
+
+### Key Management
+
+When you store a file, `dropclaw_store` returns a `file_id` and saves the encryption key locally to `~/.dropclaw/keys.json`. **Both the file_id and key stay with you** — DropClaw does not store your keys. If you lose them, your data cannot be recovered.
+
+When you retrieve a file, `dropclaw_retrieve` will:
+1. Fetch the encrypted blob from Monad blockchain
+2. Look up the encryption key in your local `keys.json` (or use the `encryption_key` parameter you provide)
+3. Decrypt (AES-256-GCM) and decompress (zlib inflate) the data
+4. Return the original plaintext content
+
+## REST API
+
+### Public (No Auth)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/vault/pricing?size=N` | Cost estimate for N bytes |
+| `GET` | `/.well-known/x402` | x402 discovery manifest |
+| `GET` | `/skill` | This file |
+| `GET` | `/openai-tools` | OpenAI function calling definitions |
+| `GET` | `/claude-tools` | Claude tool definitions |
+
+### Authenticated
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `POST` | `/vault/store` | Store encrypted file — `{ content_base64, file_name, payment_tx_hash, payment_network }` |
+| `POST` | `/vault/retrieve/{id}` | Retrieve encrypted blob from chain (free) |
+
+## x402 Payment Flow
+
+1. **Get pricing** — `GET /vault/pricing?size=<bytes>`
+2. **Send payment** — Transfer exact amount to the `payTo` address on your preferred chain
+3. **Store file** — `POST /vault/store` with `payment_tx_hash` and `payment_network`
+4. **Save your keys** — Store the returned `file_id` and your local encryption key securely
+5. **Retrieve anytime** — `POST /vault/retrieve/{id}` (free, no payment needed)
+
+## Payment Options
+
+| Network | Chain ID | Asset | Pay-To Address |
+|---------|----------|-------|---------------|
+| Monad | eip155:143 | MON (native) | `0xC86E4a0b90874d8081276AE13e830e23C726229e` |
+| Solana | solana:5eykt4... | SOL (native) | `9cQMUBgEPzunpzkjQxV2TMKUUHPFqAHWzNGw9dBzZeSc` |
+| Base | eip155:8453 | USDC | `0xC86E4a0b90874d8081276AE13e830e23C726229e` |
+
+## Pricing
+
+- **Service fee:** $30 USD + gas costs
+- **Gas costs:** Variable (depends on file size and Monad gas prices)
+- **Retrieval:** Always free
+- **Syntek subscribers:** Gas only (no service fee) — Syntek subscription ($100/90 days) includes DropClaw access for Syntek memory uploads. Users still pay Monad gas fees.
+- **50% of service fees** go to FARNS token buybacks
+
+## Encryption
+
+- **Algorithm:** AES-256-GCM
+- **Key generation:** Client-side, 32-byte random key — never transmitted to DropClaw
+- **IV:** 12-byte random — prepended to ciphertext
+- **Auth tag:** 16-byte GCM tag — prepended after IV
+- **Compression:** zlib deflate before encryption
+- **Wire format:** `[IV (12 bytes) | AuthTag (16 bytes) | Ciphertext]` → base64
+- **On-chain storage:** Encrypted blob chunked into segments, stored as Monad calldata
+- **Zero-knowledge:** Server never sees plaintext data or encryption keys
+
+## Example Usage
+
+```bash
+# Get pricing for 1MB file
+curl https://dropclaw.cloud/vault/pricing?size=1000000
+
+# Check x402 discovery
+curl https://dropclaw.cloud/.well-known/x402
+
+# Get tool definitions
+curl https://dropclaw.cloud/openai-tools
+curl https://dropclaw.cloud/claude-tools
+```

package/dist/client.js

@@ -0,0 +1,190 @@
+/**
+ * DropClaw v1.2.0
+ * (c) 2026 Farnsworth Labs — All rights reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying prohibited.
+ * This software is protected by international copyright law.
+ */
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+const DEFAULT_GATEWAY = "https://dropclaw.cloud";
+const VERSION = "1.2.0";
+
+class DropClawClient {
+  constructor(opts = {}) {
+    this.gateway = (opts.gateway || process.env.DROPCLAW_GATEWAY || DEFAULT_GATEWAY).replace(/\/+$/, "");
+    this.apiKey = opts.apiKey || process.env.DROPCLAW_API_KEY || null;
+    this._vaultDir = path.join(
+      process.env.HOME || process.env.USERPROFILE || "/tmp",
+      ".dropclaw"
+    );
+
+    if (!this.apiKey) {
+      this._loadVaultKey();
+    }
+    if (!this.apiKey) {
+      throw new Error(
+        "API key required. Set DROPCLAW_API_KEY env var, pass apiKey in constructor, " +
+        "or run: npx dropclaw setup"
+      );
+    }
+  }
+
+  _loadVaultKey() {
+    try {
+      // Try new name first, fall back to legacy
+      let vaultPath = path.join(this._vaultDir, "vault.json");
+      if (!fs.existsSync(vaultPath)) {
+        vaultPath = path.join(this._vaultDir, "vault.enc");
+      }
+      if (fs.existsSync(vaultPath)) {
+        const data = JSON.parse(fs.readFileSync(vaultPath, "utf8"));
+        if (data.apiKey) this.apiKey = data.apiKey;
+        if (data.gateway) this.gateway = data.gateway;
+      }
+    } catch {}
+  }
+
+  _headers() {
+    return {
+      "Content-Type": "application/json",
+      "X-Client-Version": VERSION,
+      "Authorization": `Bearer ${this.apiKey}`,
+    };
+  }
+
+  async _handle(resp) {
+    if (!resp.ok) {
+      const body = await resp.text();
+      let msg;
+      try { msg = JSON.parse(body).error || body; } catch { msg = body; }
+      throw new Error(msg);
+    }
+    return resp.json();
+  }
+
+  async _get(endpoint) {
+    const headers = this._headers();
+    delete headers["Content-Type"];
+    const resp = await fetch(`${this.gateway}${endpoint}`, { method: "GET", headers });
+    return this._handle(resp);
+  }
+
+  async _post(endpoint, body = {}) {
+    const resp = await fetch(`${this.gateway}${endpoint}`, {
+      method: "POST",
+      headers: this._headers(),
+      body: JSON.stringify(body),
+    });
+    return this._handle(resp);
+  }
+
+  // --- Public API ---
+
+  async pricing(fileSize) {
+    const resp = await fetch(`${this.gateway}/vault/pricing?size=${fileSize}`);
+    return this._handle(resp);
+  }
+
+  async getPaymentOptions(fileSize) {
+    return this.pricing(fileSize);
+  }
+
+  async store(opts = {}) {
+    if (!opts.paymentTxHash) {
+      throw new Error("paymentTxHash required. Call pricing() first, send payment, then store().");
+    }
+    if (!opts.filePath && !opts.content && !opts.contentBase64) {
+      throw new Error("Provide filePath, content, or contentBase64");
+    }
+
+    let contentBase64;
+    let keyHex = null;
+    const fileName = opts.fileName || (opts.filePath ? path.basename(opts.filePath) : "untitled");
+
+    if (opts.filePath) {
+      const raw = fs.readFileSync(opts.filePath);
+      const compressed = zlib.deflateSync(raw);
+      const key = crypto.randomBytes(32);
+      const iv = crypto.randomBytes(12);
+      const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+      const encrypted = Buffer.concat([cipher.update(compressed), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      contentBase64 = Buffer.concat([iv, tag, encrypted]).toString("base64");
+      keyHex = key.toString("hex");
+    } else if (opts.content) {
+      const raw = Buffer.isBuffer(opts.content) ? opts.content : Buffer.from(opts.content);
+      const compressed = zlib.deflateSync(raw);
+      const key = crypto.randomBytes(32);
+      const iv = crypto.randomBytes(12);
+      const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+      const encrypted = Buffer.concat([cipher.update(compressed), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      contentBase64 = Buffer.concat([iv, tag, encrypted]).toString("base64");
+      keyHex = key.toString("hex");
+    } else if (opts.contentBase64) {
+      contentBase64 = opts.contentBase64;
+    }
+
+    const result = await this._post("/vault/store", {
+      content_base64: contentBase64,
+      file_name: fileName,
+      payment_tx_hash: opts.paymentTxHash,
+      payment_network: opts.paymentNetwork || "eip155:143",
+    });
+
+    // Save key with file_id AFTER successful API response
+    if (keyHex) {
+      const fileId = result.fileId || result.file_id || null;
+      this._saveKey(fileName, keyHex, fileId);
+    }
+
+    return result;
+  }
+
+  async retrieve(fileId) {
+    return this._post(`/vault/retrieve/${fileId}`, {});
+  }
+
+  async list() {
+    try {
+      const keysPath = path.join(this._vaultDir, "keys.json");
+      if (fs.existsSync(keysPath)) {
+        return JSON.parse(fs.readFileSync(keysPath, "utf8"));
+      }
+    } catch {}
+    return [];
+  }
+
+  _saveKey(fileName, keyHex, fileId) {
+    try {
+      if (!fs.existsSync(this._vaultDir)) {
+        fs.mkdirSync(this._vaultDir, { recursive: true });
+      }
+      const keysPath = path.join(this._vaultDir, "keys.json");
+      let keys = [];
+      try { keys = JSON.parse(fs.readFileSync(keysPath, "utf8")); } catch {}
+      keys.push({
+        fileId: fileId || null,
+        fileName,
+        key: keyHex,
+        storedAt: new Date().toISOString(),
+      });
+      fs.writeFileSync(keysPath, JSON.stringify(keys, null, 2));
+    } catch (e) {
+      console.error("WARNING: Failed to save encryption key locally:", e.message);
+      console.error("Your encryption key is:", keyHex);
+      console.error("SAVE THIS KEY — without it, your data cannot be recovered.");
+    }
+  }
+
+  async x402Discovery() {
+    const resp = await fetch(`${this.gateway}/.well-known/x402`);
+    return this._handle(resp);
+  }
+}
+
+module.exports = { DropClawClient };

package/dist/mcp/credentials.js

@@ -0,0 +1,17 @@
+/**
+ * DropClaw Credential Manager v1.2.0
+ * (c) 2026 Farnsworth Labs — All rights reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying prohibited.
+ */
+const fs=require("fs"),path=require("path");
+const VD=path.join(process.env.HOME||process.env.USERPROFILE||"/tmp",".dropclaw");
+const VP=path.join(VD,"vault.json");
+const VP_LEGACY=path.join(VD,"vault.enc");
+function load(){try{if(fs.existsSync(VP))return JSON.parse(fs.readFileSync(VP,"utf8"));if(fs.existsSync(VP_LEGACY))return JSON.parse(fs.readFileSync(VP_LEGACY,"utf8"));return null}catch{return null}}
+function save(data){if(!fs.existsSync(VD))fs.mkdirSync(VD,{recursive:true});fs.writeFileSync(VP,JSON.stringify(data,null,2))}
+function getApiKey(){const v=load();return v?.apiKey||process.env.DROPCLAW_API_KEY||null}
+function getGateway(){const v=load();return v?.gateway||process.env.DROPCLAW_GATEWAY||"https://dropclaw.cloud"}
+function saveKey(fileName,keyHex,fileId){if(!fs.existsSync(VD))fs.mkdirSync(VD,{recursive:true});const kp=path.join(VD,"keys.json");let ks=[];try{ks=JSON.parse(fs.readFileSync(kp,"utf8"))}catch{}ks.push({fileId:fileId||null,fileName,key:keyHex,storedAt:new Date().toISOString()});fs.writeFileSync(kp,JSON.stringify(ks,null,2))}
+function getKeys(){const kp=path.join(VD,"keys.json");try{return JSON.parse(fs.readFileSync(kp,"utf8"))}catch{return[]}}
+function revoke(){const files=[VP,VP_LEGACY,path.join(VD,"keys.json")];for(const f of files){if(fs.existsSync(f))fs.unlinkSync(f)}}
+module.exports={load,save,getApiKey,getGateway,saveKey,getKeys,revoke};

package/dist/mcp/index.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * DropClaw MCP Server v1.2.0
+ * (c) 2026 Farnsworth Labs — All rights reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying prohibited.
+ */
+import{Server}from"@modelcontextprotocol/sdk/server/index.js";import{StdioServerTransport}from"@modelcontextprotocol/sdk/server/stdio.js";import{CallToolRequestSchema,ListToolsRequestSchema}from"@modelcontextprotocol/sdk/types.js";import fs from"fs";import path from"path";import crypto from"crypto";import zlib from"zlib";
+const G=process.env.DROPCLAW_GATEWAY||"https://dropclaw.cloud";const V="1.2.0";
+const VD=path.join(process.env.HOME||process.env.USERPROFILE||"/tmp",".dropclaw");
+function lk(){try{const p=path.join(VD,"vault.json");if(fs.existsSync(p)){return JSON.parse(fs.readFileSync(p,"utf8"))}}catch{}try{const p=path.join(VD,"vault.enc");if(fs.existsSync(p)){return JSON.parse(fs.readFileSync(p,"utf8"))}}catch{}return{}}
+function hd(){const v=lk();const h={"Content-Type":"application/json","X-Client-Version":V};if(v.apiKey)h["Authorization"]=`Bearer ${v.apiKey}`;if(process.env.DROPCLAW_API_KEY)h["Authorization"]=`Bearer ${process.env.DROPCLAW_API_KEY}`;return h}
+async function api(m,p,b){const u=`${G}${p}`;const o={method:m,headers:hd()};if(m==="GET")delete o.headers["Content-Type"];if(b)o.body=JSON.stringify(b);const r=await fetch(u,o);if(!r.ok){const t=await r.text();let msg;try{msg=JSON.parse(t).error||t}catch{msg=t}throw new Error(`${r.status}: ${msg}`)}return r.json()}
+function saveKey(fileName,keyHex,fileId){if(!fs.existsSync(VD))fs.mkdirSync(VD,{recursive:true});const kp=path.join(VD,"keys.json");let ks=[];try{ks=JSON.parse(fs.readFileSync(kp,"utf8"))}catch{}ks.push({fileId:fileId||null,fileName,key:keyHex,storedAt:new Date().toISOString()});fs.writeFileSync(kp,JSON.stringify(ks,null,2))}
+function getKeys(){const kp=path.join(VD,"keys.json");try{return JSON.parse(fs.readFileSync(kp,"utf8"))}catch{return[]}}
+const server=new Server({name:"dropclaw-mcp",version:V},{capabilities:{tools:{}}});
+server.setRequestHandler(ListToolsRequestSchema,async()=>({tools:[
+{name:"dropclaw_payment_options",description:"STEP 1: Get x402 payment requirements before storing a file. Returns exact amounts in MON, SOL, and USDC with pay-to addresses. Regular usage: $30 + gas. Syntek subscribers: gas only.",inputSchema:{type:"object",properties:{file_size:{type:"number",description:"File size in bytes"}},required:["file_size"]}},
+{name:"dropclaw_store",description:"STEP 2: Store a file permanently on Monad blockchain. Files go DIRECTLY on-chain as calldata — DropClaw never stores user files. The file is compressed (zlib) and encrypted (AES-256-GCM) client-side before upload. You MUST save the returned file_id and encryption key — these stay with YOU and are the only way to retrieve and decrypt later.",inputSchema:{type:"object",properties:{file_path:{type:"string",description:"Absolute path to file to store"},content_base64:{type:"string",description:"Base64-encoded content (alternative to file_path — must be pre-encrypted)"},file_name:{type:"string",description:"Original filename"},payment_tx_hash:{type:"string",description:"Transaction hash of on-chain payment"},payment_network:{type:"string",enum:["eip155:143","solana","eip155:8453"],description:"Payment network",default:"eip155:143"}},required:["payment_tx_hash"]}},
+{name:"dropclaw_retrieve",description:"Retrieve an encrypted file from Monad blockchain. FREE — no payment required. Returns the encrypted blob (base64). Decrypt with your encryption key using the wire format in SKILL.md.",inputSchema:{type:"object",properties:{file_id:{type:"string",description:"File ID returned from dropclaw_store"},save_to:{type:"string",description:"Path to save encrypted blob (optional)"}},required:["file_id"]}},
+{name:"dropclaw_pricing",description:"Get cost estimates for storing a file. Returns $30 USD service fee plus estimated gas costs. Syntek subscribers pay gas only.",inputSchema:{type:"object",properties:{file_size:{type:"number",description:"File size in bytes"}},required:["file_size"]}},
+{name:"dropclaw_list",description:"List all files stored via DropClaw with their encryption keys and file IDs saved locally.",inputSchema:{type:"object",properties:{}}}
+]}));
+server.setRequestHandler(CallToolRequestSchema,async(req)=>{const{name,arguments:args}=req.params;try{
+if(name==="dropclaw_payment_options"||name==="dropclaw_pricing"){const sz=args.file_size!==undefined?args.file_size:1000000;const r=await api("GET",`/vault/pricing?size=${sz}`);return{content:[{type:"text",text:JSON.stringify(r,null,2)}]}}
+if(name==="dropclaw_store"){if(!args.file_path&&!args.content_base64){return{content:[{type:"text",text:"Error: Provide either file_path or content_base64"}],isError:true}}let cb64=args.content_base64;let keyHex=null;const fn=args.file_name||(args.file_path?path.basename(args.file_path):"untitled");if(args.file_path&&!cb64){const raw=fs.readFileSync(args.file_path);const comp=zlib.deflateSync(raw);const key=crypto.randomBytes(32);const iv=crypto.randomBytes(12);const c=crypto.createCipheriv("aes-256-gcm",key,iv);const enc=Buffer.concat([c.update(comp),c.final()]);const tag=c.getAuthTag();cb64=Buffer.concat([iv,tag,enc]).toString("base64");keyHex=key.toString("hex")}
+const r=await api("POST","/vault/store",{content_base64:cb64,file_name:fn,payment_tx_hash:args.payment_tx_hash,payment_network:args.payment_network||"eip155:143"});if(keyHex&&r.fileId){saveKey(fn,keyHex,r.fileId)}else if(keyHex){saveKey(fn,keyHex,r.file_id||null)}
+return{content:[{type:"text",text:JSON.stringify(r,null,2)+"\n\n⚠️ IMPORTANT: Save the file_id and encryption key. These stay with YOU — DropClaw does not store your keys. Without them, your data cannot be recovered."}]}}
+if(name==="dropclaw_retrieve"){const r=await api("POST",`/vault/retrieve/${args.file_id}`,{});if(r.content_base64&&args.save_to){fs.writeFileSync(args.save_to,Buffer.from(r.content_base64,"base64"))}return{content:[{type:"text",text:JSON.stringify(r,null,2)}]}}
+if(name==="dropclaw_list"){return{content:[{type:"text",text:JSON.stringify(getKeys(),null,2)}]}}
+return{content:[{type:"text",text:`Unknown tool: ${name}`}],isError:true}}catch(e){return{content:[{type:"text",text:`Error: ${e.message}`}],isError:true}}});
+async function main(){const t=new StdioServerTransport();await server.connect(t)}
+main().catch(e=>{process.stderr.write(`DropClaw MCP fatal: ${e.message}\n`);process.exit(1)});

package/dist/mcp/setup.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * DropClaw Setup CLI v1.2.0
+ * (c) 2026 Farnsworth Labs — All rights reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying prohibited.
+ */
+const fs=require("fs"),path=require("path"),readline=require("readline");
+const V="1.2.0",G="https://dropclaw.cloud";
+const VD=path.join(process.env.HOME||process.env.USERPROFILE||"/tmp",".dropclaw");
+const VP=path.join(VD,"vault.json");
+function rl(){return readline.createInterface({input:process.stdin,output:process.stdout})}
+function ask(r,q){return new Promise(res=>{r.question(q,ans=>{res(ans.trim())})})}
+async function setup(){
+console.log(`\n  DropClaw Setup v${V}\n  ${"─".repeat(30)}\n`);
+const r=rl();
+const key=await ask(r,"  API Key (dc_...): ");
+if(!key){console.log("  Cancelled.");r.close();return}
+const gw=await ask(r,`  Gateway [${G}]: `)||G;
+r.close();
+if(!fs.existsSync(VD))fs.mkdirSync(VD,{recursive:true});
+const vault={apiKey:key,gateway:gw,createdAt:new Date().toISOString()};
+fs.writeFileSync(VP,JSON.stringify(vault,null,2));
+console.log(`\n  Credentials saved to ${VP}`);
+console.log("  Run 'npx dropclaw status' to verify.\n");
+try{const resp=await fetch(`${gw}/vault/pricing?size=1000`);const d=await resp.json();console.log(`  Connection OK — service fee: $${d.serviceFeeUSD}`)}catch(e){console.log(`  Warning: Could not reach ${gw} — ${e.message}`)}
+}
+async function status(){
+console.log(`\n  DropClaw Status v${V}\n  ${"─".repeat(30)}\n`);
+if(!fs.existsSync(VP)){const legacy=path.join(VD,"vault.enc");if(!fs.existsSync(legacy)){console.log("  No credentials found. Run: npx dropclaw setup\n");return}}
+let vault;
+try{vault=JSON.parse(fs.readFileSync(fs.existsSync(VP)?VP:path.join(VD,"vault.enc"),"utf8"))}catch(e){console.log(`  Error reading credentials: ${e.message}\n`);return}
+const gw=vault.gateway||G;
+console.log(`  Gateway: ${gw}`);
+console.log(`  API Key: ${vault.apiKey?.slice(0,6)}...`);
+console.log(`  Created: ${vault.createdAt||"unknown"}`);
+try{const resp=await fetch(`${gw}/vault/pricing?size=1000000`);const d=await resp.json();console.log(`  Service: Online`);console.log(`  Fee: $${d.serviceFeeUSD} + gas`);console.log(`  Chains: MON, SOL, USDC`)}catch(e){console.log(`  Service: Offline (${e.message})`)}
+const kp=path.join(VD,"keys.json");
+try{const ks=JSON.parse(fs.readFileSync(kp,"utf8"));console.log(`  Local keys: ${ks.length} files stored`)}catch{console.log("  Local keys: 0 files")}
+console.log();
+}
+async function revoke(){
+const files=[VP,path.join(VD,"vault.enc"),path.join(VD,"keys.json")];
+let erased=false;
+for(const f of files){if(fs.existsSync(f)){fs.unlinkSync(f);erased=true}}
+if(erased){console.log("\n  Local credentials removed.");console.log("  Note: On-chain data is immutable and cannot be deleted.");console.log("  If you removed keys.json, encrypted on-chain files are unrecoverable.\n")}
+else console.log("\n  No credentials found.\n");
+}
+const cmd=process.argv[2]||"setup";
+if(cmd==="setup")setup().catch(e=>console.error(e.message));
+else if(cmd==="status")status().catch(e=>console.error(e.message));
+else if(cmd==="revoke")revoke().catch(e=>console.error(e.message));
+else{console.log(`\n  DropClaw CLI v${V}\n\n  Usage:\n    npx dropclaw setup    Setup credentials\n    npx dropclaw status   Check connection\n    npx dropclaw revoke   Erase credentials\n`)}

package/package.json

@@ -1,17 +1,47 @@
 {
   "name": "dropclaw",
-  "version": "1.0.0",
-  "description": "DropClaw — Permanent Encrypted On-Chain Storage for AI Agents on Monad",
-  "main": "stub.js",
+  "version": "1.2.0",
+  "description": "DropClaw — Permanent encrypted on-chain storage for AI agents on Monad blockchain with x402 payments.",
+  "main": "dist/client.js",
+  "bin": {
+    "dropclaw": "./dist/mcp/setup.js",
+    "dropclaw-mcp": "./dist/mcp/index.mjs"
+  },
+  "scripts": {
+    "setup": "node dist/mcp/setup.js setup",
+    "status": "node dist/mcp/setup.js status"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timowhite88/dropclaw.git"
+  },
+  "homepage": "https://dropclaw.cloud",
+  "keywords": [
+    "dropclaw",
+    "blockchain",
+    "storage",
+    "encryption",
+    "monad",
+    "ai-agents",
+    "x402",
+    "on-chain",
+    "mcp",
+    "claude"
+  ],
   "files": [
-    "stub.js",
-    "README.md"
+    "dist/",
+    "SKILL.md"
   ],
-  "keywords": ["dropclaw", "blockchain", "storage", "encryption", "monad", "ai-agents", "x402", "on-chain"],
-  "author": "Farnsworth",
-  "license": "Proprietary",
-  "homepage": "https://dropclaw.cloud",
+  "license": "PROPRIETARY",
+  "author": "Farnsworth Labs <timowhite88@icloud.com>",
   "engines": {
     "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/stub.js

@@ -1,15 +0,0 @@
-/**
- * DropClaw — Permanent Encrypted On-Chain Storage for AI Agents
- *
- * This is the official npm listing for DropClaw.
- * Full SDK access is available via the DropClaw gateway.
- *
- * Website: https://dropclaw.cloud
- * Docs:    https://dropclaw.cloud/docs
- */
-
-module.exports = {
-  name: "dropclaw",
-  gateway: "https://dropclaw.cloud",
-  description: "Permanent encrypted on-chain storage for AI agents on Monad.",
-};