@bsv/simple-mcp 0.0.1

package/dist/tools/credential.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCredentialIssuer = generateCredentialIssuer;
+function generateCredentialIssuer(schemaFields, revocation) {
+    const fieldsDef = schemaFields.map(f => `    { key: '${f.key}', label: '${f.label}', type: '${f.type}'${f.required ? ', required: true' : ''} }`).join(',\n');
+    const schemaId = 'custom-credential';
+    return `\`\`\`typescript
+import {
+  CredentialSchema,
+  CredentialIssuer,
+  ${revocation ? 'MemoryRevocationStore,' : ''}
+  toVerifiableCredential,
+  toVerifiablePresentation
+} from '@bsv/simple/browser'
+
+// 1. Define Schema
+const schema = new CredentialSchema({
+  id: '${schemaId}',
+  name: 'CustomCredential',
+  fields: [
+${fieldsDef}
+  ],
+  computedFields: (values) => ({
+    ...values,
+    issuedAt: new Date().toISOString()
+  })
+})
+
+// 2. Create Issuer
+const issuer = await CredentialIssuer.create({
+  privateKey: issuerPrivateKeyHex,
+  schemas: [schema.getConfig()],
+  revocation: {
+    enabled: ${revocation},
+    ${revocation ? `wallet: issuerWallet.getClient(),
+    store: new MemoryRevocationStore()` : ''}
+  }
+})
+
+console.log('Issuer DID:', issuer.getInfo().did)
+
+// 3. Issue a Credential
+async function issueCredential(
+  subjectKey: string,
+  fields: Record<string, string>
+): Promise<VerifiableCredential> {
+  // Validate fields
+  const error = schema.validate(fields)
+  if (error) throw new Error(error)
+
+  // Issue
+  const vc = await issuer.issue(subjectKey, '${schemaId}', fields)
+  console.log('VC issued to:', vc.credentialSubject.id)
+  return vc
+}
+
+// 4. Verify a Credential
+async function verifyCredential(vc: VerifiableCredential) {
+  const result = await issuer.verify(vc)
+  console.log('Valid:', result.valid, '| Revoked:', result.revoked)
+  if (result.errors.length) console.warn('Errors:', result.errors)
+  return result
+}
+
+${revocation ? `// 5. Revoke a Credential
+async function revokeCredential(serialNumber: string) {
+  const { txid } = await issuer.revoke(serialNumber)
+  console.log('Revoked, txid:', txid)
+}
+
+// 6. Check Revocation Status
+async function checkRevocation(serialNumber: string) {
+  const revoked = await issuer.isRevoked(serialNumber)
+  console.log('Is revoked:', revoked)
+  return revoked
+}` : ''}
+
+// Wallet-side: Acquire + List + Present
+async function acquireAndPresent(wallet: BrowserWallet, serverUrl: string) {
+  // Acquire from remote issuer (uses ?action=info and ?action=certify query params)
+  const vc = await wallet.acquireCredential({
+    serverUrl,
+    schemaId: '${schemaId}',
+    replaceExisting: true
+  })
+
+  // List credentials
+  const vcs = await wallet.listCredentials({
+    certifiers: [issuer.getInfo().publicKey],
+    types: [schema.getInfo().certificateTypeBase64]
+  })
+
+  // Create presentation
+  const vp = wallet.createPresentation(vcs)
+  console.log('VP holder:', vp.holder)
+  console.log('VCs in presentation:', vp.verifiableCredential.length)
+
+  return vp
+}
+
+// ---- Server-Side Route (REQUIRED for remote issuance) ----
+// Use the handler factory — do NOT write manual route code:
+
+// app/api/credential-issuer/route.ts  (no [[...path]] catch-all needed!)
+import { createCredentialIssuerHandler } from '@bsv/simple/server'
+const handler = createCredentialIssuerHandler({
+  schemas: [{
+    id: '${schemaId}',
+    name: 'CustomCredential',
+    fields: [
+${fieldsDef}
+    ]
+  }]
+})
+export const GET = handler.GET, POST = handler.POST
+
+// API endpoints (all query-param based):
+// GET  ?action=info           → { certifierPublicKey, certificateType, schemas }
+// GET  ?action=schema&id=...  → schema details
+// POST ?action=certify        → CertificateData (wallet acquisition)
+// POST ?action=issue          → { credential: VerifiableCredential }
+// POST ?action=verify         → { verification: VerificationResult }
+// POST ?action=revoke         → { txid }
+\`\`\``;
+}

