@bsv/simple-mcp 0.0.1

package/dist/tools/server-route.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServerRoute = generateServerRoute;
+function generateServerRoute(routeType) {
+    if (routeType === 'identity-registry') {
+        return `\`\`\`typescript
+// app/api/identity-registry/route.ts
+import { createIdentityRegistryHandler } from '@bsv/simple/server'
+const handler = createIdentityRegistryHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`
+
+**API endpoints:**
+- \`GET ?action=lookup&query=...\` → \`{ success, results: [{ tag, identityKey }] }\`
+- \`GET ?action=list&identityKey=...\` → \`{ success, tags: [{ tag, createdAt }] }\`
+- \`POST ?action=register\` body: \`{ tag, identityKey }\` → \`{ success, message, tag }\`
+- \`POST ?action=revoke\` body: \`{ tag, identityKey }\` → \`{ success, message, tag }\`
+
+**Custom config options:**
+\`\`\`typescript
+createIdentityRegistryHandler({
+  validateTag: (tag) => tag.startsWith('@') ? null : 'Must start with @',
+  maxTagsPerIdentity: 3
+})
+\`\`\``;
+    }
+    if (routeType === 'did-resolver') {
+        return `\`\`\`typescript
+// app/api/resolve-did/route.ts
+import { createDIDResolverHandler } from '@bsv/simple/server'
+const handler = createDIDResolverHandler()
+export const GET = handler.GET
+\`\`\`
+
+**API:** \`GET ?did=did:bsv:<txid>\` → \`DIDResolutionResult\`
+
+**Custom config options:**
+\`\`\`typescript
+createDIDResolverHandler({
+  resolverUrl: 'https://custom-resolver.com',  // nChain Universal Resolver by default
+  wocBaseUrl: 'https://api.whatsonchain.com',   // WoC fallback
+  resolverTimeout: 10000,                        // ms
+  maxHops: 100                                   // chain-following limit
+})
+\`\`\``;
+    }
+    if (routeType === 'server-wallet') {
+        return `\`\`\`typescript
+// app/api/server-wallet/route.ts
+import { createServerWalletHandler } from '@bsv/simple/server'
+const handler = createServerWalletHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`
+
+**API endpoints:**
+- \`GET ?action=create\` → \`{ success, serverIdentityKey, status }\`
+- \`GET ?action=status\` → \`{ success, saved, identityKey }\`
+- \`GET ?action=request&satoshis=1000\` → \`{ success, paymentRequest }\`
+- \`GET ?action=balance\` → \`{ success, totalOutputs, totalSatoshis }\`
+- \`GET ?action=outputs\` → \`{ success, outputs }\`
+- \`GET ?action=reset\` → \`{ success, message }\`
+- \`POST ?action=receive\` body: \`{ tx, senderIdentityKey, derivationPrefix, derivationSuffix, outputIndex }\`
+
+**Custom config options:**
+\`\`\`typescript
+createServerWalletHandler({
+  envVar: 'SERVER_PRIVATE_KEY',          // env var name
+  keyFile: '.server-wallet.json',        // file persistence
+  network: 'main',
+  defaultRequestSatoshis: 1000,
+  requestMemo: 'Payment to server'
+})
+\`\`\`
+
+Key persistence order: env var → file → auto-generate via \`generatePrivateKey()\`. No \`@bsv/sdk\` import needed.`;
+    }
+    if (routeType === 'credential-issuer') {
+        return `\`\`\`typescript
+// app/api/credential-issuer/route.ts  (no [[...path]] catch-all needed!)
+import { createCredentialIssuerHandler } from '@bsv/simple/server'
+const handler = createCredentialIssuerHandler({
+  schemas: [{
+    id: 'my-credential',
+    name: 'MyCredential',
+    fields: [
+      { key: 'name', label: 'Full Name', type: 'text', required: true },
+      { key: 'email', label: 'Email', type: 'email' },
+    ]
+  }]
+})
+export const GET = handler.GET, POST = handler.POST
+\`\`\`
+
+**API endpoints:**
+- \`GET ?action=info\` → \`{ certifierPublicKey, certificateType, schemas }\`
+- \`GET ?action=schema&id=...\` → schema details
+- \`GET ?action=status&serialNumber=...\` → revocation status
+- \`POST ?action=certify\` body: \`{ identityKey, schemaId, fields }\` → CertificateData
+- \`POST ?action=issue\` body: \`{ subjectKey, schemaId, fields }\` → \`{ credential }\`
+- \`POST ?action=verify\` body: \`{ credential }\` → \`{ verification }\`
+- \`POST ?action=revoke\` body: \`{ serialNumber }\` → \`{ txid }\`
+
+**Custom config options:**
+\`\`\`typescript
+createCredentialIssuerHandler({
+  schemas: [schemaConfig],
+  envVar: 'CREDENTIAL_ISSUER_KEY',         // env var for private key
+  keyFile: '.credential-issuer-key.json',  // file persistence
+  revocationStorePath: '.revocation-secrets.json'
+})
+\`\`\``;
+    }
+    // Default: show all routes
+    return `## All Server API Routes (Handler Factories)
+
+No boilerplate needed. No \`@bsv/sdk\` import. Each is 3 lines:
+
+\`\`\`typescript
+// app/api/identity-registry/route.ts
+import { createIdentityRegistryHandler } from '@bsv/simple/server'
+const handler = createIdentityRegistryHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`
+
+\`\`\`typescript
+// app/api/resolve-did/route.ts
+import { createDIDResolverHandler } from '@bsv/simple/server'
+const handler = createDIDResolverHandler()
+export const GET = handler.GET
+\`\`\`
+
+\`\`\`typescript
+// app/api/server-wallet/route.ts
+import { createServerWalletHandler } from '@bsv/simple/server'
+const handler = createServerWalletHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`
+
+\`\`\`typescript
+// app/api/credential-issuer/route.ts  (no [[...path]] needed!)
+import { createCredentialIssuerHandler } from '@bsv/simple/server'
+const handler = createCredentialIssuerHandler({
+  schemas: [{ id: 'my-cred', name: 'MyCred', fields: [{ key: 'name', label: 'Name', type: 'text', required: true }] }]
+})
+export const GET = handler.GET, POST = handler.POST
+\`\`\``;
+}