package/dist/tools/did.d.ts

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

package/dist/tools/did.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDIDIntegration = generateDIDIntegration;
+function generateDIDIntegration(features) {
+    const sections = [];
+    sections.push(`\`\`\`typescript
+import { createWallet, DID } from '@bsv/simple/browser'
+\`\`\``);
+    if (features.includes('create')) {
+        sections.push(`### Create a DID (UTXO Chain-Linked)
+\`\`\`typescript
+async function createDID(wallet: BrowserWallet) {
+  const result = await wallet.createDID()
+  console.log('DID:', result.did)              // 'did:bsv:<txid>'
+  console.log('Document:', result.document)     // W3C DID Document
+  console.log('Identity Code:', result.identityCode)
+  return result
+}
+
+// With services
+async function createDIDWithServices(wallet: BrowserWallet) {
+  const result = await wallet.createDID({
+    services: [
+      {
+        id: 'did:bsv:<txid>#messaging',
+        type: 'MessagingService',
+        serviceEndpoint: 'https://example.com/messages'
+      }
+    ]
+  })
+  return result
+}
+\`\`\``);
+    }
+    if (features.includes('resolve')) {
+        sections.push(`### Resolve a DID (Cross-Wallet)
+
+**Important:** Cross-wallet resolution requires a server-side proxy in browser
+environments. Set \`didProxyUrl\` when creating the wallet:
+
+\`\`\`typescript
+// Initialize wallet with proxy URL for cross-wallet resolution
+const wallet = await createWallet({
+  didProxyUrl: '/api/resolve-did'
+})
+
+async function resolveDID(wallet: BrowserWallet, didString: string) {
+  if (!DID.isValid(didString)) {
+    throw new Error('Invalid DID format')
+  }
+
+  const result = await wallet.resolveDID(didString)
+
+  if (result.didDocumentMetadata?.deactivated) {
+    console.log('DID is deactivated')
+    return null
+  }
+
+  if (result.didResolutionMetadata?.error) {
+    console.error('Resolution error:', result.didResolutionMetadata.message)
+    return null
+  }
+
+  console.log('Resolved DID:', result.didDocument?.id)
+  console.log('Verification Key:', result.didDocument?.verificationMethod[0]?.publicKeyJwk)
+  console.log('Created:', result.didDocumentMetadata?.created)
+  console.log('Updated:', result.didDocumentMetadata?.updated)
+  return result.didDocument
+}
+\`\`\`
+
+#### Resolution Proxy (Next.js API Route)
+
+Use the handler factory — **do NOT write manual proxy code**:
+
+\`\`\`typescript
+// app/api/resolve-did/route.ts
+import { createDIDResolverHandler } from '@bsv/simple/server'
+const handler = createDIDResolverHandler()
+export const GET = handler.GET
+\`\`\`
+
+The handler automatically:
+- Tries the nChain Universal Resolver first (10s timeout)
+- Falls back to WoC UTXO chain-following on failure
+- Handles deactivated DIDs
+- Limits chain hops to 100
+
+**Custom config (optional):**
+\`\`\`typescript
+createDIDResolverHandler({
+  resolverUrl: 'https://custom-resolver.com',
+  wocBaseUrl: 'https://api.whatsonchain.com',
+  resolverTimeout: 10000,
+  maxHops: 100
+})
+\`\`\``);
+    }
+    if (features.includes('update')) {
+        sections.push(`### Update a DID
+\`\`\`typescript
+async function updateDID(wallet: BrowserWallet, did: string) {
+  const result = await wallet.updateDID({
+    did,
+    services: [
+      {
+        id: did + '#api',
+        type: 'APIService',
+        serviceEndpoint: 'https://api.example.com'
+      }
+    ],
+    additionalKeys: ['03abc...']  // Optional extra verification keys
+  })
+  console.log('Updated DID:', result.did)
+  console.log('New Document:', result.document)
+  return result
+}
+\`\`\``);
+    }
+    if (features.includes('deactivate')) {
+        sections.push(`### Deactivate (Revoke) a DID
+\`\`\`typescript
+async function deactivateDID(wallet: BrowserWallet, did: string) {
+  const { txid } = await wallet.deactivateDID(did)
+  console.log('Deactivated in TX:', txid)
+  // Resolving this DID will now return { didDocumentMetadata: { deactivated: true } }
+}
+\`\`\``);
+    }
+    if (features.includes('list')) {
+        sections.push(`### List Wallet DIDs
+\`\`\`typescript
+async function listDIDs(wallet: BrowserWallet) {
+  const dids = await wallet.listDIDs()
+  for (const entry of dids) {
+    console.log(entry.did, entry.status)  // 'active' or 'deactivated'
+  }
+  return dids
+}
+\`\`\``);
+    }
+    // Legacy support
+    if (features.includes('get')) {
+        sections.push(`### Get Legacy DID (deprecated)
+\`\`\`typescript
+// Legacy identity-key-based DID — use createDID() for new projects
+function getWalletDID(wallet: BrowserWallet) {
+  const didDoc = wallet.getDID()
+  console.log('DID:', didDoc.id)  // 'did:bsv:02abc...' (66-char pubkey)
+  return didDoc
+}
+\`\`\``);
+    }
+    if (features.includes('register')) {
+        sections.push(`### Register Legacy DID (deprecated)
+\`\`\`typescript
+// Legacy: persist identity-key DID as certificate — use createDID() for new projects
+async function registerDID(wallet: BrowserWallet) {
+  const didDoc = await wallet.registerDID({ persist: true })
+  console.log('DID registered:', didDoc.id)
+  return didDoc
+}
+\`\`\``);
+    }
+    return sections.join('\n\n');
+}