package/dist/tools/token.d.ts

@@ -0,0 +1 @@
+export declare function generateTokenHandler(operations: string[]): string;

package/dist/tools/token.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTokenHandler = generateTokenHandler;
+function generateTokenHandler(operations) {
+    const sections = [];
+    if (operations.includes('create')) {
+        sections.push(`### Create Token
+\`\`\`typescript
+async function createToken(wallet: BrowserWallet, data: any, basket = 'my-tokens') {
+  const result = await wallet.createToken({
+    data,
+    basket,
+    satoshis: 1
+  })
+
+  console.log('Token created:', result.txid)
+  console.log('Basket:', result.basket, '| Encrypted:', result.encrypted)
+  return result
+}
+
+// Usage:
+// await createToken(wallet, { type: 'loyalty', points: 100 })
+\`\`\``);
+    }
+    if (operations.includes('list')) {
+        sections.push(`### List Tokens
+\`\`\`typescript
+async function listTokens(wallet: BrowserWallet, basket = 'my-tokens') {
+  const tokens = await wallet.listTokenDetails(basket)
+
+  for (const token of tokens) {
+    console.log(\`[\${token.outpoint}] \${token.satoshis} sats\`, token.data)
+  }
+
+  return tokens
+}
+\`\`\``);
+    }
+    if (operations.includes('send')) {
+        sections.push(`### Send Token
+\`\`\`typescript
+async function sendToken(
+  wallet: BrowserWallet,
+  basket: string,
+  outpoint: string,
+  recipientKey: string
+) {
+  const result = await wallet.sendToken({ basket, outpoint, to: recipientKey })
+  console.log('Token sent:', result.txid)
+  return result
+}
+\`\`\``);
+    }
+    if (operations.includes('redeem')) {
+        sections.push(`### Redeem Token
+\`\`\`typescript
+async function redeemToken(wallet: BrowserWallet, basket: string, outpoint: string) {
+  const result = await wallet.redeemToken({ basket, outpoint })
+  console.log('Token redeemed:', result.txid)
+  return result
+}
+\`\`\``);
+    }
+    if (operations.includes('messagebox')) {
+        sections.push(`### Send Token via MessageBox
+\`\`\`typescript
+async function sendTokenViaMessageBox(
+  wallet: BrowserWallet,
+  basket: string,
+  outpoint: string,
+  recipientKey: string
+) {
+  const result = await wallet.sendTokenViaMessageBox({ basket, outpoint, to: recipientKey })
+  console.log('Token sent via MessageBox:', result.txid)
+  return result
+}
+
+async function receiveTokens(wallet: BrowserWallet, targetBasket = 'received-tokens') {
+  const incoming = await wallet.listIncomingTokens()
+  console.log(\`\${incoming.length} incoming tokens\`)
+
+  for (const token of incoming) {
+    const accepted = await wallet.acceptIncomingToken(token, targetBasket)
+    console.log('Accepted token from:', accepted.sender)
+  }
+
+  return incoming.length
+}
+\`\`\``);
+    }
+    return sections.join('\n\n');
+}