package/dist/tools/inscription.d.ts

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

package/dist/tools/inscription.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInscriptionHandler = generateInscriptionHandler;
+function generateInscriptionHandler(types) {
+    const sections = [];
+    if (types.includes('text')) {
+        sections.push(`### Text Inscription
+\`\`\`typescript
+async function inscribeText(wallet: BrowserWallet, text: string) {
+  const result = await wallet.inscribeText(text)
+  console.log('Text inscribed:', result.txid)
+  console.log('Size:', result.dataSize, 'bytes | Basket:', result.basket)
+  return result
+}
+\`\`\``);
+    }
+    if (types.includes('json')) {
+        sections.push(`### JSON Inscription
+\`\`\`typescript
+async function inscribeJSON(wallet: BrowserWallet, data: object) {
+  const result = await wallet.inscribeJSON(data)
+  console.log('JSON inscribed:', result.txid)
+  console.log('Size:', result.dataSize, 'bytes | Basket:', result.basket)
+  return result
+}
+\`\`\``);
+    }
+    if (types.includes('file-hash')) {
+        sections.push(`### File Hash Inscription
+\`\`\`typescript
+async function inscribeFileHash(wallet: BrowserWallet, file: File) {
+  // Compute SHA-256 hash of the file
+  const buffer = await file.arrayBuffer()
+  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  const hash = hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
+
+  const result = await wallet.inscribeFileHash(hash, {
+    description: \`Hash of \${file.name}\`
+  })
+
+  console.log('File hash inscribed:', result.txid)
+  console.log('Hash:', hash)
+  return { ...result, hash, fileName: file.name }
+}
+\`\`\``);
+    }
+    if (types.includes('image-hash')) {
+        sections.push(`### Image Hash Inscription
+\`\`\`typescript
+async function inscribeImageHash(wallet: BrowserWallet, imageFile: File) {
+  if (!imageFile.type.startsWith('image/')) {
+    throw new Error('File must be an image')
+  }
+
+  const buffer = await imageFile.arrayBuffer()
+  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  const hash = hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
+
+  const result = await wallet.inscribeImageHash(hash, {
+    description: \`Hash of image \${imageFile.name}\`
+  })
+
+  console.log('Image hash inscribed:', result.txid)
+  return { ...result, hash, fileName: imageFile.name }
+}
+\`\`\``);
+    }
+    return sections.join('\n\n');
+}

package/dist/tools/messagebox.d.ts

@@ -0,0 +1 @@
+export declare function generateMessageBoxSetup(features: string[], registryUrl?: string): string;

package/dist/tools/messagebox.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMessageBoxSetup = generateMessageBoxSetup;
+function generateMessageBoxSetup(features, registryUrl) {
+    const registry = registryUrl || '/api/identity-registry';
+    const sections = [];
+    if (features.includes('certify')) {
+        sections.push(`### MessageBox Certification
+\`\`\`typescript
+async function certifyIdentity(wallet: BrowserWallet, handle: string) {
+  // Check if already certified
+  const existingHandle = await wallet.getMessageBoxHandle('${registry}')
+  if (existingHandle) {
+    console.log('Already certified as:', existingHandle)
+    return existingHandle
+  }
+
+  // Register new handle
+  const result = await wallet.certifyForMessageBox(handle, '${registry}')
+  console.log('Certified as:', result.handle)
+  return result.handle
+}
+
+async function revokeIdentity(wallet: BrowserWallet) {
+  await wallet.revokeMessageBoxCertification('${registry}')
+  console.log('Identity revoked')
+}
+\`\`\``);
+    }
+    if (features.includes('send')) {
+        sections.push(`### Send Payment via MessageBox
+\`\`\`typescript
+async function sendPayment(wallet: BrowserWallet, recipientKey: string, satoshis: number) {
+  const result = await wallet.sendMessageBoxPayment(recipientKey, satoshis)
+
+  console.log('Payment sent:', result.amount, 'sats to', result.recipient)
+
+  return result
+}
+\`\`\``);
+    }
+    if (features.includes('receive')) {
+        sections.push(`### Receive Payments from MessageBox
+\`\`\`typescript
+async function receivePayments(wallet: BrowserWallet, basket = 'received-payments') {
+  const incoming = await wallet.listIncomingPayments()
+  console.log(\`\${incoming.length} incoming payments\`)
+
+  const results = []
+  for (const payment of incoming) {
+    try {
+      const accepted = await wallet.acceptIncomingPayment(payment, basket)
+      results.push({ success: true, payment: accepted })
+    } catch (e) {
+      results.push({ success: false, error: (e as Error).message })
+    }
+  }
+
+  return results
+}
+\`\`\``);
+    }
+    if (features.includes('search')) {
+        sections.push(`### Search Identity Registry
+\`\`\`typescript
+async function searchIdentity(wallet: BrowserWallet, query: string) {
+  const results = await wallet.lookupIdentityByTag(query, '${registry}')
+  console.log(\`Found \${results.length} matches for "\${query}"\`)
+
+  for (const match of results) {
+    console.log(\`  \${match.tag} → \${match.identityKey.substring(0, 20)}...\`)
+  }
+
+  return results
+}
+
+async function listMyTags(wallet: BrowserWallet) {
+  const tags = await wallet.listMyTags('${registry}')
+  console.log('My tags:', tags.map(t => t.tag))
+  return tags
+}
+\`\`\``);
+    }
+    return sections.join('\n\n');
+}

package/dist/tools/payment.d.ts

@@ -0,0 +1 @@
+export declare function generatePaymentHandler(type: string, basket?: string): string;