package/dist/tools/wallet.d.ts

@@ -0,0 +1 @@
+export declare function generateWalletSetup(target: string, framework: string): string;

package/dist/tools/wallet.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWalletSetup = generateWalletSetup;
+function generateWalletSetup(target, framework) {
+    if (target === 'browser') {
+        if (framework === 'nextjs') {
+            return `\`\`\`typescript
+'use client'
+import { useState } from 'react'
+import { createWallet, type BrowserWallet } from '@bsv/simple/browser'
+
+export default function WalletProvider({ children }: { children: React.ReactNode }) {
+  const [wallet, setWallet] = useState<BrowserWallet | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  const connect = async () => {
+    try {
+      setError(null)
+      const w = await createWallet()
+      setWallet(w)
+    } catch (e) {
+      setError((e as Error).message)
+    }
+  }
+
+  if (!wallet) {
+    return (
+      <div>
+        <button onClick={connect}>Connect Wallet</button>
+        {error && <p style={{ color: 'red' }}>{error}</p>}
+      </div>
+    )
+  }
+
+  return (
+    <div>
+      <p>Connected: {wallet.getIdentityKey().substring(0, 20)}...</p>
+      <p>Address: {wallet.getAddress()}</p>
+      {children}
+    </div>
+  )
+}
+\`\`\``;
+        }
+        if (framework === 'react') {
+            return `\`\`\`typescript
+import { useState, useEffect } from 'react'
+import { createWallet, type BrowserWallet } from '@bsv/simple/browser'
+
+export function useWallet() {
+  const [wallet, setWallet] = useState<BrowserWallet | null>(null)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const connect = async () => {
+    try {
+      setLoading(true)
+      setError(null)
+      const w = await createWallet()
+      setWallet(w)
+    } catch (e) {
+      setError((e as Error).message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return { wallet, loading, error, connect }
+}
+\`\`\``;
+        }
+        return `\`\`\`typescript
+import { createWallet } from '@bsv/simple/browser'
+
+async function main() {
+  const wallet = await createWallet()
+  console.log('Connected:', wallet.getIdentityKey())
+  console.log('Address:', wallet.getAddress())
+  console.log('Status:', wallet.getStatus())
+}
+
+main().catch(console.error)
+\`\`\``;
+    }
+    // Server target
+    if (framework === 'nextjs') {
+        return `\`\`\`typescript
+// app/api/server-wallet/route.ts — Simplified with handler factory
+import { createServerWalletHandler } from '@bsv/simple/server'
+const handler = createServerWalletHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`
+
+Handles lazy-init singleton, key persistence, and all actions automatically.
+
+**Key persistence order:**
+1. \`process.env.SERVER_PRIVATE_KEY\` — Environment variable (production)
+2. \`.server-wallet.json\` file — Persisted from previous run (development)
+3. Auto-generated via \`generatePrivateKey()\` — Fresh key (first run)
+
+**API endpoints:**
+- \`GET ?action=create\` → server identity key + status
+- \`GET ?action=request&satoshis=1000\` → BRC-29 payment request
+- \`GET ?action=balance\` → output count + total satoshis
+- \`POST ?action=receive\` body: \`{ tx, senderIdentityKey, derivationPrefix, derivationSuffix, outputIndex }\`
+
+No \`@bsv/sdk\` import needed. Add \`.server-wallet.json\` to \`.gitignore\`.`;
+    }
+    return `\`\`\`typescript
+import { ServerWallet, generatePrivateKey } from '@bsv/simple/server'
+
+async function main() {
+  const privateKey = process.env.SERVER_PRIVATE_KEY || generatePrivateKey()
+
+  const wallet = await ServerWallet.create({
+    privateKey,
+    network: 'main',
+    storageUrl: 'https://storage.babbage.systems'
+  })
+
+  console.log('Server wallet ready:', wallet.getIdentityKey())
+  console.log('Status:', wallet.getStatus())
+}
+
+main().catch(console.error)
+\`\`\``;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@bsv/simple-mcp",
+  "version": "0.0.1",
+  "description": "MCP server for @bsv/simple — AI-assisted BSV blockchain development",
+  "main": "dist/index.js",
+  "bin": {
+    "simple-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "bsv",
+    "blockchain",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "claude",
+    "bitcoin"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bsv-blockchain/simple-mcp.git"
+  },
+  "homepage": "https://github.com/bsv-blockchain/simple-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/bsv-blockchain/simple-mcp/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0"
+  }
+}