package/dist/tools/payment.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePaymentHandler = generatePaymentHandler;
+function generatePaymentHandler(type, basket) {
+    const effectiveBasket = basket || 'payments';
+    if (type === 'simple') {
+        return `\`\`\`typescript
+async function sendPayment(
+  wallet: BrowserWallet,
+  recipientKey: string,
+  satoshis: number
+) {
+  const result = await wallet.pay({
+    to: recipientKey,
+    satoshis
+  })
+
+  console.log('TXID:', result.txid)
+
+  return result
+}
+\`\`\``;
+    }
+    if (type === 'multi-output') {
+        return `\`\`\`typescript
+async function sendMultiOutput(
+  wallet: BrowserWallet,
+  outputs: Array<{
+    to?: string
+    satoshis?: number
+    data?: (string | object | number[])[]
+    basket?: string
+  }>
+) {
+  const result = await wallet.send({
+    outputs: outputs.map(o => ({
+      to: o.to,
+      satoshis: o.satoshis,
+      data: o.data,
+      basket: o.basket || '${effectiveBasket}'
+    })),
+    description: 'Multi-output transaction'
+  })
+
+  console.log('TXID:', result.txid)
+  console.log('Outputs:', result.outputDetails.map(d => \`#\${d.index}: \${d.type} (\${d.satoshis} sats)\`))
+
+  return result
+}
+
+// Usage:
+// await sendMultiOutput(wallet, [
+//   { to: recipientKey, satoshis: 1000 },                    // P2PKH
+//   { data: ['Hello!'] },                                     // OP_RETURN
+//   { to: wallet.getIdentityKey(), data: [{ v: 1 }], satoshis: 1 }  // PushDrop
+// ])
+\`\`\``;
+    }
+    if (type === 'server-funding') {
+        return `\`\`\`typescript
+async function fundServer(wallet: BrowserWallet, serverApiUrl: string) {
+  // 1. Get payment request from server
+  const res = await fetch(\`\${serverApiUrl}?action=request\`)
+  const { paymentRequest } = await res.json()
+
+  // 2. Fund server wallet via BRC-29 derivation
+  const result = await wallet.fundServerWallet(
+    paymentRequest,
+    '${effectiveBasket}'
+  )
+
+  if (!result.tx) {
+    throw new Error('No transaction bytes returned')
+  }
+
+  // 3. Send tx to server for internalization
+  const receiveRes = await fetch(\`\${serverApiUrl}?action=receive\`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      tx: Array.from(result.tx),
+      senderIdentityKey: wallet.getIdentityKey(),
+      derivationPrefix: paymentRequest.derivationPrefix,
+      derivationSuffix: paymentRequest.derivationSuffix,
+      outputIndex: 0
+    })
+  })
+
+  const receiveData = await receiveRes.json()
+  if (!receiveData.success) {
+    throw new Error(receiveData.error || 'Server receive failed')
+  }
+
+  console.log('Server funded:', result.txid)
+  return result
+}
+\`\`\``;
+    }
+    return `Unknown payment type: ${type}. Use 'simple', 'multi-output', or 'server-funding'.`;
+}

package/dist/tools/scaffold.d.ts

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

package/dist/tools/scaffold.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldNextjsConfig = scaffoldNextjsConfig;
+function scaffoldNextjsConfig(features) {
+    const deps = {
+        '@bsv/simple': '^0.2.3'
+    };
+    const nextConfig = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  serverExternalPackages: [
+    "@bsv/wallet-toolbox",
+    "knex",
+    "better-sqlite3",
+    "tedious",
+    "mysql",
+    "mysql2",
+    "pg",
+    "pg-query-stream",
+    "oracledb",
+    "dotenv"
+  ]
+};
+
+export default nextConfig;`;
+    const packageAdditions = JSON.stringify({ dependencies: deps }, null, 2);
+    return `## next.config.ts
+
+\`\`\`typescript
+${nextConfig}
+\`\`\`
+
+## package.json additions
+
+\`\`\`json
+${packageAdditions}
+\`\`\`
+
+## .gitignore additions
+
+\`\`\`
+.server-wallet.json
+.revocation-secrets.json
+.identity-registry.json
+.credential-issuer-key.json
+\`\`\`
+
+## Features configured: ${features.join(', ')}
+
+${features.includes('server-wallet') ? `### Server wallet setup
+\`\`\`typescript
+// app/api/server-wallet/route.ts
+import { createServerWalletHandler } from '@bsv/simple/server'
+const handler = createServerWalletHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`` : ''}
+${features.includes('messagebox') ? `### MessageBox setup
+\`\`\`typescript
+// app/api/identity-registry/route.ts
+import { createIdentityRegistryHandler } from '@bsv/simple/server'
+const handler = createIdentityRegistryHandler()
+export const GET = handler.GET, POST = handler.POST
+\`\`\`` : ''}
+${features.includes('did') ? `### DID Resolution Proxy
+\`\`\`typescript
+// app/api/resolve-did/route.ts
+import { createDIDResolverHandler } from '@bsv/simple/server'
+const handler = createDIDResolverHandler()
+export const GET = handler.GET
+\`\`\`` : ''}
+${features.includes('credentials') ? `### Credential Issuer
+\`\`\`typescript
+// app/api/credential-issuer/route.ts
+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/server-route.d.ts

@@ -0,0 +1 @@
+export declare function generateServerRoute(routeType: string): string;