Merge pull request #4 from Permissionless-Software-Foundation/ct-unstable

Authentication - basic & x402

.env-local

@@ -0,0 +1,32 @@
+# START INFRASTRUCTURE SETUP
+
+# Full Node Connection
+RPC_BASEURL=http://172.17.0.1:8332
+RPC_USERNAME=bitcoin
+RPC_PASSWORD=password
+
+# Fulcrum Indexer
+FULCRUM_API=http://172.17.0.1:3001/v1
+
+# SLP Indexer
+SLP_INDEXER_API=http://localhost:5010
+
+# REST API URL for wallet operations
+LOCAL_RESTURL=http://localhost:5942/v6
+
+# END INFRASTRUCTURE SETUP
+
+
+# START ACCESS CONTROL
+
+# x402 payments required to access this API?
+X402_ENABLED=true
+SERVER_BCH_ADDRESS=bitcoincash:qqlrzp23w08434twmvr4fxw672whkjy0py26r63g3d
+FACILITATOR_URL=http://localhost:4345/facilitator
+
+# Basic Authentication required to access this API?
+USE_BASIC_AUTH=true
+BASIC_AUTH_TOKEN=some-random-token
+
+# END ACCESS CONTROL
+

README.md

@@ -6,3 +6,25 @@ This is a REST API for communicating with Bitcoin Cash infrastructure. It replac
 
 [MIT](./LICENSE.md)
 
+## x402-bch Payments
+
+All REST endpoints exposed under the `/v6` prefix are protected by the [`x402-bch-express`](https://www.npmjs.com/package/x402-bch-express) middleware. Each API call requires a BCH payment authorization for **2000 satoshis**. The middleware advertises payment requirements via HTTP 402 responses and validates incoming `X-PAYMENT` headers with a configured Facilitator.
+
+### Configuration
+
+Environment variables control the payment flow:
+
+- `X402_ENABLED` — set to `false` (case-insensitive) to disable the middleware. Defaults to enabled.
+- `SERVER_BCH_ADDRESS` — BCH cash address that receives funding transactions. Defaults to `bitcoincash:qqlrzp23w08434twmvr4fxw672whkjy0py26r63g3d`.
+- `FACILITATOR_URL` — Root URL of the facilitator service (e.g., `http://localhost:4345/facilitator`).
+- `X402_PRICE_SAT` — Optional; override the satoshi price per call (defaults to `2000`).
+
+When `X402_ENABLED=false`, the server continues to operate without payment headers for local development or trusted deployments.
+
+### Manual Verification
+
+1. Start or point to an `x402-bch` facilitator service (the example facilitator listens at `http://localhost:4345/facilitator`).
+2. Run the API server with the default configuration: `npm start`.
+3. Call a protected endpoint without an `X-PAYMENT` header, e.g. `curl -i http://localhost:5942/v6/full-node/control/getNetworkInfo`. The server will respond with HTTP `402` and include payment requirements.
+4. Restart the server with `X402_ENABLED=false npm start` to confirm that the same request now bypasses the middleware (useful for local development without payments).
+

apidoc.json

@@ -1,9 +1,9 @@
 {
-  "name": "REST2NOSTR Proxy API",
+  "name": "psf-bch-api REST API",
   "version": "1.0.0",
-  "description": "REST API proxy for Nostr WebSocket protocol",
-  "title": "REST2NOSTR Proxy API",
-  "url": "https://nostr-relay-api.psfoundation.info",
-  "sampleUrl": "https://nostr-relay-api.psfoundation.info"
+  "description": "REST API proxy to Bitcoin Cash infrastructure",
+  "title": "psf-bch-api REST API",
+  "url": "http://localhost:5942",
+  "sampleUrl": "http://localhost:5942"
 }
 

bin/server.js

@@ -1,5 +1,5 @@
 /*
-  Express server for REST2NOSTR Proxy API.
+  Express server for psf-bch-api REST API.
   The architecture of the code follows the Clean Architecture pattern.
 */
 
@@ -7,6 +7,7 @@
 import express from 'express'
 import cors from 'cors'
 import dotenv from 'dotenv'
+import { paymentMiddleware as x402PaymentMiddleware } from 'x402-bch-express'
 import { fileURLToPath } from 'url'
 import { dirname, join } from 'path'
 
@@ -14,6 +15,8 @@ import { dirname, join } from 'path'
 import config from '../src/config/index.js'
 import Controllers from '../src/controllers/index.js'
 import wlogger from '../src/adapters/wlogger.js'
+import { buildX402Routes, getX402Settings, getBasicAuthSettings } from '../src/config/x402.js'
+import { basicAuthMiddleware } from '../src/middleware/basic-auth.js'
 
 // Load environment variables
 dotenv.config()
@@ -57,6 +60,9 @@ class Server {
       // Create an Express instance.
       const app = express()
 
+      const x402Settings = getX402Settings()
+      const basicAuthSettings = getBasicAuthSettings()
+
       // MIDDLEWARE START
       app.use(express.json())
       app.use(express.urlencoded({ extended: true }))
@@ -68,6 +74,74 @@ class Server {
         allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With']
       }))
 
+      // Apply basic auth middleware if enabled
+      // This must run before x402 middleware to set req.locals.basicAuthValid
+      if (basicAuthSettings.enabled) {
+        wlogger.info('Basic auth middleware enabled')
+        app.use(basicAuthMiddleware)
+      }
+
+      // Apply x402 middleware based on configuration
+      // Logic:
+      // - If X402_ENABLED=false OR USE_BASIC_AUTH=false: Don't apply x402 (no rate limits)
+      // - If X402_ENABLED=true AND USE_BASIC_AUTH=true: Apply x402 conditionally (bypass if basic auth valid)
+
+      // Apply access control middleware based on configuration
+      if (x402Settings.enabled && basicAuthSettings.enabled) {
+        // X402_ENABLED=true AND USE_BASIC_AUTH=true: Apply x402 conditionally
+        const routes = buildX402Routes(this.config.apiPrefix)
+        const facilitatorOptions = x402Settings.facilitatorUrl
+          ? { url: x402Settings.facilitatorUrl }
+          : undefined
+
+        wlogger.info(`x402 middleware enabled with basic auth bypass; enforcing ${x402Settings.priceSat} satoshis per request (unless basic auth provided)`)
+
+        // Create conditional x402 middleware that bypasses if basic auth is valid
+        const conditionalX402Middleware = (req, res, next) => {
+          // If basic auth is valid, bypass x402
+          if (req.locals?.basicAuthValid === true) {
+            return next()
+          }
+
+          // Otherwise, apply x402 middleware
+          return x402PaymentMiddleware(
+            x402Settings.serverAddress,
+            routes,
+            facilitatorOptions
+          )(req, res, next)
+        }
+
+        app.use(conditionalX402Middleware)
+      } else if (basicAuthSettings.enabled && !x402Settings.enabled) {
+        // USE_BASIC_AUTH=true AND X402_ENABLED=false: Require basic auth, reject unauthenticated requests
+        wlogger.info('Basic auth enforcement enabled (x402 disabled)')
+
+        // Middleware that rejects requests without valid basic auth
+        const requireBasicAuthMiddleware = (req, res, next) => {
+          // Skip auth check for health endpoint and root
+          if (req.path === '/health' || req.path === '/') {
+            return next()
+          }
+
+          // If basic auth is valid, allow the request
+          if (req.locals?.basicAuthValid === true) {
+            return next()
+          }
+
+          // Reject unauthenticated requests
+          wlogger.warn(`Unauthenticated request rejected: ${req.method} ${req.path}`)
+          return res.status(401).json({
+            error: 'Unauthorized',
+            message: 'Valid Bearer token required in Authorization header'
+          })
+        }
+
+        app.use(requireBasicAuthMiddleware)
+      } else {
+        // X402_ENABLED=false AND USE_BASIC_AUTH=false: No access control middleware
+        wlogger.info('No access control middleware enabled')
+      }
+
       // Endpoint logging middleware
       app.use((req, res, next) => {
         console.log(`Endpoint called: ${req.method} ${req.path}`)

package.json

@@ -1,7 +1,7 @@
 {
   "name": "psf-bch-api",
-  "version": "1.0.0",
-  "main": "index.js",
+  "version": "7.0.0",
+  "main": "psf-bch-api.js",
   "type": "module",
   "scripts": {
     "start": "node bin/server.js",
@@ -15,11 +15,17 @@
   "license": "MIT",
   "description": "REST API proxy to Bitcoin Cash infrastructure",
   "dependencies": {
+    "@psf/bch-js": "6.8.3",
+    "axios": "1.7.7",
     "cors": "2.8.5",
     "dotenv": "16.3.1",
     "express": "5.1.0",
+    "minimal-slp-wallet": "5.13.3",
+    "psffpp": "1.2.0",
+    "slp-token-media": "1.2.10",
     "winston": "3.11.0",
-    "winston-daily-rotate-file": "4.7.1"
+    "winston-daily-rotate-file": "4.7.1",
+    "x402-bch-express": "1.1.1"
   },
   "devDependencies": {
     "apidoc": "1.2.0",

src/adapters/fulcrum-api.js

@@ -0,0 +1,124 @@
+/*
+  Adapter library for interacting with Fulcrum API service over HTTP.
+*/
+
+import axios from 'axios'
+import wlogger from './wlogger.js'
+import config from '../config/index.js'
+
+class FulcrumAPIAdapter {
+  constructor (localConfig = {}) {
+    this.config = localConfig.config || config
+
+    // Allow missing config for testing environments
+    if (!this.config.fulcrumApi || !this.config.fulcrumApi.baseUrl) {
+      if (process.env.NODE_ENV === 'test' || process.env.TEST) {
+        // In test environment, create a mock baseURL
+        this.config.fulcrumApi = {
+          baseUrl: 'http://localhost:50001',
+          timeoutMs: 15000
+        }
+      } else {
+        throw new Error('FULCRUM_API env var not set. Can not connect to Fulcrum indexer.')
+      }
+    }
+
+    const {
+      baseUrl,
+      timeoutMs = 15000
+    } = this.config.fulcrumApi
+
+    this.http = axios.create({
+      baseURL: baseUrl,
+      timeout: timeoutMs
+    })
+  }
+
+  async get (path) {
+    try {
+      const response = await this.http.get(path)
+      return response.data
+    } catch (err) {
+      throw this._handleError(err)
+    }
+  }
+
+  async post (path, data) {
+    try {
+      const response = await this.http.post(path, data)
+      return response.data
+    } catch (err) {
+      throw this._handleError(err)
+    }
+  }
+
+  _handleError (err) {
+    const { status, message } = this.decodeError(err)
+    const error = new Error(message)
+    error.status = status
+    error.originalError = err
+    return error
+  }
+
+  decodeError (err) {
+    try {
+      // Attempt to extract error message from response data
+      if (err.response && err.response.data) {
+        const data = err.response.data
+        // Handle structured error responses
+        if (data.error) {
+          return this._formatError(data.error, err.response.status || 400)
+        }
+        // Handle string error messages
+        if (typeof data === 'string') {
+          return this._formatError(data, err.response.status || 400)
+        }
+        // Handle object responses that might contain error info
+        if (typeof data === 'object' && data.message) {
+          return this._formatError(data.message, err.response.status || 400)
+        }
+        // Fallback to returning the status
+        return this._formatError('Fulcrum API error', err.response.status || 500)
+      }
+
+      // Network errors
+      if (err.message) {
+        if (err.message.includes('ENOTFOUND') || err.message.includes('ENETUNREACH') || err.message.includes('EAI_AGAIN')) {
+          return this._formatError(
+            'Network error: Could not communicate with Fulcrum API service.',
+            503
+          )
+        }
+      }
+
+      if (err.code && (err.code === 'ECONNABORTED' || err.code === 'ECONNREFUSED')) {
+        return this._formatError(
+          'Network error: Could not communicate with Fulcrum API service.',
+          503
+        )
+      }
+
+      if (err.error && typeof err.error === 'string' && err.error.includes('429')) {
+        return this._formatError('429 Too Many Requests', 429)
+      }
+
+      if (err.message) {
+        return this._formatError(err.message, err.status || 422)
+      }
+
+      return this._formatError('Unhandled Fulcrum API error', 500)
+    } catch (decodeError) {
+      wlogger.error('Unhandled error in FulcrumAPIAdapter.decodeError()', decodeError)
+      return this._formatError('Internal server error', 500)
+    }
+  }
+
+  _formatError (message, status = 500) {
+    return {
+      message: message || 'Internal server error',
+      status: status || 500
+    }
+  }
+}
+
+export default FulcrumAPIAdapter

src/adapters/full-node-rpc.js

@@ -0,0 +1,129 @@
+/*
+  Adapter library for interacting with a BCH full node over JSON-RPC.
+*/
+
+import axios from 'axios'
+import wlogger from './wlogger.js'
+import config from '../config/index.js'
+
+class FullNodeRPCAdapter {
+  constructor (localConfig = {}) {
+    this.config = localConfig.config || config
+
+    if (!this.config.fullNode || !this.config.fullNode.rpcBaseUrl) {
+      throw new Error('Full node RPC configuration is required')
+    }
+
+    const {
+      rpcBaseUrl,
+      rpcUsername,
+      rpcPassword,
+      rpcTimeoutMs = 15000
+    } = this.config.fullNode
+
+    this.requestIdPrefix = this.config.fullNode.rpcRequestIdPrefix || 'psf-bch-api'
+
+    this.http = axios.create({
+      baseURL: rpcBaseUrl,
+      timeout: rpcTimeoutMs,
+      auth: {
+        username: rpcUsername,
+        password: rpcPassword
+      }
+    })
+
+    this.defaultRequestPayload = {
+      jsonrpc: '1.0'
+    }
+  }
+
+  async call (method, params = [], requestId) {
+    const id = requestId || `${this.requestIdPrefix}-${method}`
+
+    try {
+      const response = await this.http.post('', {
+        ...this.defaultRequestPayload,
+        id,
+        method,
+        params
+      })
+
+      if (response.data && response.data.error) {
+        const rpcError = this._formatError(response.data.error.message, 400)
+        throw rpcError
+      }
+
+      return response.data.result
+    } catch (err) {
+      throw this._handleError(err)
+    }
+  }
+
+  _handleError (err) {
+    const { status, message } = this.decodeError(err)
+    const error = new Error(message)
+    error.status = status
+    error.originalError = err
+    return error
+  }
+
+  decodeError (err) {
+    try {
+      if (
+        err.response &&
+        err.response.data &&
+        err.response.data.error &&
+        err.response.data.error.message
+      ) {
+        return this._formatError(err.response.data.error.message, 400)
+      }
+
+      if (err.response && err.response.data) {
+        return this._formatError(err.response.data, err.response.status || 500)
+      }
+
+      if (err.message) {
+        if (err.message.includes('ENOTFOUND') || err.message.includes('ENETUNREACH') || err.message.includes('EAI_AGAIN')) {
+          return this._formatError(
+            'Network error: Could not communicate with full node or other external service.',
+            503
+          )
+        }
+      }
+
+      if (err.code && (err.code === 'ECONNABORTED' || err.code === 'ECONNREFUSED')) {
+        return this._formatError(
+          'Network error: Could not communicate with full node or other external service.',
+          503
+        )
+      }
+
+      if (err.error && typeof err.error === 'string' && err.error.includes('429')) {
+        return this._formatError('429 Too Many Requests', 429)
+      }
+
+      if (err.message) {
+        return this._formatError(err.message, err.status || 422)
+      }
+
+      return this._formatError('Unhandled full node error', 500)
+    } catch (decodeError) {
+      wlogger.error('Unhandled error in FullNodeRPCAdapter.decodeError()', decodeError)
+      return this._formatError('Internal server error', 500)
+    }
+  }
+
+  validateArraySize (length) {
+    const limit = 20
+    return length <= limit
+  }
+
+  _formatError (message, status = 500) {
+    return {
+      message: message || 'Internal server error',
+      status: status || 500
+    }
+  }
+}
+
+export default FullNodeRPCAdapter

src/adapters/index.js

@@ -6,6 +6,9 @@
 
 // Load individual adapter libraries.
 // import NostrRelayAdapter from './nostr-relay.js'
+import FullNodeRPCAdapter from './full-node-rpc.js'
+import FulcrumAPIAdapter from './fulcrum-api.js'
+import SlpIndexerAPIAdapter from './slp-indexer-api.js'
 import config from '../config/index.js'
 
 class Adapters {
@@ -30,6 +33,10 @@ class Adapters {
     // Maintain backward compatibility: expose first relay as nostrRelay
     // This allows existing code to work during transition
     // this.nostrRelay = this.nostrRelays[0]
+
+    this.fullNode = new FullNodeRPCAdapter({ config: this.config })
+    this.fulcrum = new FulcrumAPIAdapter({ config: this.config })
+    this.slpIndexer = new SlpIndexerAPIAdapter({ config: this.config })
   }
 
   async start () {

src/adapters/nostr-relay.js

@@ -1,241 +0,0 @@
-/*
-  Nostr Relay WebSocket adapter.
-  Handles WebSocket connections to Nostr relays and manages message sending/receiving.
-*/
-
-import WebSocket from 'ws'
-import config from '../config/index.js'
-import wlogger from './wlogger.js'
-
-class NostrRelayAdapter {
-  constructor (localConfig = {}) {
-    this.config = config
-    this.relayUrl = localConfig.relayUrl || config.nostrRelayUrl
-    this.ws = null
-    this.isConnected = false
-    this.reconnectAttempts = 0
-    this.maxReconnectAttempts = 5
-    this.reconnectDelay = 5000 // 5 seconds
-    this.messageHandlers = new Map() // Map subscription_id to handlers
-    this.pendingMessages = [] // Queue messages while disconnected
-    this.eventResolvers = new Map() // Map event_id to promise resolvers for OK responses
-    this.subscriptionHandlers = new Map() // Map subscription_id to event handlers
-
-    // Bind methods
-    this.connect = this.connect.bind(this)
-    this.disconnect = this.disconnect.bind(this)
-    this.sendEvent = this.sendEvent.bind(this)
-    this.sendReq = this.sendReq.bind(this)
-    this.sendClose = this.sendClose.bind(this)
-    this.handleMessage = this.handleMessage.bind(this)
-    this.handleError = this.handleError.bind(this)
-    this.handleClose = this.handleClose.bind(this)
-  }
-
-  async connect () {
-    if (this.ws && this.isConnected) {
-      return true
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        wlogger.info(`Connecting to Nostr relay: ${this.relayUrl}`)
-        this.ws = new WebSocket(this.relayUrl)
-
-        this.ws.on('open', () => {
-          wlogger.info('Connected to Nostr relay')
-          this.isConnected = true
-          this.reconnectAttempts = 0
-
-          // Send any pending messages
-          while (this.pendingMessages.length > 0) {
-            const message = this.pendingMessages.shift()
-            this.ws.send(JSON.stringify(message))
-          }
-
-          resolve(true)
-        })
-
-        this.ws.on('message', (data) => {
-          try {
-            const message = JSON.parse(data.toString())
-            this.handleMessage(message)
-          } catch (err) {
-            wlogger.error('Error parsing relay message:', err)
-          }
-        })
-
-        this.ws.on('error', this.handleError)
-        this.ws.on('close', this.handleClose)
-
-        // Timeout after 10 seconds
-        setTimeout(() => {
-          if (!this.isConnected) {
-            reject(new Error('Connection timeout'))
-          }
-        }, 10000)
-      } catch (err) {
-        wlogger.error('Error connecting to relay:', err)
-        reject(err)
-      }
-    })
-  }
-
-  async disconnect () {
-    if (this.ws) {
-      this.ws.close()
-      this.ws = null
-      this.isConnected = false
-      wlogger.info('Disconnected from Nostr relay')
-    }
-  }
-
-  handleMessage (message) {
-    if (!Array.isArray(message) || message.length === 0) {
-      return
-    }
-
-    const [type, ...args] = message
-
-    switch (type) {
-      case 'EVENT':
-        // ["EVENT", <subscription_id>, <event>]
-        if (args.length >= 2) {
-          const subscriptionId = args[0]
-          const event = args[1]
-          const handler = this.subscriptionHandlers.get(subscriptionId)
-          if (handler) {
-            handler.onEvent(event)
-          }
-        }
-        break
-
-      case 'OK':
-        // ["OK", <event_id>, <true|false>, <message>]
-        if (args.length >= 2) {
-          const eventId = args[0]
-          const accepted = args[1]
-          const message = args[2] || ''
-          const resolver = this.eventResolvers.get(eventId)
-          if (resolver) {
-            resolver({ accepted, message })
-            this.eventResolvers.delete(eventId)
-          }
-        }
-        break
-
-      case 'EOSE':
-        // ["EOSE", <subscription_id>]
-        if (args.length >= 1) {
-          const subscriptionId = args[0]
-          const handler = this.subscriptionHandlers.get(subscriptionId)
-          if (handler) {
-            handler.onEose()
-          }
-        }
-        break
-
-      case 'CLOSED':
-        // ["CLOSED", <subscription_id>, <message>]
-        if (args.length >= 1) {
-          const subscriptionId = args[0]
-          const message = args[1] || ''
-          const handler = this.subscriptionHandlers.get(subscriptionId)
-          if (handler) {
-            handler.onClosed(message)
-          }
-        }
-        break
-
-      case 'NOTICE':
-        // ["NOTICE", <message>]
-        if (args.length >= 1) {
-          const message = args[0]
-          wlogger.warn('Relay notice:', message)
-        }
-        break
-
-      default:
-        wlogger.warn('Unknown message type from relay:', type)
-    }
-  }
-
-  handleError (error) {
-    wlogger.error('WebSocket error:', error)
-    this.isConnected = false
-  }
-
-  handleClose () {
-    const now = new Date()
-    wlogger.warn(`WebSocket connection closed at ${now.toLocaleString()}`)
-    this.isConnected = false
-
-    // Attempt to reconnect
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++
-      wlogger.info(`Attempting to reconnect (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`)
-      setTimeout(() => {
-        this.connect().catch(err => {
-          wlogger.error('Reconnection failed:', err)
-        })
-      }, this.reconnectDelay)
-    }
-  }
-
-  async sendMessage (message) {
-    if (!this.isConnected || !this.ws) {
-      // Queue message for when connection is established
-      this.pendingMessages.push(message)
-      await this.connect()
-      return
-    }
-
-    try {
-      this.ws.send(JSON.stringify(message))
-    } catch (err) {
-      wlogger.error('Error sending message:', err)
-      throw err
-    }
-  }
-
-  async sendEvent (event) {
-    // ["EVENT", <event>]
-    const message = ['EVENT', event]
-    await this.sendMessage(message)
-
-    // Return a promise that resolves when we get the OK response
-    return new Promise((resolve, reject) => {
-      this.eventResolvers.set(event.id, resolve)
-      // Timeout after 30 seconds
-      setTimeout(() => {
-        if (this.eventResolvers.has(event.id)) {
-          this.eventResolvers.delete(event.id)
-          reject(new Error('Timeout waiting for OK response'))
-        }
-      }, 30000)
-    })
-  }
-
-  async sendReq (subscriptionId, filters, handlers) {
-    // ["REQ", <subscription_id>, <filters>]
-    await this.connect()
-
-    // Store handlers for this subscription
-    this.subscriptionHandlers.set(subscriptionId, handlers)
-
-    const message = ['REQ', subscriptionId, ...filters]
-    await this.sendMessage(message)
-  }
-
-  async sendClose (subscriptionId) {
-    // ["CLOSE", <subscription_id>]
-    const message = ['CLOSE', subscriptionId]
-    await this.sendMessage(message)
-
-    // Clean up handlers
-    this.subscriptionHandlers.delete(subscriptionId)
-    this.messageHandlers.delete(subscriptionId)
-  }
-}
-
-export default NostrRelayAdapter

src/adapters/slp-indexer-api.js

@@ -0,0 +1,124 @@
+/*
+  Adapter library for interacting with SLP Indexer API service over HTTP.
+*/
+
+import axios from 'axios'
+import wlogger from './wlogger.js'
+import config from '../config/index.js'
+
+class SlpIndexerAPIAdapter {
+  constructor (localConfig = {}) {
+    this.config = localConfig.config || config
+
+    // Allow missing config for testing environments
+    if (!this.config.slpIndexerApi || !this.config.slpIndexerApi.baseUrl) {
+      if (process.env.NODE_ENV === 'test' || process.env.TEST) {
+        // In test environment, create a mock baseURL
+        this.config.slpIndexerApi = {
+          baseUrl: 'http://localhost:5021',
+          timeoutMs: 15000
+        }
+      } else {
+        throw new Error('SLP_INDEXER_API env var not set. Can not connect to PSF SLP indexer.')
+      }
+    }
+
+    const {
+      baseUrl,
+      timeoutMs = 15000
+    } = this.config.slpIndexerApi
+
+    this.http = axios.create({
+      baseURL: baseUrl,
+      timeout: timeoutMs
+    })
+  }
+
+  async get (path) {
+    try {
+      const response = await this.http.get(path)
+      return response.data
+    } catch (err) {
+      throw this._handleError(err)
+    }
+  }
+
+  async post (path, data) {
+    try {
+      const response = await this.http.post(path, data)
+      return response.data
+    } catch (err) {
+      throw this._handleError(err)
+    }
+  }
+
+  _handleError (err) {
+    const { status, message } = this.decodeError(err)
+    const error = new Error(message)
+    error.status = status
+    error.originalError = err
+    return error
+  }
+
+  decodeError (err) {
+    try {
+      // Attempt to extract error message from response data
+      if (err.response && err.response.data) {
+        const data = err.response.data
+        // Handle structured error responses
+        if (data.error) {
+          return this._formatError(data.error, err.response.status || 400)
+        }
+        // Handle string error messages
+        if (typeof data === 'string') {
+          return this._formatError(data, err.response.status || 400)
+        }
+        // Handle object responses that might contain error info
+        if (typeof data === 'object' && data.message) {
+          return this._formatError(data.message, err.response.status || 400)
+        }
+        // Fallback to returning the status
+        return this._formatError('SLP Indexer API error', err.response.status || 500)
+      }
+
+      // Network errors
+      if (err.message) {
+        if (err.message.includes('ENOTFOUND') || err.message.includes('ENETUNREACH') || err.message.includes('EAI_AGAIN')) {
+          return this._formatError(
+            'Network error: Could not communicate with SLP Indexer API service.',
+            503
+          )
+        }
+      }
+
+      if (err.code && (err.code === 'ECONNABORTED' || err.code === 'ECONNREFUSED')) {
+        return this._formatError(
+          'Network error: Could not communicate with SLP Indexer API service.',
+          503
+        )
+      }
+
+      if (err.error && typeof err.error === 'string' && err.error.includes('429')) {
+        return this._formatError('429 Too Many Requests', 429)
+      }
+
+      if (err.message) {
+        return this._formatError(err.message, err.status || 422)
+      }
+
+      return this._formatError('Unhandled SLP Indexer API error', 500)
+    } catch (decodeError) {
+      wlogger.error('Unhandled error in SlpIndexerAPIAdapter.decodeError()', decodeError)
+      return this._formatError('Internal server error', 500)
+    }
+  }
+
+  _formatError (message, status = 500) {
+    return {
+      message: message || 'Internal server error',
+      status: status || 500
+    }
+  }
+}
+
+export default SlpIndexerAPIAdapter

src/config/env/common.js

@@ -3,16 +3,46 @@
   environments.
 */
 
+import dotenv from 'dotenv'
+
 // Hack to get __dirname back.
 // https://blog.logrocket.com/alternatives-dirname-node-js-es-modules/
 import * as url from 'url'
 import { readFileSync } from 'fs'
+dotenv.config()
 
 const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
 const pkgInfo = JSON.parse(readFileSync(`${__dirname.toString()}/../../../package.json`))
 
 const version = pkgInfo.version
 
+// This function is used to convert the string input of an environment variable to a boolean value.
+const normalizeBoolean = (value, defaultValue) => {
+  if (value === undefined || value === null || value === '') return defaultValue
+
+  const normalized = String(value).trim().toLowerCase()
+  if (['false', '0', 'no', 'off'].includes(normalized)) return false
+  if (['true', '1', 'yes', 'on'].includes(normalized)) return true
+  return defaultValue
+}
+
+// By default, the price per API call is 2000 satoshis.
+// But the user can override this value by setting the X402_PRICE_SAT environment variable.
+const parsedPriceSat = Number(process.env.X402_PRICE_SAT)
+const priceSat = Number.isFinite(parsedPriceSat) && parsedPriceSat > 0 ? parsedPriceSat : 2000
+
+const x402Defaults = {
+  enabled: normalizeBoolean(process.env.X402_ENABLED, true),
+  facilitatorUrl: process.env.FACILITATOR_URL || 'http://localhost:4345/facilitator',
+  serverAddress: process.env.SERVER_BCH_ADDRESS || 'bitcoincash:qqsrke9lh257tqen99dkyy2emh4uty0vky9y0z0lsr',
+  priceSat
+}
+
+const basicAuthDefaults = {
+  enabled: normalizeBoolean(process.env.USE_BASIC_AUTH, false),
+  token: process.env.BASIC_AUTH_TOKEN || ''
+}
+
 export default {
   // Server port
   port: process.env.PORT || 5942,
@@ -20,32 +50,42 @@ export default {
   // Environment
   env: process.env.NODE_ENV || 'development',
 
+  // API prefix for REST controllers
+  apiPrefix: process.env.API_PREFIX || '/v6',
+
   // Logging level
   logLevel: process.env.LOG_LEVEL || 'info',
 
-  // Nostr relay configuration (array of relay URLs)
-  nostrRelayUrls: (() => {
-    // Support NOSTR_RELAY_URLS (plural) as comma-separated string or JSON array
-    if (process.env.NOSTR_RELAY_URLS) {
-      try {
-        // Try parsing as JSON array first
-        const parsed = JSON.parse(process.env.NOSTR_RELAY_URLS)
-        if (Array.isArray(parsed)) {
-          return parsed.filter(url => url && typeof url === 'string')
-        }
-      } catch (e) {
-        // Not JSON, treat as comma-separated string
-        return process.env.NOSTR_RELAY_URLS.split(',').map(url => url.trim()).filter(url => url.length > 0)
-      }
-    }
-    // Backward compatibility: support NOSTR_RELAY_URL (singular)
-    if (process.env.NOSTR_RELAY_URL) {
-      return [process.env.NOSTR_RELAY_URL]
-    }
+  // Full node RPC configuration
+  fullNode: {
+    rpcBaseUrl: process.env.RPC_BASEURL || 'http://127.0.0.1:8332',
+    rpcUsername: process.env.RPC_USERNAME || '',
+    rpcPassword: process.env.RPC_PASSWORD || '',
+    rpcTimeoutMs: Number(process.env.RPC_TIMEOUT_MS || 15000),
+    rpcRequestIdPrefix: process.env.RPC_REQUEST_ID_PREFIX || 'psf-bch-api'
+  },
 
-    // Default
-    return ['wss://nostr-relay.psfoundation.info', 'wss://relay.damus.io']
-  })(),
+  // Fulcrum API configuration
+  fulcrumApi: {
+    baseUrl: process.env.FULCRUM_API || '',
+    timeoutMs: Number(process.env.FULCRUM_TIMEOUT_MS || 15000)
+  },
+
+  // SLP Indexer API configuration
+  slpIndexerApi: {
+    baseUrl: process.env.SLP_INDEXER_API || '',
+    timeoutMs: Number(process.env.SLP_INDEXER_TIMEOUT_MS || 15000)
+  },
+
+  // REST API URL for wallet operations
+  restURL: process.env.REST_URL || process.env.LOCAL_RESTURL || 'http://127.0.0.1:5942/v6/',
+
+  // IPFS Gateway URL
+  ipfsGateway: process.env.IPFS_GATEWAY || 'p2wdb-gateway-678.fullstack.cash',
+
+  x402: x402Defaults,
+
+  basicAuth: basicAuthDefaults,
 
   // Version
   version

src/config/x402.js

@@ -0,0 +1,50 @@
+import config from './index.js'
+
+const DEFAULT_DESCRIPTION = 'Access to protected psf-bch-api resources'
+const DEFAULT_TIMEOUT_SECONDS = 60
+const NETWORK = 'bch'
+
+/**
+ * Builds a route configuration map for x402-bch middleware.
+ *
+ * @param {string} apiPrefix Express API prefix (e.g., "/v6")
+ * @returns {Object} Routes configuration compatible with x402-bch-express
+ */
+export function buildX402Routes (apiPrefix = '/v6') {
+  const normalizedPrefix = apiPrefix.endsWith('/')
+    ? apiPrefix.slice(0, -1)
+    : apiPrefix
+  const prefixWithSlash = normalizedPrefix.startsWith('/')
+    ? normalizedPrefix
+    : `/${normalizedPrefix}`
+
+  const routeKey = `${prefixWithSlash}/*`
+
+  return {
+    network: NETWORK,
+    [routeKey]: {
+      price: config.x402.priceSat,
+      network: NETWORK,
+      config: {
+        description: `${DEFAULT_DESCRIPTION} (2000 satoshis)`,
+        maxTimeoutSeconds: DEFAULT_TIMEOUT_SECONDS
+      }
+    }
+  }
+}
+
+export function getX402Settings () {
+  return {
+    enabled: Boolean(config.x402?.enabled),
+    facilitatorUrl: config.x402?.facilitatorUrl,
+    serverAddress: config.x402?.serverAddress,
+    priceSat: config.x402?.priceSat
+  }
+}
+
+export function getBasicAuthSettings () {
+  return {
+    enabled: Boolean(config.basicAuth?.enabled),
+    token: config.basicAuth?.token || ''
+  }
+}

src/controllers/index.js

@@ -18,6 +18,7 @@ class Controllers {
     this.useCases = new UseCases({ adapters: this.adapters })
     this.config = config
     this.timerController = new TimerController({ adapters: this.adapters, useCases: this.useCases })
+    this.apiPrefix = this.config.apiPrefix || '/v6'
 
     // Bind 'this' object to all subfunctions
     this.initAdapters = this.initAdapters.bind(this)
@@ -45,7 +46,8 @@ class Controllers {
   attachRESTControllers (app) {
     const restControllers = new RESTControllers({
       adapters: this.adapters,
-      useCases: this.useCases
+      useCases: this.useCases,
+      apiPrefix: this.apiPrefix
     })
 
     // Attach the REST API Controllers to the Express app.

src/controllers/rest-api/event/controller.js

@@ -1,99 +0,0 @@
-/*
-  REST API Controller library for the /event route
-*/
-
-// Local libraries
-import wlogger from '../../../adapters/wlogger.js'
-
-class EventRESTControllerLib {
-  constructor (localConfig = {}) {
-    // Dependency Injection.
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error(
-        'Instance of Adapters library required when instantiating /event REST Controller.'
-      )
-    }
-    this.useCases = localConfig.useCases
-    if (!this.useCases) {
-      throw new Error(
-        'Instance of Use Cases library required when instantiating /event REST Controller.'
-      )
-    }
-
-    // Bind 'this' object to all subfunctions
-    this.publishEvent = this.publishEvent.bind(this)
-    this.handleError = this.handleError.bind(this)
-  }
-
-  /**
-   * @api {post} /event Publish a Nostr event
-   * @apiPermission public
-   * @apiName PublishEvent
-   * @apiGroup Event
-   *
-   * @apiDescription Publish a signed Nostr event to the relay. Maps to the Nostr WebSocket protocol message: ["EVENT", <event>]
-   *
-   * @apiParam {String} id Event ID (32-bytes lowercase hex-encoded sha256)
-   * @apiParam {String} pubkey Public key of event creator (32-bytes lowercase hex-encoded)
-   * @apiParam {Number} created_at Unix timestamp in seconds
-   * @apiParam {Number} kind Integer between 0 and 65535
-   * @apiParam {Array} tags Array of tag arrays
-   * @apiParam {String} content Event content (arbitrary string)
-   * @apiParam {String} sig Signature (64-bytes lowercase hex)
-   *
-   * @apiExample {json} Example usage:
-   * {
-   *   "id": "5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36",
-   *   "pubkey": "2c7e76c0f8dc1dca9d0197c7d19be580a8d074ccada6a2f6ebe056ae41092e9",
-   *   "created_at": 1672531200,
-   *   "kind": 1,
-   *   "tags": [],
-   *   "content": "Hello, Nostr!",
-   *   "sig": "abc123..."
-   * }
-   *
-   * @apiSuccess {Boolean} accepted Whether the event was accepted by the relay
-   * @apiSuccess {String} message Optional message from the relay
-   * @apiSuccess {String} eventId The event ID
-   *
-   * @apiError {String} error Error message
-   */
-  async publishEvent (req, res) {
-    try {
-      const eventData = req.body
-
-      // Check if eventData is missing or empty
-      if (!eventData || (typeof eventData === 'object' && Object.keys(eventData).length === 0)) {
-        return res.status(400).json({
-          error: 'Event data is required'
-        })
-      }
-
-      const result = await this.useCases.publishEvent.execute(eventData)
-
-      if (result.accepted) {
-        return res.status(200).json(result)
-      } else {
-        return res.status(400).json(result)
-      }
-    } catch (err) {
-      return this.handleError(err, req, res)
-    }
-  }
-
-  handleError (err, req, res) {
-    wlogger.error('Error in EventRESTController:', err)
-
-    // Return 400 for validation errors, 500 for other errors
-    // Validation errors indicate the client sent bad data
-    const isValidationError = err.message && err.message.includes('Invalid event structure')
-    const statusCode = isValidationError ? 400 : 500
-
-    return res.status(statusCode).json({
-      error: err.message || 'Internal server error'
-    })
-  }
-}
-
-export default EventRESTControllerLib

src/controllers/rest-api/event/index.js

@@ -1,55 +0,0 @@
-/*
-  REST API library for the /event route.
-*/
-
-// Public npm libraries.
-import express from 'express'
-
-// Local libraries.
-import EventRESTControllerLib from './controller.js'
-
-class EventRouter {
-  constructor (localConfig = {}) {
-    // Dependency Injection.
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error(
-        'Instance of Adapters library required when instantiating Event REST Controller.'
-      )
-    }
-    this.useCases = localConfig.useCases
-    if (!this.useCases) {
-      throw new Error(
-        'Instance of Use Cases library required when instantiating Event REST Controller.'
-      )
-    }
-
-    const dependencies = {
-      adapters: this.adapters,
-      useCases: this.useCases
-    }
-
-    // Encapsulate dependencies.
-    this.eventRESTController = new EventRESTControllerLib(dependencies)
-
-    // Instantiate the router and set the base route.
-    this.baseUrl = '/event'
-    this.router = express.Router()
-  }
-
-  attach (app) {
-    if (!app) {
-      throw new Error(
-        'Must pass app object when attaching REST API controllers.'
-      )
-    }
-
-    // Define the routes and attach the controller.
-    this.router.post('/', this.eventRESTController.publishEvent)
-
-    // Attach the Controller routes to the Express app.
-    app.use(this.baseUrl, this.router)
-  }
-}
-
-export default EventRouter

src/controllers/rest-api/fulcrum/controller.js

@@ -0,0 +1,563 @@
+/*
+  REST API Controller for the /fulcrum routes.
+*/
+
+import wlogger from '../../../adapters/wlogger.js'
+import BCHJS from '@psf/bch-js'
+
+const bchjs = new BCHJS()
+
+class FulcrumRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Fulcrum REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.fulcrum) {
+      throw new Error(
+        'Instance of Fulcrum use cases required when instantiating Fulcrum REST Controller.'
+      )
+    }
+
+    this.fulcrumUseCases = this.useCases.fulcrum
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.getBalance = this.getBalance.bind(this)
+    this.balanceBulk = this.balanceBulk.bind(this)
+    this.getUtxos = this.getUtxos.bind(this)
+    this.utxosBulk = this.utxosBulk.bind(this)
+    this.getTransactionDetails = this.getTransactionDetails.bind(this)
+    this.transactionDetailsBulk = this.transactionDetailsBulk.bind(this)
+    this.broadcastTransaction = this.broadcastTransaction.bind(this)
+    this.getBlockHeaders = this.getBlockHeaders.bind(this)
+    this.blockHeadersBulk = this.blockHeadersBulk.bind(this)
+    this.getTransactions = this.getTransactions.bind(this)
+    this.transactionsBulk = this.transactionsBulk.bind(this)
+    this.getMempool = this.getMempool.bind(this)
+    this.mempoolBulk = this.mempoolBulk.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/ Service status
+   * @apiName FulcrumRoot
+   * @apiGroup Fulcrum
+   *
+   * @apiDescription Returns the status of the fulcrum service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'fulcrum' })
+  }
+
+  /**
+   * Validates and converts an address to cash address format
+   * @param {string} address - Address to validate and convert
+   * @returns {string} Cash address
+   * @throws {Error} If address is invalid or not mainnet
+   */
+  _validateAndConvertAddress (address) {
+    if (!address) {
+      throw new Error('address is empty')
+    }
+
+    // Convert legacy to cash address
+    const cashAddr = bchjs.Address.toCashAddress(address)
+
+    // Ensure it's a valid BCH address
+    try {
+      bchjs.Address.toLegacyAddress(cashAddr)
+    } catch (err) {
+      throw new Error(`Invalid BCH address. Double check your address is valid: ${address}`)
+    }
+
+    // Ensure it's mainnet (no testnet support)
+    const isMainnet = bchjs.Address.isMainnetAddress(cashAddr)
+    if (!isMainnet) {
+      throw new Error('Invalid network. Only mainnet addresses are supported.')
+    }
+
+    return cashAddr
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/balance/:address Get balance for a single address
+   * @apiName GetBalance
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an object with confirmed and unconfirmed balance associated with an address.
+   */
+  async getBalance (req, res) {
+    try {
+      const address = req.params.address
+
+      if (Array.isArray(address)) {
+        return res.status(400).json({
+          success: false,
+          error: 'address can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      const cashAddr = this._validateAndConvertAddress(address)
+
+      const result = await this.fulcrumUseCases.getBalance({ address: cashAddr })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/balance Get balances for an array of addresses
+   * @apiName GetBalances
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of balances associated with an array of addresses. Limited to 20 items per request.
+   */
+  async balanceBulk (req, res) {
+    try {
+      const addresses = req.body.addresses
+
+      if (!Array.isArray(addresses)) {
+        return res.status(400).json({
+          success: false,
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(addresses.length)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate and convert all addresses
+      const validatedAddresses = []
+      for (let i = 0; i < addresses.length; i++) {
+        try {
+          const cashAddr = this._validateAndConvertAddress(addresses[i])
+          validatedAddresses.push(cashAddr)
+        } catch (err) {
+          return res.status(400).json({
+            success: false,
+            error: err.message
+          })
+        }
+      }
+
+      const result = await this.fulcrumUseCases.getBalances({ addresses: validatedAddresses })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/utxos/:address Get utxos for a single address
+   * @apiName GetUtxos
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an object with UTXOs associated with an address.
+   */
+  async getUtxos (req, res) {
+    try {
+      const address = req.params.address
+
+      if (Array.isArray(address)) {
+        return res.status(400).json({
+          success: false,
+          error: 'address can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      const cashAddr = this._validateAndConvertAddress(address)
+
+      const result = await this.fulcrumUseCases.getUtxos({ address: cashAddr })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/utxos Get utxos for an array of addresses
+   * @apiName GetUtxosBulk
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of objects with UTXOs associated with an address. Limited to 20 items per request.
+   */
+  async utxosBulk (req, res) {
+    try {
+      const addresses = req.body.addresses
+
+      if (!Array.isArray(addresses)) {
+        return res.status(400).json({
+          success: false,
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(addresses.length)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate and convert all addresses
+      const validatedAddresses = []
+      for (let i = 0; i < addresses.length; i++) {
+        try {
+          const cashAddr = this._validateAndConvertAddress(addresses[i])
+          validatedAddresses.push(cashAddr)
+        } catch (err) {
+          return res.status(400).json({
+            success: false,
+            error: err.message
+          })
+        }
+      }
+
+      const result = await this.fulcrumUseCases.getUtxosBulk({ addresses: validatedAddresses })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/tx/data/:txid Get transaction details for a TXID
+   * @apiName GetTransactionDetails
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an object with transaction details of the TXID
+   */
+  async getTransactionDetails (req, res) {
+    try {
+      const txid = req.params.txid
+
+      if (typeof txid !== 'string') {
+        return res.status(400).json({
+          success: false,
+          error: 'txid must be a string'
+        })
+      }
+
+      const result = await this.fulcrumUseCases.getTransactionDetails({ txid })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/tx/data Get transaction details for an array of TXIDs
+   * @apiName GetTransactionDetailsBulk
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of objects with transaction details of an array of TXIDs. Limited to 20 items per request.
+   */
+  async transactionDetailsBulk (req, res) {
+    try {
+      const txids = req.body.txids
+      const verbose = req.body.verbose !== undefined ? req.body.verbose : true
+
+      if (!Array.isArray(txids)) {
+        return res.status(400).json({
+          success: false,
+          error: 'txids needs to be an array. Use GET for single txid.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(txids.length)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Array too large.'
+        })
+      }
+
+      const result = await this.fulcrumUseCases.getTransactionDetailsBulk({ txids, verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/tx/broadcast Broadcast a raw transaction
+   * @apiName BroadcastTransaction
+   * @apiGroup Fulcrum
+   * @apiDescription Broadcast a raw transaction and return the transaction ID on success or error on failure.
+   */
+  async broadcastTransaction (req, res) {
+    try {
+      const txHex = req.body.txHex
+
+      if (typeof txHex !== 'string') {
+        return res.status(400).json({
+          success: false,
+          error: 'txHex must be a string'
+        })
+      }
+
+      const result = await this.fulcrumUseCases.broadcastTransaction({ txHex })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/block/headers/:height Get block headers
+   * @apiName GetBlockHeaders
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array with block headers starting at the block height
+   *
+   * @apiParam {Number} height Block height
+   * @apiParam {Number} count Number of block headers to return (query parameter, default: 1)
+   */
+  async getBlockHeaders (req, res) {
+    try {
+      const heightRaw = req.params.height
+      const countRaw = req.query.count
+
+      const height = Number(heightRaw)
+      const count = countRaw === undefined ? 1 : Number(countRaw)
+
+      if (Number.isNaN(height) || height < 0) {
+        return res.status(400).json({
+          success: false,
+          error: 'height must be a positive number'
+        })
+      }
+
+      if (Number.isNaN(count) || count < 0) {
+        return res.status(400).json({
+          success: false,
+          error: 'count must be a positive number'
+        })
+      }
+
+      const result = await this.fulcrumUseCases.getBlockHeaders({ height, count })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/block/headers Get block headers for an array of height + count pairs
+   * @apiName GetBlockHeadersBulk
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of objects with block headers. Limited to 20 items per request.
+   */
+  async blockHeadersBulk (req, res) {
+    try {
+      const heights = req.body.heights
+
+      if (!Array.isArray(heights)) {
+        return res.status(400).json({
+          success: false,
+          error: 'heights needs to be an array. Use GET for single height.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(heights.length)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate each height object
+      for (const item of heights) {
+        if (!item || typeof item.height !== 'number' || typeof item.count !== 'number') {
+          return res.status(400).json({
+            success: false,
+            error: 'Each height object must have numeric height and count properties'
+          })
+        }
+        if (item.height < 0 || item.count < 0) {
+          return res.status(400).json({
+            success: false,
+            error: 'height and count must be positive numbers'
+          })
+        }
+      }
+
+      const result = await this.fulcrumUseCases.getBlockHeadersBulk({ heights })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/transactions/:address Get transaction history for a single address
+   * @apiName GetTransactions
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of historical transactions associated with an address. Results are returned in descending order (most recent TX first). Passing allTxs=true will return the entire transaction history, otherwise, only the last 100 TXIDs will be returned.
+   *
+   * @apiParam {String} address Address
+   * @apiParam {Boolean} allTxs Optional: return all transactions (default: false, limited to 100)
+   */
+  async getTransactions (req, res) {
+    try {
+      const address = req.params.address
+      let allTxs = false
+
+      // Check if allTxs is in params or query
+      if (req.params.allTxs) {
+        allTxs = req.params.allTxs === 'true'
+      } else if (req.query.allTxs) {
+        allTxs = req.query.allTxs === 'true'
+      }
+
+      if (Array.isArray(address)) {
+        return res.status(400).json({
+          success: false,
+          error: 'address can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      const cashAddr = this._validateAndConvertAddress(address)
+
+      const result = await this.fulcrumUseCases.getTransactions({ address: cashAddr, allTxs })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/transactions Get the transaction history for an array of addresses
+   * @apiName GetTransactionsBulk
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of transactions associated with an array of addresses. Limited to 20 items per request. Passing allTxs=true will return the entire transaction history, otherwise, only the last 100 TXIDs will be returned.
+   */
+  async transactionsBulk (req, res) {
+    try {
+      const addresses = req.body.addresses
+      const allTxs = req.body.allTxs === true
+
+      if (!Array.isArray(addresses)) {
+        return res.status(400).json({
+          success: false,
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(addresses.length)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate and convert all addresses
+      const validatedAddresses = []
+      for (let i = 0; i < addresses.length; i++) {
+        try {
+          const cashAddr = this._validateAndConvertAddress(addresses[i])
+          validatedAddresses.push(cashAddr)
+        } catch (err) {
+          return res.status(400).json({
+            success: false,
+            error: err.message
+          })
+        }
+      }
+
+      const result = await this.fulcrumUseCases.getTransactionsBulk({
+        addresses: validatedAddresses,
+        allTxs
+      })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/fulcrum/unconfirmed/:address Get unconfirmed utxos for a single address
+   * @apiName GetMempool
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an object with unconfirmed UTXOs associated with an address.
+   */
+  async getMempool (req, res) {
+    try {
+      const address = req.params.address
+
+      if (Array.isArray(address)) {
+        return res.status(400).json({
+          success: false,
+          error: 'address can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      const cashAddr = this._validateAndConvertAddress(address)
+
+      const result = await this.fulcrumUseCases.getMempool({ address: cashAddr })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/fulcrum/unconfirmed Get unconfirmed utxos for an array of addresses
+   * @apiName GetMempoolBulk
+   * @apiGroup Fulcrum
+   * @apiDescription Returns an array of objects with unconfirmed UTXOs associated with an address. Limited to 20 items per request.
+   */
+  async mempoolBulk (req, res) {
+    try {
+      const addresses = req.body.addresses
+
+      if (!Array.isArray(addresses)) {
+        return res.status(400).json({
+          success: false,
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(addresses.length)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate and convert all addresses
+      const validatedAddresses = []
+      for (let i = 0; i < addresses.length; i++) {
+        try {
+          const cashAddr = this._validateAndConvertAddress(addresses[i])
+          validatedAddresses.push(cashAddr)
+        } catch (err) {
+          return res.status(400).json({
+            success: false,
+            error: err.message
+          })
+        }
+      }
+
+      const result = await this.fulcrumUseCases.getMempoolBulk({ addresses: validatedAddresses })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in FulcrumRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default FulcrumRESTController

src/controllers/rest-api/fulcrum/router.js

@@ -0,0 +1,64 @@
+/*
+  REST API router for /full-node/fulcrum routes.
+*/
+
+import express from 'express'
+import FulcrumRESTController from './controller.js'
+
+class FulcrumRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Fulcrum REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating Fulcrum REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.fulcrumController = new FulcrumRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/fulcrum`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.fulcrumController.root)
+    this.router.get('/balance/:address', this.fulcrumController.getBalance)
+    this.router.post('/balance', this.fulcrumController.balanceBulk)
+    this.router.get('/utxos/:address', this.fulcrumController.getUtxos)
+    this.router.post('/utxos', this.fulcrumController.utxosBulk)
+    this.router.get('/tx/data/:txid', this.fulcrumController.getTransactionDetails)
+    this.router.post('/tx/data', this.fulcrumController.transactionDetailsBulk)
+    this.router.post('/tx/broadcast', this.fulcrumController.broadcastTransaction)
+    this.router.get('/block/headers/:height', this.fulcrumController.getBlockHeaders)
+    this.router.post('/block/headers', this.fulcrumController.blockHeadersBulk)
+    this.router.get('/transactions/:address', this.fulcrumController.getTransactions)
+    this.router.get('/transactions/:address/:allTxs', this.fulcrumController.getTransactions)
+    this.router.post('/transactions', this.fulcrumController.transactionsBulk)
+    this.router.get('/unconfirmed/:address', this.fulcrumController.getMempool)
+    this.router.post('/unconfirmed', this.fulcrumController.mempoolBulk)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default FulcrumRouter

src/controllers/rest-api/full-node/blockchain/controller.js

@@ -0,0 +1,553 @@
+/*
+  REST API Controller for the /full-node/blockchain routes.
+*/
+
+import wlogger from '../../../../adapters/wlogger.js'
+
+class BlockchainRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Blockchain REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.blockchain) {
+      throw new Error(
+        'Instance of Blockchain use cases required when instantiating Blockchain REST Controller.'
+      )
+    }
+
+    this.blockchainUseCases = this.useCases.blockchain
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.getBestBlockHash = this.getBestBlockHash.bind(this)
+    this.getBlockchainInfo = this.getBlockchainInfo.bind(this)
+    this.getBlockCount = this.getBlockCount.bind(this)
+    this.getBlockHeaderSingle = this.getBlockHeaderSingle.bind(this)
+    this.getBlockHeaderBulk = this.getBlockHeaderBulk.bind(this)
+    this.getChainTips = this.getChainTips.bind(this)
+    this.getDifficulty = this.getDifficulty.bind(this)
+    this.getMempoolEntrySingle = this.getMempoolEntrySingle.bind(this)
+    this.getMempoolEntryBulk = this.getMempoolEntryBulk.bind(this)
+    this.getMempoolAncestorsSingle = this.getMempoolAncestorsSingle.bind(this)
+    this.getMempoolInfo = this.getMempoolInfo.bind(this)
+    this.getRawMempool = this.getRawMempool.bind(this)
+    this.getTxOut = this.getTxOut.bind(this)
+    this.getTxOutPost = this.getTxOutPost.bind(this)
+    this.getTxOutProofSingle = this.getTxOutProofSingle.bind(this)
+    this.getTxOutProofBulk = this.getTxOutProofBulk.bind(this)
+    this.verifyTxOutProofSingle = this.verifyTxOutProofSingle.bind(this)
+    this.verifyTxOutProofBulk = this.verifyTxOutProofBulk.bind(this)
+    this.getBlock = this.getBlock.bind(this)
+    this.getBlockHash = this.getBlockHash.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/ Service status
+   * @apiName BlockchainRoot
+   * @apiGroup Blockchain
+   *
+   * @apiDescription Returns the status of the blockchain service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'blockchain' })
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getBestBlockHash Get best block hash
+   * @apiName GetBestBlockHash
+   * @apiGroup Blockchain
+   * @apiDescription Returns the hash of the best (tip) block in the longest block chain.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/blockchain/getBestBlockHash" -H "accept: application/json"
+   *
+   * @apiSuccess {String} bestBlockHash Hash of the best block
+   */
+  async getBestBlockHash (req, res) {
+    try {
+      const result = await this.blockchainUseCases.getBestBlockHash()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getBlockchainInfo Get blockchain info
+   * @apiName GetBlockchainInfo
+   * @apiGroup Blockchain
+   * @apiDescription Returns various state info regarding blockchain processing.
+   */
+  async getBlockchainInfo (req, res) {
+    try {
+      const result = await this.blockchainUseCases.getBlockchainInfo()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getBlockCount Get block count
+   * @apiName GetBlockCount
+   * @apiGroup Blockchain
+   * @apiDescription Returns the number of blocks in the longest blockchain.
+   */
+  async getBlockCount (req, res) {
+    try {
+      const result = await this.blockchainUseCases.getBlockCount()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getBlockHeader/:hash Get single block header
+   * @apiName GetSingleBlockHeader
+   * @apiGroup Blockchain
+   * @apiDescription Returns serialized block header data.
+   *
+   * @apiParam {String} hash Block hash
+   * @apiParam {Boolean} verbose Return verbose data (default false)
+   */
+  async getBlockHeaderSingle (req, res) {
+    try {
+      const hash = req.params.hash
+      if (!hash) {
+        return res.status(400).json({ error: 'hash can not be empty' })
+      }
+
+      const verbose = req.query.verbose?.toString() === 'true'
+      const result = await this.blockchainUseCases.getBlockHeader({ hash, verbose })
+
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/blockchain/getBlockHeader Get multiple block headers
+   * @apiName GetBulkBlockHeader
+   * @apiGroup Blockchain
+   * @apiDescription Returns serialized block header data for multiple hashes.
+   *
+   * @apiParam {String[]} hashes Block hashes
+   * @apiParam {Boolean} verbose Return verbose data (default false)
+   */
+  async getBlockHeaderBulk (req, res) {
+    try {
+      const hashes = req.body.hashes
+      const verbose = !!req.body.verbose
+
+      if (!Array.isArray(hashes)) {
+        return res.status(400).json({
+          error: 'hashes needs to be an array. Use GET for single hash.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(hashes.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      for (const hash of hashes) {
+        if (!hash || hash.length !== 64) {
+          return res.status(400).json({ error: `This is not a hash: ${hash}` })
+        }
+      }
+
+      const result = await this.blockchainUseCases.getBlockHeaders({ hashes, verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getChainTips Get chain tips
+   * @apiName GetChainTips
+   * @apiGroup Blockchain
+   * @apiDescription Returns information about known tips in the block tree.
+   */
+  async getChainTips (req, res) {
+    try {
+      const result = await this.blockchainUseCases.getChainTips()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getDifficulty Get difficulty
+   * @apiName GetDifficulty
+   * @apiGroup Blockchain
+   * @apiDescription Returns the current difficulty value.
+   */
+  async getDifficulty (req, res) {
+    try {
+      const result = await this.blockchainUseCases.getDifficulty()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getMempoolEntry/:txid Get single mempool entry
+   * @apiName GetMempoolEntry
+   * @apiGroup Blockchain
+   * @apiDescription Returns mempool data for a transaction.
+   */
+  async getMempoolEntrySingle (req, res) {
+    try {
+      const txid = req.params.txid
+      if (!txid) {
+        return res.status(400).json({ error: 'txid can not be empty' })
+      }
+
+      const result = await this.blockchainUseCases.getMempoolEntry({ txid })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/blockchain/getMempoolEntry Get bulk mempool entry
+   * @apiName GetMempoolEntryBulk
+   * @apiGroup Blockchain
+   * @apiDescription Returns mempool data for multiple transactions.
+   */
+  async getMempoolEntryBulk (req, res) {
+    try {
+      const txids = req.body.txids
+
+      if (!Array.isArray(txids)) {
+        return res.status(400).json({
+          error: 'txids needs to be an array. Use GET for single txid.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(txids.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      for (const txid of txids) {
+        if (!txid || txid.length !== 64) {
+          return res.status(400).json({ error: 'This is not a txid' })
+        }
+      }
+
+      const result = await this.blockchainUseCases.getMempoolEntries({ txids })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getMempoolAncestors/:txid Get mempool ancestors
+   * @apiName GetMempoolAncestors
+   * @apiGroup Blockchain
+   * @apiDescription Returns mempool ancestor data for a transaction.
+   */
+  async getMempoolAncestorsSingle (req, res) {
+    try {
+      const txid = req.params.txid
+      if (!txid) {
+        return res.status(400).json({ error: 'txid can not be empty' })
+      }
+
+      let verbose = false
+      if (req.query.verbose && req.query.verbose.toString() === 'true') {
+        verbose = true
+      }
+
+      const result = await this.blockchainUseCases.getMempoolAncestors({ txid, verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getMempoolInfo Get mempool info
+   * @apiName GetMempoolInfo
+   * @apiGroup Blockchain
+   * @apiDescription Returns details on the state of the mempool.
+   */
+  async getMempoolInfo (req, res) {
+    try {
+      const result = await this.blockchainUseCases.getMempoolInfo()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getRawMempool Get raw mempool
+   * @apiName GetRawMempool
+   * @apiGroup Blockchain
+   * @apiDescription Returns all transaction ids in the mempool.
+   *
+   * @apiParam {Boolean} verbose Return verbose data (default false)
+   */
+  async getRawMempool (req, res) {
+    try {
+      const verbose = req.query.verbose === 'true'
+      const result = await this.blockchainUseCases.getRawMempool({ verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getTxOut/:txid/:n Get transaction output
+   * @apiName GetTxOut
+   * @apiGroup Blockchain
+   * @apiDescription Returns details about an unspent transaction output.
+   */
+  async getTxOut (req, res) {
+    try {
+      const txid = req.params.txid
+      if (!txid) {
+        return res.status(400).json({ error: 'txid can not be empty' })
+      }
+
+      const nRaw = req.params.n
+      if (nRaw === undefined || nRaw === '') {
+        return res.status(400).json({ error: 'n can not be empty' })
+      }
+
+      const n = parseInt(nRaw)
+      const includeMempool = req.query.includeMempool === 'true'
+
+      const result = await this.blockchainUseCases.getTxOut({
+        txid,
+        n,
+        includeMempool
+      })
+
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/blockchain/getTxOut Validate a UTXO
+   * @apiName GetTxOutPost
+   * @apiGroup Blockchain
+   * @apiDescription Returns details about an unspent transaction output.
+   */
+  async getTxOutPost (req, res) {
+    try {
+      const txid = req.body.txid
+      if (!txid) {
+        return res.status(400).json({ error: 'txid can not be empty' })
+      }
+
+      const voutRaw = req.body.vout
+      if (voutRaw === undefined || voutRaw === '') {
+        return res.status(400).json({ error: 'vout can not be empty' })
+      }
+
+      const n = parseInt(voutRaw)
+      const mempool = req.body.mempool !== undefined ? !!req.body.mempool : true
+
+      const result = await this.blockchainUseCases.getTxOut({
+        txid,
+        n,
+        includeMempool: mempool
+      })
+
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getTxOutProof/:txid Get TxOut proof
+   * @apiName GetTxOutProofSingle
+   * @apiGroup Blockchain
+   * @apiDescription Returns a hex-encoded proof that the transaction was included in a block.
+   */
+  async getTxOutProofSingle (req, res) {
+    try {
+      const txid = req.params.txid
+      if (!txid) {
+        return res.status(400).json({ error: 'txid can not be empty' })
+      }
+
+      const result = await this.blockchainUseCases.getTxOutProof({ txid })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/blockchain/getTxOutProof Get TxOut proofs
+   * @apiName GetTxOutProofBulk
+   * @apiGroup Blockchain
+   * @apiDescription Returns hex-encoded proofs for transactions.
+   */
+  async getTxOutProofBulk (req, res) {
+    try {
+      const txids = req.body.txids
+
+      if (!Array.isArray(txids)) {
+        return res.status(400).json({
+          error: 'txids needs to be an array. Use GET for single txid.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(txids.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      for (const txid of txids) {
+        if (!txid || txid.length !== 64) {
+          return res.status(400).json({
+            error: `Invalid txid. Double check your txid is valid: ${txid}`
+          })
+        }
+      }
+
+      const result = await this.blockchainUseCases.getTxOutProofs({ txids })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/verifyTxOutProof/:proof Verify TxOut proof
+   * @apiName VerifyTxOutProofSingle
+   * @apiGroup Blockchain
+   * @apiDescription Verifies a hex-encoded proof was included in a block.
+   */
+  async verifyTxOutProofSingle (req, res) {
+    try {
+      const proof = req.params.proof
+      if (!proof) {
+        return res.status(400).json({ error: 'proof can not be empty' })
+      }
+
+      const result = await this.blockchainUseCases.verifyTxOutProof({ proof })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/blockchain/verifyTxOutProof Verify TxOut proofs
+   * @apiName VerifyTxOutProofBulk
+   * @apiGroup Blockchain
+   * @apiDescription Verifies hex-encoded proofs were included in blocks.
+   */
+  async verifyTxOutProofBulk (req, res) {
+    try {
+      const proofs = req.body.proofs
+
+      if (!Array.isArray(proofs)) {
+        return res.status(400).json({
+          error: 'proofs needs to be an array. Use GET for single proof.'
+        })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(proofs.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      for (const proof of proofs) {
+        if (!proof) {
+          return res.status(400).json({ error: `proof can not be empty: ${proof}` })
+        }
+      }
+
+      const result = await this.blockchainUseCases.verifyTxOutProofs({ proofs })
+      const flattened = result.map(entry => Array.isArray(entry) ? entry[0] : entry)
+
+      return res.status(200).json(flattened)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/blockchain/getBlock Get block details
+   * @apiName GetBlock
+   * @apiGroup Blockchain
+   * @apiDescription Returns block details for a hash.
+   */
+  async getBlock (req, res) {
+    try {
+      const blockhash = req.body.blockhash
+      if (!blockhash) {
+        return res.status(400).json({ error: 'blockhash can not be empty' })
+      }
+
+      let verbosity = req.body.verbosity
+      if (verbosity === undefined || verbosity === null) {
+        verbosity = 1
+      }
+
+      const result = await this.blockchainUseCases.getBlock({
+        blockhash,
+        verbosity
+      })
+
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/blockchain/getBlockHash/:height Get block hash
+   * @apiName GetBlockHash
+   * @apiGroup Blockchain
+   * @apiDescription Returns the hash of a block by height.
+   */
+  async getBlockHash (req, res) {
+    try {
+      const heightRaw = req.params.height
+      if (!heightRaw) {
+        return res.status(400).json({ error: 'height can not be empty' })
+      }
+
+      const height = parseInt(heightRaw)
+      const result = await this.blockchainUseCases.getBlockHash({ height })
+
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in BlockchainRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default BlockchainRESTController

src/controllers/rest-api/full-node/blockchain/router.js

@@ -0,0 +1,70 @@
+/*
+  REST API router for /full-node/blockchain routes.
+*/
+
+import express from 'express'
+import BlockchainRESTController from './controller.js'
+
+class BlockchainRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Blockchain REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating Blockchain REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.blockchainController = new BlockchainRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/full-node/blockchain`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.blockchainController.root)
+    this.router.get('/getBestBlockHash', this.blockchainController.getBestBlockHash)
+    this.router.get('/getBlockchainInfo', this.blockchainController.getBlockchainInfo)
+    this.router.get('/getBlockCount', this.blockchainController.getBlockCount)
+    this.router.get('/getBlockHeader/:hash', this.blockchainController.getBlockHeaderSingle)
+    this.router.post('/getBlockHeader', this.blockchainController.getBlockHeaderBulk)
+    this.router.get('/getChainTips', this.blockchainController.getChainTips)
+    this.router.get('/getDifficulty', this.blockchainController.getDifficulty)
+    this.router.get('/getMempoolEntry/:txid', this.blockchainController.getMempoolEntrySingle)
+    this.router.post('/getMempoolEntry', this.blockchainController.getMempoolEntryBulk)
+    this.router.get('/getMempoolAncestors/:txid', this.blockchainController.getMempoolAncestorsSingle)
+    this.router.get('/getMempoolInfo', this.blockchainController.getMempoolInfo)
+    this.router.get('/getRawMempool', this.blockchainController.getRawMempool)
+    this.router.get('/getTxOut/:txid/:n', this.blockchainController.getTxOut)
+    this.router.post('/getTxOut', this.blockchainController.getTxOutPost)
+    this.router.get('/getTxOutProof/:txid', this.blockchainController.getTxOutProofSingle)
+    this.router.post('/getTxOutProof', this.blockchainController.getTxOutProofBulk)
+    this.router.get('/verifyTxOutProof/:proof', this.blockchainController.verifyTxOutProofSingle)
+    this.router.post('/verifyTxOutProof', this.blockchainController.verifyTxOutProofBulk)
+    this.router.post('/getBlock', this.blockchainController.getBlock)
+    this.router.get('/getBlockHash/:height', this.blockchainController.getBlockHash)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default BlockchainRouter

src/controllers/rest-api/full-node/control/controller.js

@@ -0,0 +1,68 @@
+/*
+  REST API Controller for the /full-node/control routes.
+*/
+
+import wlogger from '../../../../adapters/wlogger.js'
+
+class ControlRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Control REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.control) {
+      throw new Error(
+        'Instance of Control use cases required when instantiating Control REST Controller.'
+      )
+    }
+
+    this.controlUseCases = this.useCases.control
+
+    this.root = this.root.bind(this)
+    this.getNetworkInfo = this.getNetworkInfo.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/full-node/control/ Service status
+   * @apiName ControlRoot
+   * @apiGroup Control
+   *
+   * @apiDescription Returns the status of the control service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'control' })
+  }
+
+  /**
+   * @api {get} /v6/full-node/control/getNetworkInfo Get Network Info
+   * @apiName GetNetworkInfo
+   * @apiGroup Control
+   * @apiDescription RPC call that gets basic full node information.
+   */
+  async getNetworkInfo (req, res) {
+    try {
+      const result = await this.controlUseCases.getNetworkInfo()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in ControlRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default ControlRESTController

src/controllers/rest-api/full-node/control/router.js

@@ -0,0 +1,51 @@
+/*
+  REST API router for /full-node/control routes.
+*/
+
+import express from 'express'
+import ControlRESTController from './controller.js'
+
+class ControlRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Control REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating Control REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.controlController = new ControlRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/full-node/control`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.controlController.root)
+    this.router.get('/getNetworkInfo', this.controlController.getNetworkInfo)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default ControlRouter

src/controllers/rest-api/full-node/dsproof/controller.js

@@ -0,0 +1,90 @@
+/*
+  REST API Controller for the /full-node/dsproof routes.
+*/
+
+import wlogger from '../../../../adapters/wlogger.js'
+
+class DSProofRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating DSProof REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.dsproof) {
+      throw new Error(
+        'Instance of DSProof use cases required when instantiating DSProof REST Controller.'
+      )
+    }
+
+    this.dsproofUseCases = this.useCases.dsproof
+
+    this.root = this.root.bind(this)
+    this.getDSProof = this.getDSProof.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/full-node/dsproof/ Service status
+   * @apiName DSProofRoot
+   * @apiGroup DSProof
+   *
+   * @apiDescription Returns the status of the dsproof service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'dsproof' })
+  }
+
+  /**
+   * @api {get} /v6/full-node/dsproof/getDSProof/:txid Get Double-Spend Proof
+   * @apiName GetDSProof
+   * @apiGroup DSProof
+   * @apiDescription Get information for a double-spend proof.
+   *
+   * @apiParam {String} txid Transaction ID
+   * @apiParam {String} verbose Verbose level (`false`, `true`) for compatibility with legacy API
+   */
+  async getDSProof (req, res) {
+    try {
+      const txid = req.params.txid
+
+      if (!txid) {
+        return res.status(400).json({
+          success: false,
+          error: 'txid can not be empty'
+        })
+      }
+
+      if (txid.length !== 64) {
+        return res.status(400).json({
+          success: false,
+          error: `txid must be of length 64 (not ${txid.length})`
+        })
+      }
+
+      let verbose = 2
+      if (req.query.verbose === 'true') verbose = 3
+
+      const result = await this.dsproofUseCases.getDSProof({ txid, verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in DSProofRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default DSProofRESTController

src/controllers/rest-api/full-node/dsproof/router.js

@@ -0,0 +1,51 @@
+/*
+  REST API router for /full-node/dsproof routes.
+*/
+
+import express from 'express'
+import DSProofRESTController from './controller.js'
+
+class DSProofRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating DSProof REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating DSProof REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.dsproofController = new DSProofRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/full-node/dsproof`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.dsproofController.root)
+    this.router.get('/getDSProof/:txid', this.dsproofController.getDSProof)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default DSProofRouter

src/controllers/rest-api/full-node/mining/controller.js

@@ -0,0 +1,99 @@
+/*
+  REST API Controller for the /full-node/mining routes.
+*/
+
+import wlogger from '../../../../adapters/wlogger.js'
+
+class MiningRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Mining REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.mining) {
+      throw new Error(
+        'Instance of Mining use cases required when instantiating Mining REST Controller.'
+      )
+    }
+
+    this.miningUseCases = this.useCases.mining
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.getMiningInfo = this.getMiningInfo.bind(this)
+    this.getNetworkHashPS = this.getNetworkHashPS.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/full-node/mining/ Service status
+   * @apiName MiningRoot
+   * @apiGroup Mining
+   *
+   * @apiDescription Returns the status of the mining service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'mining' })
+  }
+
+  /**
+   * @api {get} /v6/full-node/mining/getMiningInfo Get Mining Info
+   * @apiName GetMiningInfo
+   * @apiGroup Mining
+   * @apiDescription Returns a json object containing mining-related information.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/mining/getMiningInfo" -H "accept: application/json"
+   */
+  async getMiningInfo (req, res) {
+    try {
+      const result = await this.miningUseCases.getMiningInfo()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/mining/getNetworkHashPS Get Estimated network hashes per second
+   * @apiName GetNetworkHashPS
+   * @apiGroup Mining
+   * @apiDescription Returns the estimated network hashes per second based on the last n blocks. Pass in [nblocks] to override # of blocks, -1 specifies since last difficulty change. Pass in [height] to estimate the network speed at the time when a certain block was found.
+   *
+   * @apiParam {Number} nblocks Number of blocks to use for estimation (default: 120)
+   * @apiParam {Number} height Block height to estimate at (default: -1)
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/mining/getNetworkHashPS?nblocks=120&height=-1" -H "accept: application/json"
+   */
+  async getNetworkHashPS (req, res) {
+    try {
+      let nblocks = 120 // Default
+      let height = -1 // Default
+      if (req.query.nblocks) nblocks = parseInt(req.query.nblocks)
+      if (req.query.height) height = parseInt(req.query.height)
+
+      const result = await this.miningUseCases.getNetworkHashPS({ nblocks, height })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in MiningRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default MiningRESTController

src/controllers/rest-api/full-node/mining/router.js

@@ -0,0 +1,52 @@
+/*
+  REST API router for /full-node/mining routes.
+*/
+
+import express from 'express'
+import MiningRESTController from './controller.js'
+
+class MiningRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Mining REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating Mining REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.miningController = new MiningRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/full-node/mining`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.miningController.root)
+    this.router.get('/getMiningInfo', this.miningController.getMiningInfo)
+    this.router.get('/getNetworkHashPS', this.miningController.getNetworkHashPS)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default MiningRouter

src/controllers/rest-api/full-node/rawtransactions/controller.js

@@ -0,0 +1,333 @@
+/*
+  REST API Controller for the /full-node/rawtransactions routes.
+*/
+
+import wlogger from '../../../../adapters/wlogger.js'
+
+class RawTransactionsRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating RawTransactions REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.rawtransactions) {
+      throw new Error(
+        'Instance of RawTransactions use cases required when instantiating RawTransactions REST Controller.'
+      )
+    }
+
+    this.rawtransactionsUseCases = this.useCases.rawtransactions
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.decodeRawTransactionSingle = this.decodeRawTransactionSingle.bind(this)
+    this.decodeRawTransactionBulk = this.decodeRawTransactionBulk.bind(this)
+    this.decodeScriptSingle = this.decodeScriptSingle.bind(this)
+    this.decodeScriptBulk = this.decodeScriptBulk.bind(this)
+    this.getRawTransactionSingle = this.getRawTransactionSingle.bind(this)
+    this.getRawTransactionBulk = this.getRawTransactionBulk.bind(this)
+    this.sendRawTransactionSingle = this.sendRawTransactionSingle.bind(this)
+    this.sendRawTransactionBulk = this.sendRawTransactionBulk.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/full-node/rawtransactions/ Service status
+   * @apiName RawTransactionsRoot
+   * @apiGroup RawTransactions
+   *
+   * @apiDescription Returns the status of the rawtransactions service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'rawtransactions' })
+  }
+
+  /**
+   * @api {get} /v6/full-node/rawtransactions/decodeRawTransaction/:hex Decode Single Raw Transaction
+   * @apiName DecodeSingleRawTransaction
+   * @apiGroup RawTransactions
+   * @apiDescription Return a JSON object representing the serialized, hex-encoded transaction.
+   *
+   * @apiParam {String} hex Hex-encoded transaction
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/rawtransactions/decodeRawTransaction/02000000010e991f7ccec410f27d333f737f149b5d3be6728687da81072e638aed0063a176010000006b483045022100cd20443b0af090053450bc4ab00d563d4ac5955bb36e0135b00b8a96a19f233302205047f2c70a08c6ef4b76f2d198b33a31d17edfaa7e1e9e865894da0d396009354121024d4e7f522f67105b7bf5f9dbe557e7b2244613fdfcd6fe09304f93877328f6beffffffff02a0860100000000001976a9140ee020c07f39526ac5505c54fa1ab98490979b8388acb5f0f70b000000001976a9143a9b2b0c12fe722fcf653b6ef5dcc38732d6ff5188ac00000000" -H "accept: application/json"
+   */
+  async decodeRawTransactionSingle (req, res) {
+    try {
+      const hex = req.params.hex
+
+      if (!hex || hex === '') {
+        return res.status(400).json({ error: 'hex can not be empty' })
+      }
+
+      const result = await this.rawtransactionsUseCases.decodeRawTransaction({ hex })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/rawtransactions/decodeRawTransaction Decode Bulk Raw Transactions
+   * @apiName DecodeBulkRawTransactions
+   * @apiGroup RawTransactions
+   * @apiDescription Return bulk hex encoded transaction.
+   *
+   * @apiParam {String[]} hexes Array of hex-encoded transactions
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v6/full-node/rawtransactions/decodeRawTransaction" -H "accept: application/json" -H "Content-Type: application/json" -d '{"hexes":["01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"]}'
+   */
+  async decodeRawTransactionBulk (req, res) {
+    try {
+      const hexes = req.body.hexes
+
+      if (!Array.isArray(hexes)) {
+        return res.status(400).json({ error: 'hexes must be an array' })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(hexes.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      // Validate each element in the array
+      for (const hex of hexes) {
+        if (!hex || hex === '') {
+          return res.status(400).json({ error: 'Encountered empty hex' })
+        }
+      }
+
+      const result = await this.rawtransactionsUseCases.decodeRawTransactions({ hexes })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/rawtransactions/decodeScript/:hex Decode Single Script
+   * @apiName DecodeSingleScript
+   * @apiGroup RawTransactions
+   * @apiDescription Decode a hex-encoded script.
+   *
+   * @apiParam {String} hex Hex-encoded script
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/rawtransactions/decodeScript/4830450221009a51e00ec3524a7389592bc27bea4af5104a59510f5f0cfafa64bbd5c164ca2e02206c2a8bbb47eabdeed52f17d7df668d521600286406930426e3a9415fe10ed592012102e6e1423f7abde8b70bca3e78a7d030e5efabd3eb35c19302542b5fe7879c1a16" -H "accept: application/json"
+   */
+  async decodeScriptSingle (req, res) {
+    try {
+      const hex = req.params.hex
+
+      if (!hex || hex === '') {
+        return res.status(400).json({ error: 'hex can not be empty' })
+      }
+
+      const result = await this.rawtransactionsUseCases.decodeScript({ hex })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/rawtransactions/decodeScript Bulk Decode Script
+   * @apiName DecodeBulkScript
+   * @apiGroup RawTransactions
+   * @apiDescription Decode multiple hex-encoded scripts.
+   *
+   * @apiParam {String[]} hexes Array of hex-encoded scripts
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v6/full-node/rawtransactions/decodeScript" -H "accept: application/json" -H "Content-Type: application/json" -d '{"hexes":["01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"]}'
+   */
+  async decodeScriptBulk (req, res) {
+    try {
+      const hexes = req.body.hexes
+
+      if (!Array.isArray(hexes)) {
+        return res.status(400).json({ error: 'hexes must be an array' })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(hexes.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      // Validate each hex in the array
+      for (const hex of hexes) {
+        if (!hex || hex === '') {
+          return res.status(400).json({ error: 'Encountered empty hex' })
+        }
+      }
+
+      const result = await this.rawtransactionsUseCases.decodeScripts({ hexes })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/rawtransactions/getRawTransaction/:txid Get Raw Transaction
+   * @apiName GetRawTransaction
+   * @apiGroup RawTransactions
+   * @apiDescription Return the raw transaction data. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.
+   *
+   * @apiParam {String} txid Transaction ID
+   * @apiParam {Boolean} verbose Return verbose data (default false)
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/rawtransactions/getRawTransaction/fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33?verbose=true" -H "accept: application/json"
+   */
+  async getRawTransactionSingle (req, res) {
+    try {
+      const txid = req.params.txid
+      const verbose = req.query.verbose === 'true'
+
+      if (!txid || txid === '') {
+        return res.status(400).json({ error: 'txid can not be empty' })
+      }
+
+      if (txid.length !== 64) {
+        return res.status(400).json({
+          error: `parameter 1 must be of length 64 (not ${txid.length})`
+        })
+      }
+
+      const result = await this.rawtransactionsUseCases.getRawTransactionWithHeight({ txid, verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/rawtransactions/getRawTransaction Get Bulk Raw Transactions
+   * @apiName GetBulkRawTransactions
+   * @apiGroup RawTransactions
+   * @apiDescription Return the raw transaction data for multiple transactions. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.
+   *
+   * @apiParam {String[]} txids Array of transaction IDs
+   * @apiParam {Boolean} verbose Return verbose data (default false)
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v6/full-node/rawtransactions/getRawTransaction" -H "accept: application/json" -H "Content-Type: application/json" -d '{"txids":["a5f972572ee1753e2fd2457dd61ce5f40fa2f8a30173d417e49feef7542c96a1","5165dc531aad05d1149bb0f0d9b7bda99c73e2f05e314bcfb5b4bb9ca5e1af5e"],"verbose":true}'
+   */
+  async getRawTransactionBulk (req, res) {
+    try {
+      const txids = req.body.txids
+      const verbose = !!req.body.verbose
+
+      if (!Array.isArray(txids)) {
+        return res.status(400).json({ error: 'txids must be an array' })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(txids.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      // Validate each txid in the array
+      for (const txid of txids) {
+        if (!txid || txid === '') {
+          return res.status(400).json({ error: 'Encountered empty TXID' })
+        }
+
+        if (txid.length !== 64) {
+          return res.status(400).json({
+            error: `parameter 1 must be of length 64 (not ${txid.length})`
+          })
+        }
+      }
+
+      const result = await this.rawtransactionsUseCases.getRawTransactions({ txids, verbose })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/full-node/rawtransactions/sendRawTransaction/:hex Send Single Raw Transaction
+   * @apiName SendSingleRawTransaction
+   * @apiGroup RawTransactions
+   * @apiDescription Submits single raw transaction (serialized, hex-encoded) to local node and network.
+   *
+   * @apiParam {String} hex Hex-encoded transaction
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/full-node/rawtransactions/sendRawTransaction/01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000" -H "accept: application/json"
+   */
+  async sendRawTransactionSingle (req, res) {
+    try {
+      const hex = req.params.hex
+
+      if (typeof hex !== 'string') {
+        return res.status(400).json({ error: 'hex must be a string' })
+      }
+
+      if (hex === '') {
+        return res.status(400).json({ error: 'Encountered empty hex' })
+      }
+
+      const result = await this.rawtransactionsUseCases.sendRawTransaction({ hex })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/full-node/rawtransactions/sendRawTransaction Send Bulk Raw Transactions
+   * @apiName SendBulkRawTransactions
+   * @apiGroup RawTransactions
+   * @apiDescription Submits multiple raw transaction (serialized, hex-encoded) to local node and network.
+   *
+   * @apiParam {String[]} hexes Array of hex-encoded transactions
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v6/full-node/rawtransactions/sendRawTransaction" -H "accept: application/json" -H "Content-Type: application/json" -d '{"hexes":["01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"]}'
+   */
+  async sendRawTransactionBulk (req, res) {
+    try {
+      const hexes = req.body.hexes
+
+      if (!Array.isArray(hexes)) {
+        return res.status(400).json({ error: 'hex must be an array' })
+      }
+
+      if (!this.adapters.fullNode.validateArraySize(hexes.length)) {
+        return res.status(400).json({ error: 'Array too large.' })
+      }
+
+      // Validate each element
+      for (const hex of hexes) {
+        if (hex === '') {
+          return res.status(400).json({ error: 'Encountered empty hex' })
+        }
+      }
+
+      const result = await this.rawtransactionsUseCases.sendRawTransactions({ hexes })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in RawTransactionsRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default RawTransactionsRESTController

src/controllers/rest-api/full-node/rawtransactions/router.js

@@ -0,0 +1,58 @@
+/*
+  REST API router for /full-node/rawtransactions routes.
+*/
+
+import express from 'express'
+import RawTransactionsRESTController from './controller.js'
+
+class RawTransactionsRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating RawTransactions REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating RawTransactions REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.rawtransactionsController = new RawTransactionsRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/full-node/rawtransactions`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.rawtransactionsController.root)
+    this.router.get('/decodeRawTransaction/:hex', this.rawtransactionsController.decodeRawTransactionSingle)
+    this.router.post('/decodeRawTransaction', this.rawtransactionsController.decodeRawTransactionBulk)
+    this.router.get('/decodeScript/:hex', this.rawtransactionsController.decodeScriptSingle)
+    this.router.post('/decodeScript', this.rawtransactionsController.decodeScriptBulk)
+    this.router.get('/getRawTransaction/:txid', this.rawtransactionsController.getRawTransactionSingle)
+    this.router.post('/getRawTransaction', this.rawtransactionsController.getRawTransactionBulk)
+    this.router.get('/sendRawTransaction/:hex', this.rawtransactionsController.sendRawTransactionSingle)
+    this.router.post('/sendRawTransaction', this.rawtransactionsController.sendRawTransactionBulk)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default RawTransactionsRouter

src/controllers/rest-api/index.js

@@ -7,6 +7,14 @@
 // Local libraries
 // import EventRouter from './event/index.js'
 // import ReqRouter from './req/index.js'
+import BlockchainRouter from './full-node/blockchain/router.js'
+import ControlRouter from './full-node/control/router.js'
+import DSProofRouter from './full-node/dsproof/router.js'
+import FulcrumRouter from './fulcrum/router.js'
+import MiningRouter from './full-node/mining/router.js'
+import PriceRouter from './price/router.js'
+import RawTransactionsRouter from './full-node/rawtransactions/router.js'
+import SlpRouter from './slp/router.js'
 import config from '../../config/index.js'
 
 class RESTControllers {
@@ -25,6 +33,12 @@ class RESTControllers {
       )
     }
 
+    // Allow overriding the API prefix for testing, default to v6.
+    this.apiPrefix = localConfig.apiPrefix || '/v6'
+    if (this.apiPrefix.length > 1 && this.apiPrefix.endsWith('/')) {
+      this.apiPrefix = this.apiPrefix.slice(0, -1)
+    }
+
     // Bind 'this' object to all subfunctions.
     this.attachRESTControllers = this.attachRESTControllers.bind(this)
 
@@ -33,10 +47,11 @@ class RESTControllers {
   }
 
   attachRESTControllers (app) {
-    // const dependencies = {
-    //   adapters: this.adapters,
-    //   useCases: this.useCases
-    // }
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases,
+      apiPrefix: this.apiPrefix
+    }
 
     // Attach the REST API Controllers associated with the /event route
     // const eventRouter = new EventRouter(dependencies)
@@ -45,6 +60,30 @@ class RESTControllers {
     // Attach the REST API Controllers associated with the /req route
     // const reqRouter = new ReqRouter(dependencies)
     // reqRouter.attach(app)
+
+    const blockchainRouter = new BlockchainRouter(dependencies)
+    blockchainRouter.attach(app)
+
+    const controlRouter = new ControlRouter(dependencies)
+    controlRouter.attach(app)
+
+    const dsproofRouter = new DSProofRouter(dependencies)
+    dsproofRouter.attach(app)
+
+    const fulcrumRouter = new FulcrumRouter(dependencies)
+    fulcrumRouter.attach(app)
+
+    const miningRouter = new MiningRouter(dependencies)
+    miningRouter.attach(app)
+
+    const priceRouter = new PriceRouter(dependencies)
+    priceRouter.attach(app)
+
+    const rawtransactionsRouter = new RawTransactionsRouter(dependencies)
+    rawtransactionsRouter.attach(app)
+
+    const slpRouter = new SlpRouter(dependencies)
+    slpRouter.attach(app)
   }
 }
 

src/controllers/rest-api/price/controller.js

@@ -0,0 +1,96 @@
+/*
+  REST API Controller for the /price routes.
+*/
+
+import wlogger from '../../../adapters/wlogger.js'
+
+class PriceRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Price REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.price) {
+      throw new Error(
+        'Instance of Price use cases required when instantiating Price REST Controller.'
+      )
+    }
+
+    this.priceUseCases = this.useCases.price
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.getBCHUSD = this.getBCHUSD.bind(this)
+    this.getPsffppWritePrice = this.getPsffppWritePrice.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/price/ Service status
+   * @apiName PriceRoot
+   * @apiGroup Price
+   *
+   * @apiDescription Returns the status of the price service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'price' })
+  }
+
+  /**
+   * @api {get} /v6/price/bchusd Get the USD price of BCH
+   * @apiName GetBCHUSD
+   * @apiGroup Price
+   * @apiDescription Get the USD price of BCH from Coinex.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/price/bchusd" -H "accept: application/json"
+   *
+   * @apiSuccess {Number} usd The USD price of BCH
+   */
+  async getBCHUSD (req, res) {
+    try {
+      const price = await this.priceUseCases.getBCHUSD()
+      return res.status(200).json({ usd: price })
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /v6/price/psffpp Get the PSF price for writing to the PSFFPP
+   * @apiName GetPsffppWritePrice
+   * @apiGroup Price
+   * @apiDescription Get the price to pin 1MB of content to the PSFFPP pinning
+   * network on IPFS. The price is denominated in PSF tokens.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/price/psffpp" -H "accept: application/json"
+   *
+   * @apiSuccess {Number} writePrice The price in PSF tokens to write 1MB to PSFFPP
+   */
+  async getPsffppWritePrice (req, res) {
+    try {
+      const writePrice = await this.priceUseCases.getPsffppWritePrice()
+      return res.status(200).json({ writePrice })
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in PriceRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default PriceRESTController

src/controllers/rest-api/price/router.js

@@ -0,0 +1,52 @@
+/*
+  REST API router for /price routes.
+*/
+
+import express from 'express'
+import PriceRESTController from './controller.js'
+
+class PriceRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Price REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating Price REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.priceController = new PriceRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/price`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.priceController.root)
+    this.router.get('/bchusd', this.priceController.getBCHUSD)
+    this.router.get('/psffpp', this.priceController.getPsffppWritePrice)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default PriceRouter

src/controllers/rest-api/req/controller.js

@@ -1,296 +0,0 @@
-/*
-  REST API Controller library for the /req route
-*/
-
-// Local libraries
-import wlogger from '../../../adapters/wlogger.js'
-
-class ReqRESTControllerLib {
-  constructor (localConfig = {}) {
-    // Dependency Injection.
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error(
-        'Instance of Adapters library required when instantiating /req REST Controller.'
-      )
-    }
-    this.useCases = localConfig.useCases
-    if (!this.useCases) {
-      throw new Error(
-        'Instance of Use Cases library required when instantiating /req REST Controller.'
-      )
-    }
-
-    // Bind 'this' object to all subfunctions
-    this.queryEvents = this.queryEvents.bind(this)
-    this.createSubscription = this.createSubscription.bind(this)
-    this.closeSubscription = this.closeSubscription.bind(this)
-    this.handleError = this.handleError.bind(this)
-  }
-
-  /**
-   * @api {get} /req/:subId Query events (stateless)
-   * @apiPermission public
-   * @apiName QueryEvents
-   * @apiGroup Request
-   *
-   * @apiDescription Query events from the relay with filters. Returns events immediately. Maps to: ["REQ", <sub_id>, <filters>]
-   *
-   * @apiParam {String} subId Subscription ID (unique identifier)
-   * @apiParam {String} filters JSON-encoded filters object (query parameter)
-   *
-   * @apiExample {curl} Example usage:
-   * curl -X GET "http://localhost:3000/req/sub1?filters=[{\"kinds\":[1],\"limit\":10}]"
-   *
-   * @apiSuccess {Array} events Array of Nostr events
-   *
-   * @apiError {String} error Error message
-   */
-  async queryEvents (req, res) {
-    try {
-      const { subId } = req.params
-      let filters = req.query.filters
-
-      if (!subId) {
-        return res.status(400).json({
-          error: 'Subscription ID is required'
-        })
-      }
-
-      // Parse filters from query string
-      if (typeof filters === 'string') {
-        try {
-          filters = JSON.parse(filters)
-        } catch (err) {
-          return res.status(400).json({
-            error: 'Invalid filters JSON'
-          })
-        }
-      } else if (!filters) {
-        // If no filters provided, accept filters from query params
-        filters = {}
-        if (req.query.kinds) {
-          filters.kinds = JSON.parse(req.query.kinds)
-        }
-        if (req.query.authors) {
-          filters.authors = JSON.parse(req.query.authors)
-        }
-        if (req.query.ids) {
-          filters.ids = JSON.parse(req.query.ids)
-        }
-        if (req.query.limit) {
-          filters.limit = parseInt(req.query.limit)
-        }
-        if (req.query.since) {
-          filters.since = parseInt(req.query.since)
-        }
-        if (req.query.until) {
-          filters.until = parseInt(req.query.until)
-        }
-      }
-
-      // Ensure filters is an array (Nostr protocol expects array of filters)
-      const filtersArray = Array.isArray(filters) ? filters : [filters]
-
-      const events = await this.useCases.queryEvents.execute(filtersArray, subId)
-
-      return res.status(200).json(events)
-    } catch (err) {
-      return this.handleError(err, req, res)
-    }
-  }
-
-  /**
-   * @api {post} /req/:subId Create subscription (SSE)
-   * @apiPermission public
-   * @apiName CreateSubscription
-   * @apiGroup Request
-   *
-   * @apiDescription Create a subscription for Server-Sent Events. Maps to: ["REQ", <sub_id>, <filters>]
-   *
-   * @apiParam {String} subId Subscription ID (unique identifier)
-   * @apiParam {Object} filters Filters object in request body
-   *
-   * @apiExample {json} Example usage:
-   * {
-   *   "kinds": [1],
-   *   "authors": ["2c7e76c0f8dc1dca9d0197c7d19be580a8d074ccada6a2f6ebe056ae41092e9"]
-   * }
-   *
-   * @apiSuccess {String} message Success message
-   *
-   * @apiError {String} error Error message
-   */
-  async createSubscription (req, res) {
-    try {
-      const { subId } = req.params
-      const filters = req.body
-
-      if (!subId) {
-        return res.status(400).json({
-          error: 'Subscription ID is required'
-        })
-      }
-
-      if (!filters || (typeof filters === 'object' && Object.keys(filters).length === 0)) {
-        return res.status(400).json({
-          error: 'Filters are required'
-        })
-      }
-
-      // Ensure filters is an array
-      const filtersArray = Array.isArray(filters) ? filters : [filters]
-
-      // Set up Server-Sent Events
-      res.setHeader('Content-Type', 'text/event-stream')
-      res.setHeader('Cache-Control', 'no-cache')
-      res.setHeader('Connection', 'keep-alive')
-      res.setHeader('X-Accel-Buffering', 'no') // Disable buffering in nginx
-
-      // Track if response is still writable
-      let isResponseWritable = true
-
-      // Helper function to safely write to SSE stream
-      const safeWrite = (data) => {
-        if (!isResponseWritable) {
-          return false
-        }
-        try {
-          if (!res.writable || res.destroyed || res.closed) {
-            isResponseWritable = false
-            return false
-          }
-          return res.write(data)
-        } catch (err) {
-          wlogger.warn(`Error writing to SSE stream for subscription ${subId}:`, err.message)
-          isResponseWritable = false
-          return false
-        }
-      }
-
-      // Handle response stream errors
-      res.on('error', (err) => {
-        wlogger.warn(`Response stream error for subscription ${subId}:`, err.message)
-        isResponseWritable = false
-        // Clean up subscription on stream error
-        this.useCases.manageSubscription.closeSubscription(subId).catch(closeErr => {
-          wlogger.error('Error closing subscription on stream error:', closeErr)
-        })
-      })
-
-      // Send initial connection message
-      if (!safeWrite(`data: ${JSON.stringify({ type: 'connected', subscriptionId: subId })}\n\n`)) {
-        wlogger.warn(`Failed to send initial connection message for subscription ${subId}`)
-        return res.status(500).json({ error: 'Failed to establish SSE connection' })
-      }
-
-      // Handle events
-      const onEvent = (event) => {
-        if (!safeWrite(`data: ${JSON.stringify({ type: 'event', data: event })}\n\n`)) {
-          wlogger.debug(`Cannot write event to SSE stream for subscription ${subId} - connection may be closed`)
-        }
-      }
-
-      // Handle EOSE
-      const onEose = () => {
-        if (!safeWrite(`data: ${JSON.stringify({ type: 'eose' })}\n\n`)) {
-          wlogger.debug(`Cannot write EOSE to SSE stream for subscription ${subId} - connection may be closed`)
-        }
-      }
-
-      // Handle CLOSED
-      const onClosed = (message) => {
-        if (safeWrite(`data: ${JSON.stringify({ type: 'closed', message })}\n\n`)) {
-          try {
-            if (!res.destroyed && !res.closed) {
-              res.end()
-            }
-          } catch (err) {
-            wlogger.warn(`Error ending SSE stream for subscription ${subId}:`, err.message)
-          }
-        }
-        isResponseWritable = false
-      }
-
-      // Create subscription
-      await this.useCases.manageSubscription.createSubscription(
-        subId,
-        filtersArray,
-        onEvent,
-        onEose,
-        onClosed
-      )
-
-      // Handle client disconnect
-      req.on('close', () => {
-        wlogger.info(`Client disconnected from subscription ${subId}`)
-        isResponseWritable = false
-        this.useCases.manageSubscription.closeSubscription(subId).catch(err => {
-          wlogger.error('Error closing subscription on disconnect:', err)
-        })
-      })
-
-      // Handle response finish
-      res.on('finish', () => {
-        isResponseWritable = false
-      })
-    } catch (err) {
-      return this.handleError(err, req, res)
-    }
-  }
-
-  /**
-   * @api {put} /req/:subId Create subscription (SSE) - alternative method
-   * @apiPermission public
-   * @apiName CreateSubscriptionPut
-   * @apiGroup Request
-   *
-   * @apiDescription Same as POST /req/:subId - create a subscription for Server-Sent Events
-   */
-  async createSubscriptionPut (req, res) {
-    return this.createSubscription(req, res)
-  }
-
-  /**
-   * @api {delete} /req/:subId Close subscription
-   * @apiPermission public
-   * @apiName CloseSubscription
-   * @apiGroup Request
-   *
-   * @apiDescription Close an existing subscription. Maps to: ["CLOSE", <sub_id>]
-   *
-   * @apiParam {String} subId Subscription ID to close
-   *
-   * @apiSuccess {String} message Success message
-   *
-   * @apiError {String} error Error message
-   */
-  async closeSubscription (req, res) {
-    try {
-      const { subId } = req.params
-
-      if (!subId) {
-        return res.status(400).json({
-          error: 'Subscription ID is required'
-        })
-      }
-
-      await this.useCases.manageSubscription.closeSubscription(subId)
-
-      return res.status(200).json({
-        message: `Subscription ${subId} closed successfully`
-      })
-    } catch (err) {
-      return this.handleError(err, req, res)
-    }
-  }
-
-  handleError (err, req, res) {
-    wlogger.error('Error in ReqRESTController:', err)
-    return res.status(500).json({
-      error: err.message || 'Internal server error'
-    })
-  }
-}
-
-export default ReqRESTControllerLib

src/controllers/rest-api/req/index.js

@@ -1,75 +0,0 @@
-/*
-  REST API library for the /req route.
-*/
-
-// Public npm libraries.
-import express from 'express'
-
-// Local libraries.
-import ReqRESTControllerLib from './controller.js'
-
-class ReqRouter {
-  constructor (localConfig = {}) {
-    // Dependency Injection.
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error(
-        'Instance of Adapters library required when instantiating Req REST Controller.'
-      )
-    }
-    this.useCases = localConfig.useCases
-    if (!this.useCases) {
-      throw new Error(
-        'Instance of Use Cases library required when instantiating Req REST Controller.'
-      )
-    }
-
-    const dependencies = {
-      adapters: this.adapters,
-      useCases: this.useCases
-    }
-
-    // Encapsulate dependencies.
-    this.reqRESTController = new ReqRESTControllerLib(dependencies)
-
-    // Instantiate the router and set the base route.
-    this.router = express.Router()
-  }
-
-  attach (app) {
-    if (!app) {
-      throw new Error(
-        'Must pass app object when attaching REST API controllers.'
-      )
-    }
-
-    // Define the routes and attach the controller.
-    // Handle empty subId case first
-    this.router.get('/', (req, res) => {
-      res.status(400).json({
-        error: 'Subscription ID is required'
-      })
-    })
-    this.router.post('/', (req, res) => {
-      res.status(400).json({
-        error: 'Subscription ID is required'
-      })
-    })
-    this.router.delete('/', (req, res) => {
-      res.status(400).json({
-        error: 'Subscription ID is required'
-      })
-    })
-
-    // Routes with subId parameter
-    this.router.get('/:subId', this.reqRESTController.queryEvents)
-    this.router.post('/:subId', this.reqRESTController.createSubscription)
-    this.router.put('/:subId', this.reqRESTController.createSubscriptionPut)
-    this.router.delete('/:subId', this.reqRESTController.closeSubscription)
-
-    // Attach the Controller routes to the Express app.
-    app.use('/req', this.router)
-  }
-}
-
-export default ReqRouter

src/controllers/rest-api/slp/controller.js

@@ -0,0 +1,218 @@
+/*
+  REST API Controller for the /slp routes.
+*/
+
+import wlogger from '../../../adapters/wlogger.js'
+import BCHJS from '@psf/bch-js'
+
+const bchjs = new BCHJS()
+
+class SlpRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating SLP REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.slp) {
+      throw new Error(
+        'Instance of SLP use cases required when instantiating SLP REST Controller.'
+      )
+    }
+
+    this.slpUseCases = this.useCases.slp
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.getStatus = this.getStatus.bind(this)
+    this.getAddress = this.getAddress.bind(this)
+    this.getTxid = this.getTxid.bind(this)
+    this.getTokenStats = this.getTokenStats.bind(this)
+    this.getTokenData = this.getTokenData.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/slp/ Service status
+   * @apiName SlpRoot
+   * @apiGroup SLP
+   *
+   * @apiDescription Returns the status of the SLP service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'psf-slp-indexer' })
+  }
+
+  /**
+   * Validates and converts an address to cash address format
+   * @param {string} address - Address to validate and convert
+   * @returns {string} Cash address
+   * @throws {Error} If address is invalid or not mainnet
+   */
+  _validateAndConvertAddress (address) {
+    if (!address) {
+      throw new Error('address is empty')
+    }
+
+    // Convert legacy to cash address
+    const cashAddr = bchjs.SLP.Address.toCashAddress(address)
+
+    // Ensure it's a valid BCH address
+    try {
+      bchjs.SLP.Address.toLegacyAddress(cashAddr)
+    } catch (err) {
+      throw new Error(`Invalid BCH address. Double check your address is valid: ${address}`)
+    }
+
+    // Ensure it's mainnet (no testnet support)
+    const isMainnet = bchjs.Address.isMainnetAddress(cashAddr)
+    if (!isMainnet) {
+      throw new Error('Invalid network. Only mainnet addresses are supported.')
+    }
+
+    return cashAddr
+  }
+
+  /**
+   * @api {get} /v6/slp/status Get indexer status
+   * @apiName GetStatus
+   * @apiGroup SLP
+   * @apiDescription Returns the status of the SLP indexer.
+   */
+  async getStatus (req, res) {
+    try {
+      const result = await this.slpUseCases.getStatus()
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/slp/address Get SLP balance for address
+   * @apiName GetAddress
+   * @apiGroup SLP
+   * @apiDescription Returns SLP balance for an address.
+   */
+  async getAddress (req, res) {
+    try {
+      const address = req.body.address
+
+      if (!address || address === '') {
+        return res.status(400).json({
+          success: false,
+          error: 'address can not be empty'
+        })
+      }
+
+      // Validate and convert address
+      const cashAddr = this._validateAndConvertAddress(address)
+
+      const result = await this.slpUseCases.getAddress({ address: cashAddr })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/slp/txid Get SLP transaction data
+   * @apiName GetTxid
+   * @apiGroup SLP
+   * @apiDescription Returns SLP transaction data for a TXID.
+   */
+  async getTxid (req, res) {
+    try {
+      const txid = req.body.txid
+
+      if (!txid || txid === '') {
+        return res.status(400).json({
+          success: false,
+          error: 'txid can not be empty'
+        })
+      }
+
+      if (txid.length !== 64) {
+        return res.status(400).json({
+          success: false,
+          error: 'This is not a txid'
+        })
+      }
+
+      const result = await this.slpUseCases.getTxid({ txid })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/slp/token Get token statistics
+   * @apiName GetTokenStats
+   * @apiGroup SLP
+   * @apiDescription Returns statistics for a single SLP token.
+   */
+  async getTokenStats (req, res) {
+    try {
+      const tokenId = req.body.tokenId
+
+      if (!tokenId || tokenId === '') {
+        return res.status(400).json({
+          success: false,
+          error: 'tokenId can not be empty'
+        })
+      }
+
+      // Flag to toggle tx history of the token
+      const withTxHistory = req.body.withTxHistory === true
+
+      const result = await this.slpUseCases.getTokenStats({ tokenId, withTxHistory })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /v6/slp/token/data Get token data
+   * @apiName GetTokenData
+   * @apiGroup SLP
+   * @apiDescription Get mutable and immutable data if the token contains them.
+   */
+  async getTokenData (req, res) {
+    try {
+      const tokenId = req.body.tokenId
+
+      if (!tokenId || tokenId === '') {
+        return res.status(400).json({
+          success: false,
+          error: 'tokenId can not be empty'
+        })
+      }
+
+      // Flag to toggle tx history of the token
+      const withTxHistory = req.body.withTxHistory === true
+
+      const result = await this.slpUseCases.getTokenData({ tokenId, withTxHistory })
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in SlpRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ error: message })
+  }
+}
+
+export default SlpRESTController

src/controllers/rest-api/slp/router.js

@@ -0,0 +1,55 @@
+/*
+  REST API router for /slp routes.
+*/
+
+import express from 'express'
+import SlpRESTController from './controller.js'
+
+class SlpRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating SLP REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating SLP REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.slpController = new SlpRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/slp`
+    if (!this.baseUrl.startsWith('/')) {
+      this.baseUrl = `/${this.baseUrl}`
+    }
+    this.router = express.Router()
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error('Must pass app object when attaching REST API controllers.')
+    }
+
+    this.router.get('/', this.slpController.root)
+    this.router.get('/status', this.slpController.getStatus)
+    this.router.post('/address', this.slpController.getAddress)
+    this.router.post('/txid', this.slpController.getTxid)
+    this.router.post('/token', this.slpController.getTokenStats)
+    this.router.post('/token/data', this.slpController.getTokenData)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default SlpRouter

src/controllers/timer-controller.js

@@ -23,7 +23,7 @@ class TimerController {
     }
 
     // Constants
-    this.SHUTDOWN_INTERVAL_MS = 10 * 60 * 1000 // 10 minutes in milliseconds
+    this.SHUTDOWN_INTERVAL_MS = 10 * 60 * 60 * 1000 // 10 hours in milliseconds
     this.LIVENESS_CHECK_INTERVAL_MS = 1 * 60 * 1000 // 1 minute in milliseconds
 
     // Handlers

src/entities/event.js

@@ -1,71 +0,0 @@
-/*
-  Event entity - represents a Nostr event.
-  This is a domain model following Clean Architecture principles.
-*/
-
-class Event {
-  constructor (data) {
-    this.id = data.id
-    this.pubkey = data.pubkey
-    this.created_at = data.created_at
-    this.kind = data.kind
-    this.tags = data.tags || []
-    this.content = data.content
-    this.sig = data.sig
-  }
-
-  /**
-   * Validates the event structure
-   * @returns {boolean} True if valid
-   */
-  isValid () {
-    if (!this.id || !this.pubkey || !this.created_at || this.kind === undefined || !this.sig) {
-      return false
-    }
-
-    // Basic type checks
-    if (typeof this.id !== 'string' || this.id.length !== 64) {
-      return false
-    }
-
-    if (typeof this.pubkey !== 'string' || this.pubkey.length !== 64) {
-      return false
-    }
-
-    if (typeof this.created_at !== 'number') {
-      return false
-    }
-
-    if (typeof this.kind !== 'number' || this.kind < 0 || this.kind > 65535) {
-      return false
-    }
-
-    if (typeof this.sig !== 'string' || this.sig.length !== 128) {
-      return false
-    }
-
-    if (!Array.isArray(this.tags)) {
-      return false
-    }
-
-    return true
-  }
-
-  /**
-   * Convert to plain object
-   * @returns {Object} Plain event object
-   */
-  toJSON () {
-    return {
-      id: this.id,
-      pubkey: this.pubkey,
-      created_at: this.created_at,
-      kind: this.kind,
-      tags: this.tags,
-      content: this.content,
-      sig: this.sig
-    }
-  }
-}
-
-export default Event

src/middleware/basic-auth.js

@@ -0,0 +1,61 @@
+/*
+  Basic Authentication Middleware
+
+  This middleware validates Bearer tokens from the Authorization header.
+  When a valid token is provided, it sets req.locals.basicAuthValid = true
+  to allow bypassing x402 middleware.
+*/
+
+import config from '../config/index.js'
+import wlogger from '../adapters/wlogger.js'
+
+/**
+ * Middleware function that validates Bearer token authentication
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ */
+export function basicAuthMiddleware (req, res, next) {
+  // Initialize req.locals if it doesn't exist
+  if (!req.locals) {
+    req.locals = {}
+  }
+
+  // Default to false
+  req.locals.basicAuthValid = false
+
+  // Get the configured token
+  const configuredToken = config.basicAuth?.token
+
+  // If no token is configured, skip validation
+  if (!configuredToken) {
+    wlogger.warn('Basic auth enabled but no BASIC_AUTH_TOKEN configured')
+    return next()
+  }
+
+  // Get the Authorization header
+  const authHeader = req.headers.authorization
+
+  // If no Authorization header, continue (x402 will handle unauthorized requests)
+  if (!authHeader) {
+    return next()
+  }
+
+  // Check if it's a Bearer token
+  const parts = authHeader.split(' ')
+  if (parts.length !== 2 || parts[0] !== 'Bearer') {
+    return next()
+  }
+
+  const providedToken = parts[1]
+
+  // Compare tokens
+  if (providedToken === configuredToken) {
+    req.locals.basicAuthValid = true
+    wlogger.verbose(`Basic auth validated for request to ${req.path}`)
+  }
+
+  // Always continue to next middleware
+  // If auth failed, x402 middleware will handle the request
+  next()
+}

src/use-cases/fulcrum-use-cases.js

@@ -0,0 +1,155 @@
+/*
+  Use cases for interacting with the Fulcrum API service.
+*/
+
+import wlogger from '../adapters/wlogger.js'
+import BCHJS from '@psf/bch-js'
+
+const bchjs = new BCHJS()
+
+class FulcrumUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating Fulcrum use cases.')
+    }
+
+    this.fulcrum = this.adapters.fulcrum
+    if (!this.fulcrum) {
+      throw new Error('Fulcrum adapter required when instantiating Fulcrum use cases.')
+    }
+
+    // Allow bchjs to be injected for testing
+    this.bchjs = localConfig.bchjs || bchjs
+  }
+
+  async getBalance ({ address }) {
+    return this.fulcrum.get(`electrumx/balance/${address}`)
+  }
+
+  async getBalances ({ addresses }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/balance/', { addresses })
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getBalances()', err)
+      throw err
+    }
+  }
+
+  async getUtxos ({ address }) {
+    return this.fulcrum.get(`electrumx/utxos/${address}`)
+  }
+
+  async getUtxosBulk ({ addresses }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/utxos/', { addresses })
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getUtxosBulk()', err)
+      throw err
+    }
+  }
+
+  async getTransactionDetails ({ txid }) {
+    return this.fulcrum.get(`electrumx/tx/data/${txid}`)
+  }
+
+  async getTransactionDetailsBulk ({ txids, verbose }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/tx/data', { txids, verbose })
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getTransactionDetailsBulk()', err)
+      throw err
+    }
+  }
+
+  async broadcastTransaction ({ txHex }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/tx/broadcast', { txHex })
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.broadcastTransaction()', err)
+      throw err
+    }
+  }
+
+  async getBlockHeaders ({ height, count }) {
+    return this.fulcrum.get(`electrumx/block/headers/${height}?count=${count}`)
+  }
+
+  async getBlockHeadersBulk ({ heights }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/block/headers', { heights })
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getBlockHeadersBulk()', err)
+      throw err
+    }
+  }
+
+  async getTransactions ({ address, allTxs }) {
+    try {
+      const response = await this.fulcrum.get(`electrumx/transactions/${address}`)
+
+      // Sort transactions in descending order, so that newest transactions are first.
+      if (response.transactions && Array.isArray(response.transactions)) {
+        response.transactions = await this.bchjs.Electrumx.sortAllTxs(response.transactions, 'DESCENDING')
+
+        if (!allTxs) {
+          // Return only the first 100 transactions of the history.
+          response.transactions = response.transactions.slice(0, 100)
+        }
+      }
+
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getTransactions()', err)
+      throw err
+    }
+  }
+
+  async getTransactionsBulk ({ addresses, allTxs }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/transactions/', { addresses })
+
+      // Sort transactions in descending order for each address entry.
+      if (response.transactions && Array.isArray(response.transactions)) {
+        for (let i = 0; i < response.transactions.length; i++) {
+          const thisEntry = response.transactions[i]
+          if (thisEntry.transactions && Array.isArray(thisEntry.transactions)) {
+            thisEntry.transactions = await this.bchjs.Electrumx.sortAllTxs(thisEntry.transactions, 'DESCENDING')
+
+            if (!allTxs && thisEntry.transactions.length > 100) {
+              // Extract only the first 100 transactions.
+              thisEntry.transactions = thisEntry.transactions.slice(0, 100)
+            }
+          }
+        }
+      }
+
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getTransactionsBulk()', err)
+      throw err
+    }
+  }
+
+  async getMempool ({ address }) {
+    return this.fulcrum.get(`electrumx/unconfirmed/${address}`)
+  }
+
+  async getMempoolBulk ({ addresses }) {
+    try {
+      const response = await this.fulcrum.post('electrumx/unconfirmed/', { addresses })
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getMempoolBulk()', err)
+      throw err
+    }
+  }
+}
+
+export default FulcrumUseCases

src/use-cases/full-node-blockchain-use-cases.js

@@ -0,0 +1,134 @@
+/*
+  Use cases for interacting with the BCH full node blockchain RPC interface.
+*/
+
+import wlogger from '../adapters/wlogger.js'
+
+class BlockchainUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating Blockchain use cases.')
+    }
+
+    this.fullNode = this.adapters.fullNode
+    if (!this.fullNode) {
+      throw new Error('Full node adapter required when instantiating Blockchain use cases.')
+    }
+  }
+
+  async getBestBlockHash () {
+    return this.fullNode.call('getbestblockhash')
+  }
+
+  async getBlockchainInfo () {
+    return this.fullNode.call('getblockchaininfo')
+  }
+
+  async getBlockCount () {
+    return this.fullNode.call('getblockcount')
+  }
+
+  async getBlockHeader ({ hash, verbose = false }) {
+    return this.fullNode.call('getblockheader', [hash, verbose])
+  }
+
+  async getBlockHeaders ({ hashes, verbose = false }) {
+    try {
+      const promises = hashes.map(hash =>
+        this.fullNode.call('getblockheader', [hash, verbose], `getblockheader-${hash}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in BlockchainUseCases.getBlockHeaders()', err)
+      throw err
+    }
+  }
+
+  async getChainTips () {
+    return this.fullNode.call('getchaintips')
+  }
+
+  async getDifficulty () {
+    return this.fullNode.call('getdifficulty')
+  }
+
+  async getMempoolEntry ({ txid }) {
+    return this.fullNode.call('getmempoolentry', [txid])
+  }
+
+  async getMempoolEntries ({ txids }) {
+    try {
+      const promises = txids.map(txid =>
+        this.fullNode.call('getmempoolentry', [txid], `getmempoolentry-${txid}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in BlockchainUseCases.getMempoolEntries()', err)
+      throw err
+    }
+  }
+
+  async getMempoolAncestors ({ txid, verbose = false }) {
+    return this.fullNode.call('getmempoolancestors', [txid, verbose])
+  }
+
+  async getMempoolInfo () {
+    return this.fullNode.call('getmempoolinfo')
+  }
+
+  async getRawMempool ({ verbose = false }) {
+    return this.fullNode.call('getrawmempool', [verbose])
+  }
+
+  async getTxOut ({ txid, n, includeMempool }) {
+    return this.fullNode.call('gettxout', [txid, n, includeMempool])
+  }
+
+  async getTxOutProof ({ txid }) {
+    return this.fullNode.call('gettxoutproof', [[txid]])
+  }
+
+  async getTxOutProofs ({ txids }) {
+    try {
+      const promises = txids.map(txid =>
+        this.fullNode.call('gettxoutproof', [[txid]], `gettxoutproof-${txid}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in BlockchainUseCases.getTxOutProofs()', err)
+      throw err
+    }
+  }
+
+  async verifyTxOutProof ({ proof }) {
+    return this.fullNode.call('verifytxoutproof', [proof])
+  }
+
+  async verifyTxOutProofs ({ proofs }) {
+    try {
+      const promises = proofs.map(proof =>
+        this.fullNode.call('verifytxoutproof', [proof], `verifytxoutproof-${proof.slice(0, 16)}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in BlockchainUseCases.verifyTxOutProofs()', err)
+      throw err
+    }
+  }
+
+  async getBlock ({ blockhash, verbosity }) {
+    return this.fullNode.call('getblock', [blockhash, verbosity])
+  }
+
+  async getBlockHash ({ height }) {
+    return this.fullNode.call('getblockhash', [height])
+  }
+}
+
+export default BlockchainUseCases

src/use-cases/full-node-control-use-cases.js

@@ -0,0 +1,24 @@
+/*
+  Use cases for interacting with the BCH full node control RPC interface.
+*/
+
+class ControlUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating Control use cases.')
+    }
+
+    this.fullNode = this.adapters.fullNode
+    if (!this.fullNode) {
+      throw new Error('Full node adapter required when instantiating Control use cases.')
+    }
+  }
+
+  async getNetworkInfo () {
+    return this.fullNode.call('getnetworkinfo')
+  }
+}
+
+export default ControlUseCases

src/use-cases/full-node-dsproof-use-cases.js

@@ -0,0 +1,24 @@
+/*
+  Use cases for interacting with the BCH full node double-spend proof RPC interface.
+*/
+
+class DSProofUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating DSProof use cases.')
+    }
+
+    this.fullNode = this.adapters.fullNode
+    if (!this.fullNode) {
+      throw new Error('Full node adapter required when instantiating DSProof use cases.')
+    }
+  }
+
+  async getDSProof ({ txid, verbose }) {
+    return this.fullNode.call('getdsproof', [txid, verbose])
+  }
+}
+
+export default DSProofUseCases

src/use-cases/full-node-mining-use-cases.js

@@ -0,0 +1,28 @@
+/*
+  Use cases for interacting with the BCH full node mining RPC interface.
+*/
+
+class MiningUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating Mining use cases.')
+    }
+
+    this.fullNode = this.adapters.fullNode
+    if (!this.fullNode) {
+      throw new Error('Full node adapter required when instantiating Mining use cases.')
+    }
+  }
+
+  async getMiningInfo () {
+    return this.fullNode.call('getmininginfo')
+  }
+
+  async getNetworkHashPS ({ nblocks, height }) {
+    return this.fullNode.call('getnetworkhashps', [nblocks, height])
+  }
+}
+
+export default MiningUseCases

src/use-cases/full-node-rawtransactions-use-cases.js

@@ -0,0 +1,121 @@
+/*
+  Use cases for interacting with the BCH full node raw transactions RPC interface.
+*/
+
+import wlogger from '../adapters/wlogger.js'
+
+class RawTransactionsUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating RawTransactions use cases.')
+    }
+
+    this.fullNode = this.adapters.fullNode
+    if (!this.fullNode) {
+      throw new Error('Full node adapter required when instantiating RawTransactions use cases.')
+    }
+  }
+
+  async decodeRawTransaction ({ hex }) {
+    return this.fullNode.call('decoderawtransaction', [hex])
+  }
+
+  async decodeRawTransactions ({ hexes }) {
+    try {
+      const promises = hexes.map(hex =>
+        this.fullNode.call('decoderawtransaction', [hex], `decoderawtransaction-${hex.slice(0, 16)}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in RawTransactionsUseCases.decodeRawTransactions()', err)
+      throw err
+    }
+  }
+
+  async decodeScript ({ hex }) {
+    return this.fullNode.call('decodescript', [hex])
+  }
+
+  async decodeScripts ({ hexes }) {
+    try {
+      const promises = hexes.map(hex =>
+        this.fullNode.call('decodescript', [hex], `decodescript-${hex.slice(0, 16)}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in RawTransactionsUseCases.decodeScripts()', err)
+      throw err
+    }
+  }
+
+  async getRawTransaction ({ txid, verbose = false }) {
+    const verboseInt = verbose ? 1 : 0
+    return this.fullNode.call('getrawtransaction', [txid, verboseInt])
+  }
+
+  async getRawTransactions ({ txids, verbose = false }) {
+    try {
+      const verboseInt = verbose ? 1 : 0
+      const promises = txids.map(txid =>
+        this.fullNode.call('getrawtransaction', [txid, verboseInt], `getrawtransaction-${txid}`)
+      )
+
+      return await Promise.all(promises)
+    } catch (err) {
+      wlogger.error('Error in RawTransactionsUseCases.getRawTransactions()', err)
+      throw err
+    }
+  }
+
+  async getRawTransactionWithHeight ({ txid, verbose = false }) {
+    const verboseInt = verbose ? 1 : 0
+    const data = await this.fullNode.call('getrawtransaction', [txid, verboseInt])
+
+    if (verbose && data && data.blockhash) {
+      data.height = null
+      try {
+        // Look up the block height and append it to the TX response.
+        const blockHeader = await this.fullNode.call('getblockheader', [data.blockhash, true])
+        data.height = blockHeader.height
+      } catch (err) {
+        // Exit quietly if block header lookup fails
+        wlogger.debug('Could not fetch block header for height lookup', err)
+      }
+    }
+
+    return data
+  }
+
+  async getBlockHeader ({ blockHash, verbose = false }) {
+    return this.fullNode.call('getblockheader', [blockHash, verbose])
+  }
+
+  async sendRawTransaction ({ hex }) {
+    return this.fullNode.call('sendrawtransaction', [hex])
+  }
+
+  async sendRawTransactions ({ hexes }) {
+    // Dev Note: Sending the 'sendrawtransaction' RPC call to a full node in parallel will
+    // not work. Testing showed that the full node will return the same TXID for
+    // different TX hexes. I believe this is by design, to prevent double spends.
+    // In parallel, we are essentially asking the node to broadcast a new TX before
+    // it's finished broadcasting the previous one. Serial execution is required.
+    try {
+      const result = []
+      for (const hex of hexes) {
+        const txid = await this.fullNode.call('sendrawtransaction', [hex], `sendrawtransaction-${hex.slice(0, 16)}`)
+        result.push(txid)
+      }
+      return result
+    } catch (err) {
+      wlogger.error('Error in RawTransactionsUseCases.sendRawTransactions()', err)
+      throw err
+    }
+  }
+}
+
+export default RawTransactionsUseCases

src/use-cases/index.js

@@ -5,9 +5,14 @@
 */
 
 // Local libraries
-// import PublishEventUseCase from './publish-event.js'
-// import QueryEventsUseCase from './query-events.js'
-// import ManageSubscriptionUseCase from './manage-subscription.js'
+import BlockchainUseCases from './full-node-blockchain-use-cases.js'
+import ControlUseCases from './full-node-control-use-cases.js'
+import DSProofUseCases from './full-node-dsproof-use-cases.js'
+import FulcrumUseCases from './fulcrum-use-cases.js'
+import MiningUseCases from './full-node-mining-use-cases.js'
+import PriceUseCases from './price-use-cases.js'
+import RawTransactionsUseCases from './full-node-rawtransactions-use-cases.js'
+import SlpUseCases from './slp-use-cases.js'
 
 class UseCases {
   constructor (localConfig = {}) {
@@ -18,9 +23,14 @@ class UseCases {
       )
     }
 
-    // this.publishEvent = new PublishEventUseCase({ adapters: this.adapters })
-    // this.queryEvents = new QueryEventsUseCase({ adapters: this.adapters })
-    // this.manageSubscription = new ManageSubscriptionUseCase({ adapters: this.adapters })
+    this.blockchain = new BlockchainUseCases({ adapters: this.adapters })
+    this.control = new ControlUseCases({ adapters: this.adapters })
+    this.dsproof = new DSProofUseCases({ adapters: this.adapters })
+    this.fulcrum = new FulcrumUseCases({ adapters: this.adapters })
+    this.mining = new MiningUseCases({ adapters: this.adapters })
+    this.price = new PriceUseCases({ adapters: this.adapters })
+    this.rawtransactions = new RawTransactionsUseCases({ adapters: this.adapters })
+    this.slp = new SlpUseCases({ adapters: this.adapters })
   }
 
   // Run any startup Use Cases at the start of the app.

src/use-cases/manage-subscription.js

@@ -1,216 +0,0 @@
-/*
-  Use case: Manage subscriptions for Server-Sent Events (SSE).
-  This encapsulates the business logic for creating and managing subscriptions.
-*/
-
-import wlogger from '../adapters/wlogger.js'
-
-class ManageSubscriptionUseCase {
-  constructor (localConfig = {}) {
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error('Adapters instance required')
-    }
-    if (!this.adapters.nostrRelays || !Array.isArray(this.adapters.nostrRelays) || this.adapters.nostrRelays.length === 0) {
-      throw new Error('NostrRelay adapters array required')
-    }
-    // Map subscriptionId to { relaySubscriptions: Map<relayIndex, subscriptionId>, handlers, seenEventIds }
-    this.activeSubscriptions = new Map()
-  }
-
-  /**
-   * Create a subscription for SSE streaming across all relays
-   * @param {string} subscriptionId - Unique subscription ID
-   * @param {Array} filters - Array of filter objects
-   * @param {Function} onEvent - Callback for events
-   * @param {Function} onEose - Callback for EOSE
-   * @param {Function} onClosed - Callback for CLOSED
-   * @returns {Promise<void>}
-   */
-  async createSubscription (subscriptionId, filters, onEvent, onEose, onClosed) {
-    try {
-      if (this.activeSubscriptions.has(subscriptionId)) {
-        throw new Error(`Subscription ${subscriptionId} already exists`)
-      }
-
-      wlogger.info(`Creating subscription ${subscriptionId} across ${this.adapters.nostrRelays.length} relay(s)`)
-
-      // Track seen event IDs to de-duplicate across relays
-      const seenEventIds = new Set()
-
-      // Track EOSE and CLOSED status per relay
-      const relayStatuses = this.adapters.nostrRelays.map(() => ({
-        eoseReceived: false,
-        closedReceived: false
-      }))
-
-      // Create unified handlers that merge events from all relays
-      const handlers = {
-        onEvent: (event) => {
-          // De-duplicate events by ID across all relays
-          if (event && event.id && !seenEventIds.has(event.id)) {
-            seenEventIds.add(event.id)
-            if (onEvent) {
-              onEvent(event)
-            }
-          }
-        },
-        onEose: () => {
-          // Call onEose only once when all relays have sent EOSE
-          // This is called from the per-relay handler only when all relays have EOSE
-          if (onEose) {
-            onEose()
-          }
-        },
-        onClosed: (message) => {
-          if (onClosed) {
-            onClosed(message)
-          }
-          // Clean up subscription if any relay closes it
-          const subscriptionInfo = this.activeSubscriptions.get(subscriptionId)
-          if (subscriptionInfo && subscriptionInfo.eoseTimeoutId) {
-            clearTimeout(subscriptionInfo.eoseTimeoutId)
-          }
-          this.activeSubscriptions.delete(subscriptionId)
-        }
-      }
-
-      // Create subscription per relay with unique subscription IDs
-      const relaySubscriptions = new Map()
-      const subscriptionPromises = this.adapters.nostrRelays.map(async (relay, index) => {
-        const relaySubscriptionId = `${subscriptionId}-relay-${index}`
-        relaySubscriptions.set(index, relaySubscriptionId)
-
-        // Create per-relay handlers that update shared state
-        const relayHandlers = {
-          onEvent: (event) => {
-            handlers.onEvent(event)
-          },
-          onEose: () => {
-            relayStatuses[index].eoseReceived = true
-            // Check if all relays have sent EOSE
-            if (relayStatuses.every(s => s.eoseReceived)) {
-              // Clear the timeout since we got EOSE from all relays
-              const subscriptionInfo = this.activeSubscriptions.get(subscriptionId)
-              if (subscriptionInfo && subscriptionInfo.eoseTimeoutId) {
-                clearTimeout(subscriptionInfo.eoseTimeoutId)
-                subscriptionInfo.eoseTimeoutId = null
-              }
-              handlers.onEose()
-            }
-          },
-          onClosed: (message) => {
-            relayStatuses[index].closedReceived = true
-            handlers.onClosed(message)
-          }
-        }
-
-        await relay.sendReq(relaySubscriptionId, filters, relayHandlers)
-      })
-
-      // Store subscription info
-      this.activeSubscriptions.set(subscriptionId, {
-        relaySubscriptions,
-        handlers,
-        seenEventIds,
-        relayStatuses,
-        eoseTimeoutId: null
-      })
-
-      // Subscribe to all relays concurrently
-      const results = await Promise.allSettled(subscriptionPromises)
-
-      // Check if any relay subscription failed and clean up if so
-      const hasFailures = results.some(result => result.status === 'rejected')
-      if (hasFailures) {
-        const subscriptionInfo = this.activeSubscriptions.get(subscriptionId)
-        if (subscriptionInfo && subscriptionInfo.eoseTimeoutId) {
-          clearTimeout(subscriptionInfo.eoseTimeoutId)
-        }
-        this.activeSubscriptions.delete(subscriptionId)
-        const errors = results
-          .filter(result => result.status === 'rejected')
-          .map(result => result.reason)
-        throw new Error(`Failed to create subscription on some relays: ${errors.map(e => e.message).join(', ')}`)
-      }
-
-      // Set up EOSE timeout fallback - if not all relays send EOSE within 10 seconds, call onEose anyway
-      const subscriptionInfo = this.activeSubscriptions.get(subscriptionId)
-      const EOSE_TIMEOUT_MS = 10000 // 10 seconds
-      subscriptionInfo.eoseTimeoutId = setTimeout(() => {
-        // Check if subscription still exists and if all relays have sent EOSE
-        if (this.activeSubscriptions.has(subscriptionId)) {
-          const currentInfo = this.activeSubscriptions.get(subscriptionId)
-          const allEoseReceived = currentInfo.relayStatuses.every(s => s.eoseReceived)
-          if (!allEoseReceived) {
-            wlogger.warn(`EOSE timeout reached for subscription ${subscriptionId} - calling onEose callback anyway`)
-            if (handlers.onEose) {
-              handlers.onEose()
-            }
-          }
-        }
-      }, EOSE_TIMEOUT_MS)
-    } catch (err) {
-      wlogger.error('Error creating subscription:', err)
-      const subscriptionInfo = this.activeSubscriptions.get(subscriptionId)
-      if (subscriptionInfo && subscriptionInfo.eoseTimeoutId) {
-        clearTimeout(subscriptionInfo.eoseTimeoutId)
-      }
-      this.activeSubscriptions.delete(subscriptionId)
-      throw err
-    }
-  }
-
-  /**
-   * Close a subscription across all relays
-   * @param {string} subscriptionId - Subscription ID to close
-   * @returns {Promise<void>}
-   */
-  async closeSubscription (subscriptionId) {
-    try {
-      if (!this.activeSubscriptions.has(subscriptionId)) {
-        // Subscription doesn't exist - already closed, treat as success (idempotent)
-        wlogger.info(`Subscription ${subscriptionId} already closed or does not exist`)
-        return
-      }
-
-      wlogger.info(`Closing subscription ${subscriptionId} across all relays`)
-
-      const subscriptionInfo = this.activeSubscriptions.get(subscriptionId)
-      const { relaySubscriptions } = subscriptionInfo
-
-      // Clear EOSE timeout if it exists
-      if (subscriptionInfo.eoseTimeoutId) {
-        clearTimeout(subscriptionInfo.eoseTimeoutId)
-      }
-
-      // Close subscriptions on all relays concurrently
-      const closePromises = Array.from(relaySubscriptions.entries()).map(async ([relayIndex, relaySubscriptionId]) => {
-        try {
-          await this.adapters.nostrRelays[relayIndex].sendClose(relaySubscriptionId)
-        } catch (err) {
-          wlogger.warn(`Error closing subscription on relay ${relayIndex}:`, err.message)
-        }
-      })
-
-      await Promise.allSettled(closePromises)
-      this.activeSubscriptions.delete(subscriptionId)
-    } catch (err) {
-      wlogger.error('Error closing subscription:', err)
-      // Clean up even if there's an error
-      this.activeSubscriptions.delete(subscriptionId)
-      throw err
-    }
-  }
-
-  /**
-   * Check if a subscription exists
-   * @param {string} subscriptionId - Subscription ID
-   * @returns {boolean}
-   */
-  hasSubscription (subscriptionId) {
-    return this.activeSubscriptions.has(subscriptionId)
-  }
-}
-
-export default ManageSubscriptionUseCase

src/use-cases/price-use-cases.js

@@ -0,0 +1,83 @@
+/*
+  Use cases for price-related operations.
+*/
+
+// Global npm libraries
+import axios from 'axios'
+import SlpWallet from 'minimal-slp-wallet'
+import PSFFPP from 'psffpp'
+
+// Local libraries
+import wlogger from '../adapters/wlogger.js'
+import config from '../config/index.js'
+
+class PriceUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating Price use cases.')
+    }
+
+    // Get config
+    this.config = localConfig.config || config
+
+    // Coinex API URL for BCH/USDT
+    this.bchCoinexPriceUrl =
+      'https://api.coinex.com/v1/market/ticker?market=bchusdt'
+
+    // Allow axios to be injected for testing
+    this.axios = localConfig.axios || axios
+  }
+
+  /**
+   * Get the USD price of BCH from Coinex.
+   * @returns {Promise<number>} The USD price of BCH
+   */
+  async getBCHUSD () {
+    try {
+      // Request options
+      const opt = {
+        method: 'get',
+        baseURL: this.bchCoinexPriceUrl,
+        timeout: 15000
+      }
+
+      const response = await this.axios.request(opt)
+
+      const price = Number(response.data.data.ticker.last)
+
+      return price
+    } catch (err) {
+      wlogger.error('Error in PriceUseCases.getBCHUSD()', err)
+      throw err
+    }
+  }
+
+  /**
+   * Get the PSF price for writing to the PSFFPP.
+   * Returns the price to pin 1MB of content to the PSFFPP pinning
+   * network on IPFS. The price is denominated in PSF tokens.
+   * @returns {Promise<number>} The write price in PSF tokens
+   */
+  async getPsffppWritePrice () {
+    try {
+      const wallet = new SlpWallet(undefined, {
+        interface: 'rest-api',
+        restURL: this.config.restURL
+      })
+      await wallet.walletInfoPromise
+
+      const psffpp = new PSFFPP({ wallet })
+
+      const writePrice = await psffpp.getMcWritePrice()
+
+      return writePrice
+    } catch (err) {
+      wlogger.error('Error in PriceUseCases.getPsffppWritePrice()', err)
+      throw err
+    }
+  }
+}
+
+export default PriceUseCases

src/use-cases/publish-event.js

@@ -1,87 +0,0 @@
-/*
-  Use case: Publish a Nostr event to the relay.
-  This encapsulates the business logic for publishing events.
-*/
-
-import Event from '../entities/event.js'
-import wlogger from '../adapters/wlogger.js'
-
-class PublishEventUseCase {
-  constructor (localConfig = {}) {
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error('Adapters instance required')
-    }
-    if (!this.adapters.nostrRelays || !Array.isArray(this.adapters.nostrRelays) || this.adapters.nostrRelays.length === 0) {
-      throw new Error('NostrRelay adapters array required')
-    }
-  }
-
-  /**
-   * Publish an event to all Nostr relays (broadcast)
-   * @param {Object} eventData - Event data (must be signed)
-   * @returns {Promise<Object>} Result with accepted status, message, and relay results
-   */
-  async execute (eventData) {
-    try {
-      // Create event entity
-      const event = new Event(eventData)
-
-      // Validate event
-      if (!event.isValid()) {
-        throw new Error('Invalid event structure')
-      }
-
-      wlogger.info(`Publishing event ${event.id} (kind ${event.kind}) to ${this.adapters.nostrRelays.length} relay(s)`)
-
-      // Broadcast event to all relays
-      const results = await this.adapters.broadcastEvent(event.toJSON())
-
-      // Aggregate results
-      const acceptedRelays = results.filter(r => r.accepted)
-      const rejectedRelays = results.filter(r => !r.accepted)
-      const failedRelays = results.filter(r => !r.success)
-
-      const atLeastOneAccepted = acceptedRelays.length > 0
-      const allAccepted = acceptedRelays.length === results.length && failedRelays.length === 0
-
-      // Build aggregated message
-      let message = ''
-      if (allAccepted) {
-        message = `Accepted by all ${acceptedRelays.length} relay(s)`
-      } else if (atLeastOneAccepted) {
-        message = `Accepted by ${acceptedRelays.length}/${results.length} relay(s)`
-        if (rejectedRelays.length > 0) {
-          message += `, rejected by ${rejectedRelays.length} relay(s)`
-        }
-        if (failedRelays.length > 0) {
-          message += `, failed to reach ${failedRelays.length} relay(s)`
-        }
-      } else {
-        message = `Rejected or failed by all ${results.length} relay(s)`
-        if (rejectedRelays.length > 0) {
-          const rejectionMessages = rejectedRelays.map(r => r.message).filter(m => m).join('; ')
-          if (rejectionMessages) {
-            message += `: ${rejectionMessages}`
-          }
-        }
-      }
-
-      wlogger.info(`Event ${event.id} ${atLeastOneAccepted ? 'accepted' : 'rejected/failed'}: ${message}`)
-
-      return {
-        accepted: atLeastOneAccepted,
-        message,
-        eventId: event.id,
-        relayResults: results,
-        acceptedCount: acceptedRelays.length,
-        totalRelays: results.length
-      }
-    } catch (err) {
-      wlogger.error('Error in PublishEventUseCase:', err)
-      throw err
-    }
-  }
-}
-
-export default PublishEventUseCase

src/use-cases/query-events.js

@@ -1,41 +0,0 @@
-/*
-  Use case: Query events from the relay (stateless).
-  This encapsulates the business logic for querying events.
-*/
-
-import wlogger from '../adapters/wlogger.js'
-
-class QueryEventsUseCase {
-  constructor (localConfig = {}) {
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error('Adapters instance required')
-    }
-    if (!this.adapters.nostrRelays || !Array.isArray(this.adapters.nostrRelays) || this.adapters.nostrRelays.length === 0) {
-      throw new Error('NostrRelay adapters array required')
-    }
-  }
-
-  /**
-   * Query events with filters from all relays (stateless - returns immediately)
-   * @param {Array} filters - Array of filter objects
-   * @param {string} subscriptionId - Unique subscription ID
-   * @returns {Promise<Array>} Array of events (merged and de-duplicated from all relays)
-   */
-  async execute (filters, subscriptionId) {
-    try {
-      wlogger.info(`Querying events with subscription ${subscriptionId} from ${this.adapters.nostrRelays.length} relay(s)`)
-
-      // Query all relays concurrently and merge results
-      const events = await this.adapters.queryAllRelays(filters, subscriptionId)
-
-      wlogger.info(`Query returned ${events.length} events from ${this.adapters.nostrRelays.length} relay(s)`)
-      return events
-    } catch (err) {
-      wlogger.error('Error in QueryEventsUseCase:', err)
-      throw err
-    }
-  }
-}
-
-export default QueryEventsUseCase

src/use-cases/slp-use-cases.js

@@ -0,0 +1,321 @@
+/*
+  Use cases for interacting with the SLP Indexer API service.
+*/
+
+import wlogger from '../adapters/wlogger.js'
+import BCHJS from '@psf/bch-js'
+import SlpWallet from 'minimal-slp-wallet'
+import SlpTokenMedia from 'slp-token-media'
+import axios from 'axios'
+import config from '../config/index.js'
+
+const bchjs = new BCHJS()
+
+class SlpUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating SLP use cases.')
+    }
+
+    this.slpIndexer = this.adapters.slpIndexer
+    if (!this.slpIndexer) {
+      throw new Error('SLP Indexer adapter required when instantiating SLP use cases.')
+    }
+
+    // Allow bchjs to be injected for testing
+    this.bchjs = localConfig.bchjs || bchjs
+
+    // Get config
+    this.config = localConfig.config || config
+
+    // Initialize wallet (lazy initialization)
+    this.wallet = null
+    this.slpTokenMedia = null
+    this.walletInitialized = false
+    this.initializationPromise = null
+  }
+
+  // Initialize wallet and SlpTokenMedia asynchronously
+  async _ensureInitialized () {
+    if (this.walletInitialized) {
+      return
+    }
+
+    if (this.initializationPromise) {
+      return this.initializationPromise
+    }
+
+    this.initializationPromise = this._initialize()
+    return this.initializationPromise
+  }
+
+  async _initialize () {
+    try {
+      // Initialize wallet
+      this.wallet = new SlpWallet(undefined, {
+        restURL: this.config.restURL,
+        interface: 'rest-api'
+      })
+
+      // Wait for wallet to initialize
+      await this.wallet.walletInfoPromise
+
+      // Initialize SlpTokenMedia
+      this.slpTokenMedia = new SlpTokenMedia({
+        wallet: this.wallet,
+        ipfsGatewayUrl: this.config.ipfsGateway
+      })
+
+      this.walletInitialized = true
+      wlogger.info('SLP wallet and token media initialized')
+    } catch (err) {
+      wlogger.error('Error initializing SLP wallet:', err)
+      throw err
+    }
+  }
+
+  async getStatus () {
+    try {
+      return await this.slpIndexer.get('slp/status/')
+    } catch (err) {
+      wlogger.error('Error in SlpUseCases.getStatus()', err)
+      throw err
+    }
+  }
+
+  async getAddress ({ address }) {
+    try {
+      return await this.slpIndexer.post('slp/address/', { address })
+    } catch (err) {
+      wlogger.error('Error in SlpUseCases.getAddress()', err)
+      throw err
+    }
+  }
+
+  async getTxid ({ txid }) {
+    try {
+      return await this.slpIndexer.post('slp/tx/', { txid })
+    } catch (err) {
+      wlogger.error('Error in SlpUseCases.getTxid()', err)
+      throw err
+    }
+  }
+
+  async getTokenStats ({ tokenId, withTxHistory = false }) {
+    try {
+      return await this.slpIndexer.post('slp/token/', { tokenId, withTxHistory })
+    } catch (err) {
+      wlogger.error('Error in SlpUseCases.getTokenStats()', err)
+      throw err
+    }
+  }
+
+  async getTokenData ({ tokenId, withTxHistory = false }) {
+    try {
+      const tokenData = {}
+
+      // Get token stats from the Genesis TX of the token
+      const response = await this.slpIndexer.post('slp/token/', { tokenId, withTxHistory })
+      const tokenStats = response.tokenData
+
+      tokenData.genesisData = tokenStats
+
+      // Try to get immutable data
+      try {
+        const immutableData = tokenStats.documentUri
+        tokenData.immutableData = immutableData || ''
+      } catch (error) {
+        tokenData.immutableData = ''
+      }
+
+      // Try to get mutable data
+      try {
+        const mutableData = await this.getMutableCid({ tokenStats })
+        tokenData.mutableData = mutableData || ''
+      } catch (error) {
+        wlogger.warn('Error getting mutable data:', error)
+        tokenData.mutableData = ''
+      }
+
+      return tokenData
+    } catch (err) {
+      wlogger.error('Error in SlpUseCases.getTokenData()', err)
+      throw err
+    }
+  }
+
+  async getMutableCid ({ tokenStats }) {
+    // Validate input - this should throw, not be caught
+    if (!tokenStats || !tokenStats.documentHash) {
+      throw new Error('No documentHash property found in tokenStats')
+    }
+
+    try {
+      await this._ensureInitialized()
+
+      // Get the OP_RETURN data and decode it
+      const mutableData = await this.decodeOpReturn({ txid: tokenStats.documentHash })
+      const jsonData = JSON.parse(mutableData)
+
+      // mda = mutable data address
+      const mda = jsonData.mda
+
+      // Get the mda transaction history
+      const transactions = await this.wallet.getTransactions(mda)
+      wlogger.info(`MDA has ${transactions.length} transactions in its history.`)
+
+      const mdaTxs = transactions
+
+      let data = false
+
+      // These are used to filter blockchain data to find the most recent
+      // update to the MDA
+      let largestBlock = 700000
+      let largestTimestamp = 1666107111271
+      let bestEntry
+
+      // Used to track the number of transactions before the best candidate is found
+      let txCnt = 0
+
+      // Map each transaction of the mda
+      // If it finds an OP_RETURN, decode it and exit the loop
+      for (let i = 0; i < mdaTxs.length; i++) {
+        const tx = mdaTxs[i]
+        const txid = tx.tx_hash
+        txCnt++
+
+        data = await this.decodeOpReturn({ txid })
+
+        // Try parse the OP_RETURN data to a JSON object
+        if (data) {
+          try {
+            // Convert the OP_RETURN data to a JSON object
+            const obj = JSON.parse(data)
+
+            // Keep searching if this TX does not have a cid value
+            if (!obj.cid) continue
+
+            // Ensure data was generated by the MDA
+            const txData = await this.wallet.getTxData([txid])
+            const vinAddress = txData[0].vin[0].address
+
+            // Skip entry if it was not made by the MDA private key
+            if (mda !== vinAddress) {
+              continue
+            }
+
+            // First best entry found
+            if (!bestEntry) {
+              bestEntry = data
+              largestBlock = tx.height
+
+              if (obj.ts) {
+                largestTimestamp = obj.ts
+              }
+            } else {
+              // One candidate already found. Looking for potentially better entry
+
+              if (tx.height < largestBlock) {
+                // Exit loop if next candidate has an older block height
+                break
+              }
+
+              if (obj.ts && obj.ts < largestTimestamp) {
+                // Continue looping through entries if the current entry in
+                // the same block has a smaller timestamp
+                continue
+              }
+
+              bestEntry = data
+              largestBlock = tx.height
+              if (obj.ts) {
+                largestTimestamp = obj.ts
+              }
+            }
+          } catch (error) {
+            continue
+          }
+        }
+      }
+
+      wlogger.info(`${txCnt} transactions reviewed to find mutable data.`)
+
+      if (!bestEntry) {
+        return false
+      }
+
+      // Get the CID
+      const obj = JSON.parse(bestEntry)
+      const cid = obj.cid
+
+      if (!cid) {
+        return false
+      }
+
+      // Assuming that CID starts with ipfs://. Cutting out that prefix
+      const mutableCid = cid.substring(7)
+
+      return mutableCid
+    } catch (err) {
+      wlogger.error('Error in SlpUseCases.getMutableCid()', err)
+      return false
+    }
+  }
+
+  async decodeOpReturn ({ txid }) {
+    try {
+      if (!txid || typeof txid !== 'string') {
+        throw new Error('txid must be a string.')
+      }
+
+      // Get transaction data
+      const txData = await this.bchjs.Electrumx.txData(txid)
+      let data = false
+
+      // Map the vout of the transaction in search of an OP_RETURN
+      for (let i = 0; i < txData.details.vout.length; i++) {
+        const vout = txData.details.vout[i]
+
+        const script = this.bchjs.Script.toASM(
+          Buffer.from(vout.scriptPubKey.hex, 'hex')
+        ).split(' ')
+
+        // Exit on the first OP_RETURN found
+        if (script[0] === 'OP_RETURN') {
+          data = Buffer.from(script[1], 'hex').toString('ascii')
+          break
+        }
+      }
+
+      return data
+    } catch (error) {
+      wlogger.error('Error in SlpUseCases.decodeOpReturn()', error)
+      throw error
+    }
+  }
+
+  async getCIDData ({ cid }) {
+    try {
+      if (!cid || typeof cid !== 'string') {
+        throw new Error('cid must be a string.')
+      }
+
+      // Assuming that CID starts with ipfs://. Cutting out that prefix
+      const cidWithoutPrefix = cid.substring(7)
+
+      const dataUrl = `https://${cidWithoutPrefix}.ipfs.dweb.link/data.json`
+      wlogger.info(`Fetching IPFS data from: ${dataUrl}`)
+
+      const response = await axios.get(dataUrl)
+
+      return response.data
+    } catch (error) {
+      wlogger.error('Error in SlpUseCases.getCIDData()', error)
+      throw error
+    }
+  }
+}
+
+export default SlpUseCases

test/integration/api/event-integration.js

@@ -1,250 +0,0 @@
-/*
-  Integration tests for POST /event endpoint.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Server from '../../../bin/server.js'
-import { finalizeEvent, getPublicKey, generateSecretKey } from 'nostr-tools/pure'
-import { hexToBytes } from '@noble/hashes/utils.js'
-
-describe('#event-integration.js', () => {
-  let server
-  const baseUrl = 'http://localhost:3001' // Use different port for tests
-
-  before(async () => {
-    // Start test server
-    server = new Server()
-    server.config.port = 3001
-    await server.startServer()
-
-    // Wait for server to be ready
-    await new Promise(resolve => setTimeout(resolve, 1000))
-  })
-
-  after(async () => {
-    // Stop server
-    if (server && server.server) {
-      await new Promise((resolve) => {
-        server.server.close(() => {
-          resolve()
-        })
-      })
-    }
-  })
-
-  describe('POST /event', () => {
-    it('should publish kind 0 event (profile metadata) - covers example 01', async () => {
-      // Generate keys
-      const sk = generateSecretKey()
-
-      // Create profile metadata event (kind 0)
-      const profileMetadata = {
-        name: 'Test User',
-        about: 'Integration test user',
-        picture: 'https://example.com/test.jpg'
-      }
-
-      const eventTemplate = {
-        kind: 0,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [],
-        content: JSON.stringify(profileMetadata)
-      }
-
-      // Sign the event
-      const signedEvent = finalizeEvent(eventTemplate, sk)
-
-      // Publish to REST API
-      const response = await fetch(`${baseUrl}/event`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(signedEvent)
-      })
-
-      const result = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.property(result, 'accepted')
-      assert.property(result, 'eventId')
-      assert.equal(result.eventId, signedEvent.id)
-    })
-
-    it('should publish kind 1 event (text post) - covers example 03', async () => {
-      // Alice's private key from examples
-      const alicePrivKeyHex = '3292a48aa331aeccce003d50d70fbd79617ba91860abbd2c78fa4a8301e36bc0'
-      const alicePrivKeyBin = hexToBytes(alicePrivKeyHex)
-      const alicePubKey = getPublicKey(alicePrivKeyBin)
-
-      // Generate a post
-      const eventTemplate = {
-        kind: 1,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [],
-        content: 'Integration test post'
-      }
-
-      // Sign the post
-      const signedEvent = finalizeEvent(eventTemplate, alicePrivKeyBin)
-
-      // Publish to REST API
-      const response = await fetch(`${baseUrl}/event`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(signedEvent)
-      })
-
-      const result = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.property(result, 'accepted')
-      assert.property(result, 'eventId')
-      assert.equal(result.eventId, signedEvent.id)
-      assert.equal(signedEvent.pubkey, alicePubKey)
-    })
-
-    it('should publish kind 3 event (follow list) - covers example 06', async () => {
-      // Alice's private key
-      const alicePrivKeyHex = '3292a48aa331aeccce003d50d70fbd79617ba91860abbd2c78fa4a8301e36bc0'
-      const alicePrivKeyBin = hexToBytes(alicePrivKeyHex)
-
-      // Bob's public key
-      const bobPrivKeyHex = 'd2e71a977bc3900d6b0f787421e3d1a666cd12ca625482b0d9eeffd23489c99f'
-      const bobPrivKeyBin = hexToBytes(bobPrivKeyHex)
-      const bobPubKey = getPublicKey(bobPrivKeyBin)
-
-      const psf = 'wss://nostr-relay.psfoundation.info'
-
-      const followList = [
-        ['p', bobPubKey, psf, 'bob']
-      ]
-
-      // Generate a follow list event (kind 3)
-      const eventTemplate = {
-        kind: 3,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: followList,
-        content: ''
-      }
-
-      // Sign the event
-      const signedEvent = finalizeEvent(eventTemplate, alicePrivKeyBin)
-
-      // Publish to REST API
-      const response = await fetch(`${baseUrl}/event`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(signedEvent)
-      })
-
-      const result = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.property(result, 'accepted')
-      assert.property(result, 'eventId')
-      assert.equal(result.eventId, signedEvent.id)
-    })
-
-    it('should publish kind 7 event (reaction/like) - covers example 07', async () => {
-      // Bob's private key
-      const bobPrivKeyHex = 'd2e71a977bc3900d6b0f787421e3d1a666cd12ca625482b0d9eeffd23489c99f'
-      const bobPrivKeyBin = hexToBytes(bobPrivKeyHex)
-      const bobPubKey = getPublicKey(bobPrivKeyBin)
-
-      const psf = 'wss://nostr-relay.psfoundation.info'
-
-      // Use a test event ID
-      const evIdToLike = 'd09b4c5da59be3cd2768aa53fa78b77bf4859084c94f3bf26d401f004a9c8167'
-      const evIdAuthorPubKey = '2c7e76c0f8dc1dca9d0197c7d19be580a8d074ccada6a2f6ebe056ae41092e92'
-
-      // Generate like event (kind 7)
-      const likeEventTemplate = {
-        kind: 7,
-        created_at: Math.floor(Date.now() / 1000),
-        pubkey: bobPubKey,
-        tags: [
-          ['e', evIdToLike, psf],
-          ['p', evIdAuthorPubKey, psf]
-        ],
-        content: '+'
-      }
-
-      // Sign the event
-      const signedEvent = finalizeEvent(likeEventTemplate, bobPrivKeyBin)
-
-      // Publish to REST API
-      const response = await fetch(`${baseUrl}/event`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(signedEvent)
-      })
-
-      const result = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.property(result, 'accepted')
-      assert.property(result, 'eventId')
-      assert.equal(result.eventId, signedEvent.id)
-    })
-
-    it('should reject invalid event', async () => {
-      const invalidEvent = {
-        id: 'invalid',
-        pubkey: 'invalid',
-        created_at: Math.floor(Date.now() / 1000),
-        kind: 1,
-        tags: [],
-        content: 'Test',
-        sig: 'invalid'
-      }
-
-      const response = await fetch(`${baseUrl}/event`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(invalidEvent)
-      })
-
-      const result = await response.json()
-
-      // Should reject invalid event - error response format
-      assert.equal(response.status, 400)
-      assert.property(result, 'error')
-      assert.include(result.error, 'Invalid event structure')
-    })
-
-    it('should return 400 when event data is missing', async () => {
-      // Send empty body - Express will parse as undefined, controller should handle it
-      const response = await fetch(`${baseUrl}/event`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: ''
-      })
-
-      // Empty body should be parsed as undefined by Express
-      const result = await response.json()
-
-      assert.equal(response.status, 400)
-      assert.property(result, 'error')
-      assert.include(result.error, 'Event data is required')
-    })
-  })
-})

test/integration/api/req-integration.js

@@ -1,173 +0,0 @@
-/*
-  Integration tests for GET /req/:subId endpoint.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Server from '../../../bin/server.js'
-import { getPublicKey } from 'nostr-tools/pure'
-import { hexToBytes } from '@noble/hashes/utils.js'
-
-describe('#req-integration.js', () => {
-  let server
-  const baseUrl = 'http://localhost:3002' // Use different port for tests
-
-  before(async () => {
-    // Start test server
-    server = new Server()
-    server.config.port = 3002
-    await server.startServer()
-
-    // Wait for server to be ready
-    await new Promise(resolve => setTimeout(resolve, 1000))
-  })
-
-  after(async () => {
-    // Stop server
-    if (server && server.server) {
-      await new Promise((resolve) => {
-        server.server.close(() => {
-          resolve()
-        })
-      })
-    }
-  })
-
-  describe('GET /req/:subId', () => {
-    it('should query kind 1 events (posts) - covers examples 02, 04', async () => {
-      // JB55's public key from example 02
-      const jb55 = '32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'
-
-      // Create subscription ID
-      const subId = 'read-posts-' + Date.now()
-
-      // Create filters - read posts from JB55
-      const filters = {
-        limit: 2,
-        kinds: [1],
-        authors: [jb55]
-      }
-
-      // Query events using GET /req/:subId
-      const filtersJson = encodeURIComponent(JSON.stringify([filters]))
-      const url = `${baseUrl}/req/${subId}?filters=${filtersJson}`
-
-      const response = await fetch(url)
-      const events = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.isArray(events)
-      // May be empty if no events exist, but structure should be correct
-      if (events.length > 0) {
-        assert.property(events[0], 'id')
-        assert.property(events[0], 'pubkey')
-        assert.property(events[0], 'created_at')
-        assert.property(events[0], 'kind')
-        assert.property(events[0], 'content')
-        assert.equal(events[0].kind, 1)
-      }
-    })
-
-    it('should query Alice posts - covers example 04', async () => {
-      // Alice's public key
-      const alicePrivKeyHex = '3292a48aa331aeccce003d50d70fbd79617ba91860abbd2c78fa4a8301e36bc0'
-      const alicePrivKeyBin = hexToBytes(alicePrivKeyHex)
-      const alicePubKey = getPublicKey(alicePrivKeyBin)
-
-      // Create subscription ID
-      const subId = 'read-alice-posts-' + Date.now()
-
-      // Create filters - read posts from Alice
-      const filters = {
-        limit: 2,
-        kinds: [1],
-        authors: [alicePubKey]
-      }
-
-      // Query events using GET /req/:subId
-      const filtersJson = encodeURIComponent(JSON.stringify([filters]))
-      const url = `${baseUrl}/req/${subId}?filters=${filtersJson}`
-
-      const response = await fetch(url)
-      const events = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.isArray(events)
-      if (events.length > 0) {
-        assert.equal(events[0].pubkey, alicePubKey)
-        assert.equal(events[0].kind, 1)
-      }
-    })
-
-    it('should query kind 3 events (follow list) - covers example 05', async () => {
-      // Alice's public key
-      const alicePrivKeyHex = '3292a48aa331aeccce003d50d70fbd79617ba91860abbd2c78fa4a8301e36bc0'
-      const alicePrivKeyBin = hexToBytes(alicePrivKeyHex)
-      const alicePubKey = getPublicKey(alicePrivKeyBin)
-
-      // Create subscription ID
-      const subId = 'get-follow-list-' + Date.now()
-
-      // Create filters - get follow list (kind 3) from Alice
-      const filters = {
-        limit: 5,
-        kinds: [3],
-        authors: [alicePubKey]
-      }
-
-      // Query events using GET /req/:subId
-      const filtersJson = encodeURIComponent(JSON.stringify([filters]))
-      const url = `${baseUrl}/req/${subId}?filters=${filtersJson}`
-
-      const response = await fetch(url)
-      const events = await response.json()
-
-      // Assert response
-      assert.equal(response.status, 200)
-      assert.isArray(events)
-      if (events.length > 0) {
-        assert.equal(events[0].kind, 3)
-        assert.equal(events[0].pubkey, alicePubKey)
-        assert.isArray(events[0].tags)
-      }
-    })
-
-    it('should handle filters as individual query params', async () => {
-      const subId = 'test-sub-' + Date.now()
-      const url = `${baseUrl}/req/${subId}?kinds=[1]&limit=10`
-
-      const response = await fetch(url)
-      const events = await response.json()
-
-      assert.equal(response.status, 200)
-      assert.isArray(events)
-    })
-
-    it('should return 400 when subscription ID is missing', async () => {
-      const url = `${baseUrl}/req/?filters=${encodeURIComponent(JSON.stringify([{ kinds: [1] }]))}`
-
-      const response = await fetch(url)
-      await response.json()
-
-      // Should return 404 or 400
-      assert.isAtLeast(response.status, 400)
-    })
-
-    it('should return 400 when filters JSON is invalid', async () => {
-      const subId = 'test-sub-' + Date.now()
-      const url = `${baseUrl}/req/${subId}?filters=invalid-json{`
-
-      const response = await fetch(url)
-      const result = await response.json()
-
-      assert.equal(response.status, 400)
-      assert.property(result, 'error')
-      assert.include(result.error, 'Invalid filters JSON')
-    })
-  })
-})

test/integration/api/subscription-integration.js

@@ -1,198 +0,0 @@
-/*
-  Integration tests for POST /req/:subId SSE subscription and DELETE /req/:subId.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Server from '../../../bin/server.js'
-
-describe('#subscription-integration.js', () => {
-  let server
-  const baseUrl = 'http://localhost:3003' // Use different port for tests
-
-  before(async () => {
-    // Start test server
-    server = new Server()
-    server.config.port = 3003
-    await server.startServer()
-
-    // Wait for server to be ready
-    await new Promise(resolve => setTimeout(resolve, 1000))
-  })
-
-  after(async function () {
-    this.timeout(10000) // Increase timeout for cleanup
-    // Stop server
-    if (server && server.server) {
-      // Close all connections forcefully if available
-      if (server.server.closeAllConnections) {
-        server.server.closeAllConnections()
-      }
-
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          resolve() // Force resolve after 2 seconds
-        }, 2000)
-
-        server.server.close(() => {
-          clearTimeout(timeout)
-          resolve()
-        })
-      })
-    }
-  })
-
-  describe('POST /req/:subId', () => {
-    it('should create SSE subscription', async () => {
-      const subId = 'test-sub-' + Date.now()
-      const filters = { kinds: [1], limit: 10 }
-
-      const response = await fetch(`${baseUrl}/req/${subId}`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(filters)
-      })
-
-      // Assert SSE headers
-      assert.equal(response.headers.get('content-type'), 'text/event-stream')
-      assert.equal(response.headers.get('cache-control'), 'no-cache')
-      assert.equal(response.headers.get('connection'), 'keep-alive')
-
-      // Read initial connection message
-      const reader = response.body.getReader()
-      const decoder = new TextDecoder()
-
-      try {
-        const { value } = await reader.read()
-        const text = decoder.decode(value)
-        assert.include(text, 'connected')
-        assert.include(text, subId)
-      } finally {
-        reader.releaseLock()
-      }
-    })
-
-    it('should return 400 when subscription ID is missing', async () => {
-      const filters = { kinds: [1] }
-
-      const response = await fetch(`${baseUrl}/req/`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(filters)
-      })
-
-      // Should return 404 or 400
-      assert.isAtLeast(response.status, 400)
-    })
-
-    it('should return 400 when filters are missing', async () => {
-      const subId = 'test-sub-' + Date.now()
-
-      const response = await fetch(`${baseUrl}/req/${subId}`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({})
-      })
-
-      const result = await response.json()
-
-      assert.equal(response.status, 400)
-      assert.property(result, 'error')
-      assert.include(result.error, 'Filters are required')
-    })
-  })
-
-  describe('DELETE /req/:subId', () => {
-    it('should close a subscription', async () => {
-      const subId = 'test-sub-' + Date.now()
-
-      const response = await fetch(`${baseUrl}/req/${subId}`, {
-        method: 'DELETE'
-      })
-
-      // May return 200 if subscription exists, or 500 if it doesn't
-      // The important thing is it doesn't crash
-      assert.isAtMost(response.status, 500)
-    })
-
-    it('should return 400 when subscription ID is missing', async () => {
-      const response = await fetch(`${baseUrl}/req/`, {
-        method: 'DELETE'
-      })
-
-      // Should return 404 or 400
-      assert.isAtLeast(response.status, 400)
-    })
-  })
-
-  describe('PUT /req/:subId', () => {
-    it('should create SSE subscription (alternative method)', async function () {
-      this.timeout(10000) // Increase timeout for this test
-
-      const subId = 'test-sub-' + Date.now()
-      const filters = { kinds: [1], limit: 10 }
-
-      const controller = new AbortController()
-      const timeoutId = setTimeout(() => controller.abort(), 8000)
-
-      let response
-      try {
-        response = await fetch(`${baseUrl}/req/${subId}`, {
-          method: 'PUT',
-          headers: {
-            'Content-Type': 'application/json'
-          },
-          body: JSON.stringify(filters),
-          signal: controller.signal
-        })
-
-        // Assert SSE headers
-        assert.equal(response.headers.get('content-type'), 'text/event-stream')
-
-        clearTimeout(timeoutId)
-
-        // Consume the stream to prevent hanging
-        const reader = response.body.getReader()
-        const decoder = new TextDecoder()
-
-        try {
-          // Read initial connection message with timeout
-          const readPromise = reader.read()
-          const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve({ value: null, done: true }), 2000))
-          const { value, done } = await Promise.race([readPromise, timeoutPromise])
-
-          if (value && !done) {
-            const text = decoder.decode(value)
-            assert.include(text, 'connected')
-          }
-        } finally {
-          reader.releaseLock()
-        }
-      } catch (err) {
-        // AbortController aborted - this is expected
-        if (err.name !== 'AbortError') {
-          throw err
-        }
-      } finally {
-        clearTimeout(timeoutId)
-        // Always close the subscription
-        try {
-          await fetch(`${baseUrl}/req/${subId}`, {
-            method: 'DELETE'
-          })
-        } catch (err) {
-          // Ignore errors when closing
-        }
-      }
-    })
-  })
-})

test/integration/use-cases/manage-subscription-integration.js

@@ -1,163 +0,0 @@
-/*
-  Integration tests for ManageSubscriptionUseCase with real adapter.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Adapters from '../../../src/adapters/index.js'
-import ManageSubscriptionUseCase from '../../../src/use-cases/manage-subscription.js'
-
-describe('#manage-subscription-integration.js', () => {
-  let adapters
-  let uut
-
-  before(async () => {
-    // Initialize adapters (will connect to real relay)
-    adapters = new Adapters()
-    await adapters.start()
-
-    uut = new ManageSubscriptionUseCase({ adapters })
-  })
-
-  after(async () => {
-    // Clean up all subscriptions and disconnect from all relays
-    // Note: This is a simplified cleanup - in production you'd track all subscriptions
-    if (adapters && adapters.nostrRelays) {
-      await Promise.allSettled(
-        adapters.nostrRelays.map(relay => relay.disconnect())
-      )
-    }
-  })
-
-  describe('#createSubscription()', () => {
-    it('should successfully create a subscription', async () => {
-      const subscriptionId = 'test-sub-' + Date.now()
-      const filters = [{ kinds: [1], limit: 5 }]
-
-      let eventReceived = false
-      let eoseReceived = false
-
-      const onEvent = (event) => {
-        eventReceived = true
-        assert.property(event, 'id')
-        assert.property(event, 'kind')
-      }
-
-      const onEose = () => {
-        eoseReceived = true
-      }
-
-      const onClosed = () => {
-        // Handler for closed events
-      }
-
-      await uut.createSubscription(subscriptionId, filters, onEvent, onEose, onClosed)
-
-      // Assert subscription exists
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      // Wait a bit for events/EOSE
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      // EOSE should be received (or events)
-      // Note: May not receive events if none exist, but EOSE should come
-      assert.isTrue(eoseReceived || eventReceived)
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-
-    it('should prevent duplicate subscriptions', async () => {
-      const subscriptionId = 'test-dup-' + Date.now()
-      const filters = [{ kinds: [1] }]
-
-      await uut.createSubscription(subscriptionId, filters)
-
-      try {
-        await uut.createSubscription(subscriptionId, filters)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'already exists')
-      }
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-
-    it('should handle subscription with no events', async () => {
-      const subscriptionId = 'test-empty-' + Date.now()
-      const filters = [{ kinds: [99999], limit: 1 }] // Unlikely to have events
-
-      let eoseReceived = false
-
-      const onEose = () => {
-        eoseReceived = true
-      }
-
-      await uut.createSubscription(subscriptionId, filters, null, onEose, null)
-
-      // Wait for EOSE
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      // Should receive EOSE even with no events
-      assert.isTrue(eoseReceived)
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-  })
-
-  describe('#closeSubscription()', () => {
-    it('should successfully close a subscription', async () => {
-      const subscriptionId = 'test-close-' + Date.now()
-      const filters = [{ kinds: [1] }]
-
-      await uut.createSubscription(subscriptionId, filters)
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      await uut.closeSubscription(subscriptionId)
-
-      // Assert subscription is removed
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-    })
-
-    it('should return successfully when closing non-existent subscription (idempotent)', async () => {
-      const subscriptionId = 'non-existent-sub'
-
-      // Should not throw - idempotent operation
-      await uut.closeSubscription(subscriptionId)
-
-      // Should return successfully without error
-      assert.isTrue(true, 'closeSubscription should succeed for non-existent subscription')
-    })
-  })
-
-  describe('#hasSubscription()', () => {
-    it('should return false for non-existent subscription', () => {
-      assert.isFalse(uut.hasSubscription('non-existent'))
-    })
-
-    it('should return true for existing subscription', async () => {
-      const subscriptionId = 'test-has-' + Date.now()
-      const filters = [{ kinds: [1] }]
-
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-      await uut.createSubscription(subscriptionId, filters)
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-  })
-})

test/integration/use-cases/publish-event-integration.js

@@ -1,104 +0,0 @@
-/*
-  Integration tests for PublishEventUseCase with real adapter.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Adapters from '../../../src/adapters/index.js'
-import PublishEventUseCase from '../../../src/use-cases/publish-event.js'
-import { finalizeEvent, generateSecretKey } from 'nostr-tools/pure'
-
-describe('#publish-event-integration.js', () => {
-  let adapters
-  let uut
-
-  before(async () => {
-    // Initialize adapters (will connect to real relay)
-    adapters = new Adapters()
-    await adapters.start()
-
-    uut = new PublishEventUseCase({ adapters })
-  })
-
-  after(async () => {
-    // Clean up adapters - disconnect from all relays
-    if (adapters && adapters.nostrRelays) {
-      await Promise.allSettled(
-        adapters.nostrRelays.map(relay => relay.disconnect())
-      )
-    }
-  })
-
-  describe('#execute()', () => {
-    it('should successfully publish a valid event', async () => {
-      // Generate keys
-      const sk = generateSecretKey()
-
-      // Create event template
-      const eventTemplate = {
-        kind: 1,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [],
-        content: 'Integration test post from use case'
-      }
-
-      // Sign the event
-      const signedEvent = finalizeEvent(eventTemplate, sk)
-
-      // Execute use case
-      const result = await uut.execute(signedEvent)
-
-      // Assert result
-      assert.property(result, 'accepted')
-      assert.property(result, 'message')
-      assert.property(result, 'eventId')
-      assert.equal(result.eventId, signedEvent.id)
-    })
-
-    it('should reject invalid event structure', async () => {
-      const invalidEvent = {
-        id: 'invalid',
-        pubkey: 'invalid',
-        created_at: Math.floor(Date.now() / 1000),
-        kind: 1,
-        tags: [],
-        content: 'Test',
-        sig: 'invalid'
-      }
-
-      try {
-        await uut.execute(invalidEvent)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Invalid event structure')
-      }
-    })
-
-    it('should handle relay rejection', async () => {
-      // Generate keys
-      const sk = generateSecretKey()
-
-      // Create a duplicate event (if we send same event twice)
-      const eventTemplate = {
-        kind: 1,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [],
-        content: 'Duplicate test post'
-      }
-
-      const signedEvent = finalizeEvent(eventTemplate, sk)
-
-      // Publish first time
-      const result1 = await uut.execute(signedEvent)
-      assert.property(result1, 'accepted')
-
-      // Try to publish again (may be rejected as duplicate)
-      const result2 = await uut.execute(signedEvent)
-      assert.property(result2, 'accepted')
-      // Result may be accepted or rejected depending on relay
-    })
-  })
-})

test/integration/use-cases/query-events-integration.js

@@ -1,95 +0,0 @@
-/*
-  Integration tests for QueryEventsUseCase with real adapter.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Adapters from '../../../src/adapters/index.js'
-import QueryEventsUseCase from '../../../src/use-cases/query-events.js'
-
-describe('#query-events-integration.js', () => {
-  let adapters
-  let uut
-
-  before(async () => {
-    // Initialize adapters (will connect to real relay)
-    adapters = new Adapters()
-    await adapters.start()
-
-    uut = new QueryEventsUseCase({ adapters })
-  })
-
-  after(async () => {
-    // Clean up adapters - disconnect from all relays
-    if (adapters && adapters.nostrRelays) {
-      await Promise.allSettled(
-        adapters.nostrRelays.map(relay => relay.disconnect())
-      )
-    }
-  })
-
-  describe('#execute()', () => {
-    it('should successfully query events', async () => {
-      const filters = [{ kinds: [1], limit: 5 }]
-      const subscriptionId = 'test-query-' + Date.now()
-
-      const events = await uut.execute(filters, subscriptionId)
-
-      // Assert result is an array
-      assert.isArray(events)
-
-      // If events are returned, verify structure
-      if (events.length > 0) {
-        assert.property(events[0], 'id')
-        assert.property(events[0], 'pubkey')
-        assert.property(events[0], 'created_at')
-        assert.property(events[0], 'kind')
-        assert.property(events[0], 'content')
-        assert.equal(events[0].kind, 1)
-      }
-    })
-
-    it('should handle empty results', async () => {
-      // Query for events that likely don't exist
-      const filters = [{ kinds: [99999], limit: 1 }]
-      const subscriptionId = 'test-empty-' + Date.now()
-
-      const events = await uut.execute(filters, subscriptionId)
-
-      // Should return empty array, not throw
-      assert.isArray(events)
-      assert.equal(events.length, 0)
-    })
-
-    it('should handle multiple filters', async function () {
-      // Increase timeout for this test - needs to be longer than use case timeout (30s)
-      this.timeout(35000)
-
-      const filters = [
-        { kinds: [1], limit: 2 },
-        { kinds: [3], limit: 2 }
-      ]
-      const subscriptionId = 'test-multi-' + Date.now()
-
-      const events = await uut.execute(filters, subscriptionId)
-
-      // Should return array (may be empty)
-      assert.isArray(events)
-    })
-
-    it('should timeout if EOSE not received', async () => {
-      // This test may take up to 30 seconds
-      // Use a filter that might not return EOSE quickly
-      const filters = [{ kinds: [1] }] // No limit, might timeout
-      const subscriptionId = 'test-timeout-' + Date.now()
-
-      // Should eventually return (even if empty)
-      const events = await uut.execute(filters, subscriptionId)
-
-      assert.isArray(events)
-    })
-  })
-})

test/unit/adapters/full-node-rpc-unit.js

@@ -0,0 +1,122 @@
+/*
+  Unit tests for FullNodeRPCAdapter.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+import axios from 'axios'
+
+import FullNodeRPCAdapter from '../../../src/adapters/full-node-rpc.js'
+
+describe('#full-node-rpc.js', () => {
+  let sandbox
+  let axiosCreateStub
+  let mockAxiosInstance
+
+  const baseConfig = {
+    fullNode: {
+      rpcBaseUrl: 'http://127.0.0.1:8332',
+      rpcUsername: 'user',
+      rpcPassword: 'pass',
+      rpcTimeoutMs: 1000,
+      rpcRequestIdPrefix: 'test'
+    }
+  }
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAxiosInstance = {
+      post: sandbox.stub()
+    }
+    axiosCreateStub = sandbox.stub(axios, 'create').returns(mockAxiosInstance)
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should throw if full node config is missing', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new FullNodeRPCAdapter({ config: {} })
+      }, /Full node RPC configuration is required/)
+    })
+
+    it('should create axios client with provided configuration', () => {
+      // eslint-disable-next-line no-new
+      new FullNodeRPCAdapter({ config: baseConfig })
+
+      assert.isTrue(axiosCreateStub.calledOnce)
+      const options = axiosCreateStub.getCall(0).args[0]
+      assert.equal(options.baseURL, baseConfig.fullNode.rpcBaseUrl)
+      assert.equal(options.timeout, baseConfig.fullNode.rpcTimeoutMs)
+      assert.deepEqual(options.auth, {
+        username: baseConfig.fullNode.rpcUsername,
+        password: baseConfig.fullNode.rpcPassword
+      })
+    })
+  })
+
+  describe('#call()', () => {
+    it('should call RPC method and return result', async () => {
+      mockAxiosInstance.post.resolves({ data: { result: 'hash' } })
+      const uut = new FullNodeRPCAdapter({ config: baseConfig })
+
+      const result = await uut.call('getbestblockhash', [])
+
+      assert.equal(result, 'hash')
+      assert.isTrue(mockAxiosInstance.post.calledOnce)
+      const [, payload] = mockAxiosInstance.post.getCall(0).args
+      assert.deepEqual(payload, {
+        jsonrpc: '1.0',
+        id: 'test-getbestblockhash',
+        method: 'getbestblockhash',
+        params: []
+      })
+    })
+
+    it('should use custom request id when provided', async () => {
+      mockAxiosInstance.post.resolves({ data: { result: 123 } })
+      const uut = new FullNodeRPCAdapter({ config: baseConfig })
+
+      await uut.call('getblockcount', [], 'custom-id')
+
+      const [, payload] = mockAxiosInstance.post.getCall(0).args
+      assert.equal(payload.id, 'custom-id')
+    })
+
+    it('should throw formatted error when RPC returns error', async () => {
+      mockAxiosInstance.post.resolves({
+        data: {
+          error: { message: 'RPC error' }
+        }
+      })
+      const uut = new FullNodeRPCAdapter({ config: baseConfig })
+
+      try {
+        await uut.call('failing', [])
+        assert.fail('Unexpected success')
+      } catch (err) {
+        assert.equal(err.message, 'RPC error')
+        assert.equal(err.status, 400)
+      }
+    })
+
+    it('should translate network errors into 503 status', async () => {
+      mockAxiosInstance.post.rejects(new Error('ENOTFOUND fullnode'))
+      const uut = new FullNodeRPCAdapter({ config: baseConfig })
+
+      try {
+        await uut.call('getblockcount', [])
+        assert.fail('Unexpected success')
+      } catch (err) {
+        assert.equal(
+          err.message,
+          'Network error: Could not communicate with full node or other external service.'
+        )
+        assert.equal(err.status, 503)
+      }
+    })
+  })
+})

test/unit/adapters/nostr-relay-unit.js

@@ -1,304 +0,0 @@
-/*
-  Unit tests for NostrRelayAdapter.
-*/
-
-/*
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-
-// Mocking data libraries
-import {
-  mockKind1Event,
-  validEventId
-} from '../mocks/event-mocks.js'
-import {
-  mockOkAccepted,
-  mockEventMessage,
-  mockEoseMessage,
-  mockClosedMessage
-} from '../mocks/nostr-relay-mocks.js'
-
-// Unit under test
-// Note: WebSocket mocking for ES modules is complex. These tests focus on
-// testing the adapter's logic that can be tested without full WebSocket mocking.
-import NostrRelayAdapter from '../../../src/adapters/nostr-relay.js'
-
-describe('#nostr-relay.js', () => {
-  let sandbox
-  let uut
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    uut = new NostrRelayAdapter({
-      relayUrl: 'wss://test-relay.example.com'
-    })
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  describe('#connect()', () => {
-    it('should return immediately if already connected', async () => {
-      // Manually set connection state
-      uut.isConnected = true
-      uut.ws = { close: sandbox.stub() }
-
-      await uut.connect()
-
-      // Should not create new connection
-      assert.isTrue(uut.isConnected)
-    })
-
-    // Note: Full WebSocket connection testing requires integration tests
-    // due to ES module import limitations
-  })
-
-  describe('#sendEvent()', () => {
-    it('should queue message when disconnected', async () => {
-      uut.isConnected = false
-      uut.ws = null
-
-      // Mock connect to resolve immediately
-      uut.connect = sandbox.stub().resolves()
-
-      // Start sending (will queue)
-      uut.sendEvent(mockKind1Event).catch(() => {
-        // Expected to fail or timeout without real WebSocket
-      })
-
-      // Should queue message and attempt connection
-      // Wait a bit for async operations
-      await new Promise(resolve => setTimeout(resolve, 10))
-      assert.isTrue(uut.pendingMessages.length > 0 || uut.connect.called)
-    })
-
-    it('should set up event resolver', async () => {
-      uut.isConnected = true
-      uut.ws = { send: sandbox.stub() }
-      // Mock sendMessage to resolve immediately
-      uut.sendMessage = sandbox.stub().resolves()
-
-      // Start sending
-      const sendPromise = uut.sendEvent(mockKind1Event).catch(() => {
-        // Expected without real WebSocket response
-      })
-
-      // Wait a tick for Promise constructor to run
-      await new Promise(resolve => setImmediate(resolve))
-
-      // Verify resolver was set up
-      assert.isTrue(uut.eventResolvers.has(mockKind1Event.id))
-
-      // Clean up
-      uut.eventResolvers.delete(mockKind1Event.id)
-      // Prevent timeout error
-      sendPromise.catch(() => {})
-    })
-
-    // Note: Full sendEvent testing with WebSocket responses requires integration tests
-  })
-
-  describe('#sendReq()', () => {
-    it('should store handlers for subscription', async () => {
-      uut.isConnected = true
-      uut.ws = { send: sandbox.stub() }
-      uut.connect = sandbox.stub().resolves()
-
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-      const handlers = {
-        onEvent: sandbox.stub(),
-        onEose: sandbox.stub(),
-        onClosed: sandbox.stub()
-      }
-
-      await uut.sendReq(subscriptionId, filters, handlers)
-
-      // Assert handlers were stored
-      assert.isTrue(uut.subscriptionHandlers.has(subscriptionId))
-      assert.deepEqual(uut.subscriptionHandlers.get(subscriptionId), handlers)
-    })
-
-    it('should connect before sending if disconnected', async () => {
-      uut.isConnected = false
-      uut.connect = sandbox.stub().resolves()
-
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-      const handlers = {}
-
-      await uut.sendReq(subscriptionId, filters, handlers)
-
-      assert.isTrue(uut.connect.called)
-    })
-  })
-
-  describe('#sendClose()', () => {
-    it('should clean up handlers for subscription', async () => {
-      uut.isConnected = true
-      uut.ws = { send: sandbox.stub() }
-
-      const subscriptionId = 'test-sub-123'
-      uut.subscriptionHandlers.set(subscriptionId, {})
-      uut.messageHandlers.set(subscriptionId, {})
-
-      await uut.sendClose(subscriptionId)
-
-      // Assert handlers were cleaned up
-      assert.isFalse(uut.subscriptionHandlers.has(subscriptionId))
-      assert.isFalse(uut.messageHandlers.has(subscriptionId))
-    })
-  })
-
-  describe('#handleMessage()', () => {
-    it('should handle EVENT message', () => {
-      // Use the subscription ID from the mock message
-      const subscriptionId = 'subscription-id-123'
-      const onEventHandler = sandbox.stub()
-      uut.subscriptionHandlers.set(subscriptionId, {
-        onEvent: onEventHandler
-      })
-
-      const message = mockEventMessage
-      uut.handleMessage(message)
-
-      assert.isTrue(onEventHandler.calledOnce)
-      assert.deepEqual(onEventHandler.getCall(0).args[0], mockKind1Event)
-    })
-
-    it('should handle EOSE message', () => {
-      // Use the subscription ID from the mock message
-      const subscriptionId = 'subscription-id-123'
-      const onEoseHandler = sandbox.stub()
-      uut.subscriptionHandlers.set(subscriptionId, {
-        onEose: onEoseHandler
-      })
-
-      const message = mockEoseMessage
-      uut.handleMessage(message)
-
-      assert.isTrue(onEoseHandler.calledOnce)
-    })
-
-    it('should handle CLOSED message', () => {
-      // Use the subscription ID from the mock message
-      const subscriptionId = 'subscription-id-123'
-      const onClosedHandler = sandbox.stub()
-      uut.subscriptionHandlers.set(subscriptionId, {
-        onClosed: onClosedHandler
-      })
-
-      const message = mockClosedMessage
-      uut.handleMessage(message)
-
-      assert.isTrue(onClosedHandler.calledOnce)
-      assert.equal(onClosedHandler.getCall(0).args[0], 'subscription closed')
-    })
-
-    it('should handle OK message', () => {
-      const eventId = validEventId
-      let resolver = null
-      uut.eventResolvers.set(eventId, (result) => {
-        resolver = result
-      })
-
-      const message = mockOkAccepted
-      uut.handleMessage(message)
-
-      assert.isNotNull(resolver)
-      assert.isTrue(resolver.accepted)
-      assert.isFalse(uut.eventResolvers.has(eventId))
-    })
-
-    it('should handle NOTICE message', () => {
-      const message = ['NOTICE', 'rate limited']
-      // Should not throw
-      uut.handleMessage(message)
-    })
-
-    it('should ignore invalid message format', () => {
-      const message = 'invalid'
-      // Should not throw
-      uut.handleMessage(message)
-    })
-
-    it('should ignore empty messages', () => {
-      const message = []
-      // Should not throw
-      uut.handleMessage(message)
-    })
-  })
-
-  describe('#disconnect()', () => {
-    it('should disconnect from relay', async () => {
-      const mockWs = { close: sandbox.stub() }
-      uut.isConnected = true
-      uut.ws = mockWs
-
-      await uut.disconnect()
-
-      assert.isTrue(mockWs.close.called)
-      assert.isFalse(uut.isConnected)
-      assert.isNull(uut.ws)
-    })
-
-    it('should handle disconnect when already disconnected', async () => {
-      uut.isConnected = false
-      uut.ws = null
-
-      await uut.disconnect()
-
-      assert.isFalse(uut.isConnected)
-    })
-  })
-
-  describe('#handleError()', () => {
-    it('should handle WebSocket errors', () => {
-      uut.isConnected = true
-      const error = new Error('WebSocket error')
-
-      uut.handleError(error)
-
-      assert.isFalse(uut.isConnected)
-    })
-  })
-
-  describe('#handleClose()', () => {
-    it('should attempt reconnection on close', async () => {
-      uut.isConnected = true
-      uut.reconnectAttempts = 0
-      uut.maxReconnectAttempts = 5
-
-      // Mock connect to avoid actual connection
-      uut.connect = sandbox.stub().resolves()
-
-      uut.handleClose()
-
-      // Wait for reconnection attempt
-      await new Promise(resolve => setTimeout(resolve, 110))
-
-      // Should attempt reconnection
-      assert.equal(uut.reconnectAttempts, 1)
-    })
-
-    it('should stop reconnecting after max attempts', async () => {
-      uut.isConnected = true
-      uut.reconnectAttempts = 5
-      uut.maxReconnectAttempts = 5
-
-      uut.connect = sandbox.stub().resolves()
-
-      uut.handleClose()
-
-      await new Promise(resolve => setTimeout(resolve, 110))
-
-      // Should not increment beyond max
-      assert.equal(uut.reconnectAttempts, 5)
-    })
-  })
-})
-
-*/

test/unit/controllers/blockchain-controller-unit.js

@@ -0,0 +1,214 @@
+/*
+  Unit tests for BlockchainRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import BlockchainRESTController from '../../../src/controllers/rest-api/full-node/blockchain/controller.js'
+import {
+  createMockRequest,
+  createMockResponse
+} from '../mocks/controller-mocks.js'
+
+describe('#blockchain-controller.js', () => {
+  let sandbox
+  let mockUseCases
+  let mockAdapters
+  let uut
+
+  const createBlockchainUseCaseStubs = () => ({
+    getBestBlockHash: sandbox.stub().resolves('hash'),
+    getBlockchainInfo: sandbox.stub().resolves({}),
+    getBlockCount: sandbox.stub().resolves(123),
+    getBlockHeader: sandbox.stub().resolves({ header: true }),
+    getBlockHeaders: sandbox.stub().resolves(['header']),
+    getChainTips: sandbox.stub().resolves(['tip']),
+    getDifficulty: sandbox.stub().resolves(1),
+    getMempoolEntry: sandbox.stub().resolves({}),
+    getMempoolEntries: sandbox.stub().resolves([]),
+    getMempoolAncestors: sandbox.stub().resolves([]),
+    getMempoolInfo: sandbox.stub().resolves({ size: 1 }),
+    getRawMempool: sandbox.stub().resolves(['tx']),
+    getTxOut: sandbox.stub().resolves({ value: 1 }),
+    getTxOutProof: sandbox.stub().resolves('proof'),
+    getTxOutProofs: sandbox.stub().resolves(['proof']),
+    verifyTxOutProof: sandbox.stub().resolves(['txid']),
+    verifyTxOutProofs: sandbox.stub().resolves([['txid']]),
+    getBlock: sandbox.stub().resolves({ hash: 'abc' }),
+    getBlockHash: sandbox.stub().resolves('blockhash')
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {
+      fullNode: {
+        validateArraySize: sandbox.stub().returns(true)
+      }
+    }
+    mockUseCases = {
+      blockchain: createBlockchainUseCaseStubs()
+    }
+    uut = new BlockchainRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new BlockchainRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require blockchain use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new BlockchainRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Blockchain use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return service status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'blockchain' })
+    })
+  })
+
+  describe('#getBestBlockHash()', () => {
+    it('should return hash on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getBestBlockHash(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.equal(res.jsonData, 'hash')
+      assert.isTrue(mockUseCases.blockchain.getBestBlockHash.calledOnce)
+    })
+
+    it('should handle errors via handleError()', async () => {
+      const error = new Error('failure')
+      error.status = 422
+      mockUseCases.blockchain.getBestBlockHash.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getBestBlockHash(req, res)
+
+      assert.equal(res.statusValue, 422)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+
+  describe('#getBlockHeaderSingle()', () => {
+    it('should return 400 if hash is missing', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getBlockHeaderSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should call use case with verbose flag', async () => {
+      const hash = 'a'.repeat(64)
+      const req = createMockRequest({
+        params: { hash },
+        query: { verbose: 'true' }
+      })
+      const res = createMockResponse()
+
+      await uut.getBlockHeaderSingle(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(
+        mockUseCases.blockchain.getBlockHeader.calledOnceWithExactly({
+          hash,
+          verbose: true
+        })
+      )
+    })
+  })
+
+  describe('#getBlockHeaderBulk()', () => {
+    it('should return error if hashes is not array', async () => {
+      const req = createMockRequest({
+        body: { hashes: 'not-an-array' },
+        locals: {}
+      })
+      const res = createMockResponse()
+
+      await uut.getBlockHeaderBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.include(res.jsonData.error, 'hashes needs to be an array')
+    })
+
+    it('should validate array size and call use case', async () => {
+      const hash = 'a'.repeat(64)
+      const req = createMockRequest({
+        body: { hashes: [hash], verbose: true }
+      })
+      const res = createMockResponse()
+      mockUseCases.blockchain.getBlockHeaders.resolves(['result'])
+
+      await uut.getBlockHeaderBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, ['result'])
+      assert.isTrue(
+        mockAdapters.fullNode.validateArraySize.calledOnceWithExactly(1)
+      )
+      assert.isTrue(
+        mockUseCases.blockchain.getBlockHeaders.calledOnceWithExactly({
+          hashes: [hash],
+          verbose: true
+        })
+      )
+    })
+
+    it('should return error if array size invalid', async () => {
+      mockAdapters.fullNode.validateArraySize.returns(false)
+      const req = createMockRequest({
+        body: { hashes: ['a'.repeat(64)] },
+        locals: {}
+      })
+      const res = createMockResponse()
+
+      await uut.getBlockHeaderBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.equal(res.jsonData.error, 'Array too large.')
+    })
+  })
+
+  describe('#verifyTxOutProofBulk()', () => {
+    it('should flatten proof responses', async () => {
+      mockUseCases.blockchain.verifyTxOutProofs.resolves([['txid-a'], ['txid-b']])
+      const req = createMockRequest({
+        body: { proofs: ['proof-a', 'proof-b'] },
+        locals: {}
+      })
+      const res = createMockResponse()
+
+      await uut.verifyTxOutProofBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, ['txid-a', 'txid-b'])
+    })
+  })
+})

test/unit/controllers/control-controller-unit.js

@@ -0,0 +1,88 @@
+/*
+  Unit tests for ControlRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import ControlRESTController from '../../../src/controllers/rest-api/full-node/control/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#control-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      control: {
+        getNetworkInfo: sandbox.stub().resolves({ version: 1 })
+      }
+    }
+
+    uut = new ControlRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require control use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Control use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return control status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'control' })
+    })
+  })
+
+  describe('#getNetworkInfo()', () => {
+    it('should return network info on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getNetworkInfo(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { version: 1 })
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('failure')
+      error.status = 503
+      mockUseCases.control.getNetworkInfo.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getNetworkInfo(req, res)
+
+      assert.equal(res.statusValue, 503)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+})

test/unit/controllers/dsproof-controller-unit.js

@@ -0,0 +1,117 @@
+/*
+  Unit tests for DSProofRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import DSProofRESTController from '../../../src/controllers/rest-api/full-node/dsproof/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#dsproof-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      dsproof: {
+        getDSProof: sandbox.stub().resolves({ proof: true })
+      }
+    }
+
+    uut = new DSProofRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require dsproof use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /DSProof use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return dsproof status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'dsproof' })
+    })
+  })
+
+  describe('#getDSProof()', () => {
+    it('should validate txid presence', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.include(res.jsonData.error, 'txid can not be empty')
+    })
+
+    it('should validate txid length', async () => {
+      const req = createMockRequest({ params: { txid: 'abc' } })
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.include(res.jsonData.error, 'txid must be of length 64')
+    })
+
+    it('should call use case with derived verbose when valid', async () => {
+      const txid = 'a'.repeat(64)
+      const req = createMockRequest({
+        params: { txid },
+        query: { verbose: 'true' }
+      })
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.dsproof.getDSProof.calledOnceWithExactly({
+        txid,
+        verbose: 3
+      }))
+      assert.deepEqual(res.jsonData, { proof: true })
+    })
+
+    it('should handle errors via handleError', async () => {
+      const txid = 'a'.repeat(64)
+      const error = new Error('failure')
+      error.status = 422
+      mockUseCases.dsproof.getDSProof.rejects(error)
+      const req = createMockRequest({ params: { txid } })
+      const res = createMockResponse()
+
+      await uut.getDSProof(req, res)
+
+      assert.equal(res.statusValue, 422)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+})

test/unit/controllers/event-controller-unit.js

@@ -1,187 +0,0 @@
-/*
-  Unit tests for EventRESTControllerLib.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-
-// Mocking data libraries
-import {
-  mockKind1Event,
-  mockKind0Event
-} from '../mocks/event-mocks.js'
-import {
-  createMockRequestWithBody,
-  createMockResponse
-} from '../mocks/controller-mocks.js'
-
-// Unit under test
-import EventRESTControllerLib from '../../../src/controllers/rest-api/event/controller.js'
-
-describe('#event-controller.js', () => {
-  let sandbox
-  let mockUseCases
-  let uut
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    // Create mock use cases
-    mockUseCases = {
-      publishEvent: {
-        execute: sandbox.stub()
-      }
-    }
-
-    uut = new EventRESTControllerLib({
-      adapters: {},
-      useCases: mockUseCases
-    })
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  describe('#publishEvent()', () => {
-    it('should successfully publish an event', async () => {
-      const req = createMockRequestWithBody(mockKind1Event)
-      const res = createMockResponse()
-
-      mockUseCases.publishEvent.execute.resolves({
-        accepted: true,
-        message: 'event saved',
-        eventId: mockKind1Event.id
-      })
-
-      await uut.publishEvent(req, res)
-
-      // Assert use case was called
-      assert.isTrue(mockUseCases.publishEvent.execute.calledOnce)
-      assert.deepEqual(mockUseCases.publishEvent.execute.getCall(0).args[0], mockKind1Event)
-
-      // Assert response
-      assert.equal(res.statusValue, 200)
-      assert.property(res.jsonData, 'accepted')
-      assert.isTrue(res.jsonData.accepted)
-      assert.equal(res.jsonData.eventId, mockKind1Event.id)
-    })
-
-    it('should return 400 when event is rejected', async () => {
-      const req = createMockRequestWithBody(mockKind1Event)
-      const res = createMockResponse()
-
-      mockUseCases.publishEvent.execute.resolves({
-        accepted: false,
-        message: 'duplicate: event already exists',
-        eventId: mockKind1Event.id
-      })
-
-      await uut.publishEvent(req, res)
-
-      // Assert response status is 400
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'accepted')
-      assert.isFalse(res.jsonData.accepted)
-    })
-
-    it('should return 400 when event data is missing', async () => {
-      const req = createMockRequestWithBody(null)
-      const res = createMockResponse()
-
-      await uut.publishEvent(req, res)
-
-      // Assert use case was not called
-      assert.isFalse(mockUseCases.publishEvent.execute.called)
-
-      // Assert error response
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Event data is required')
-    })
-
-    it('should handle use case errors', async () => {
-      const req = createMockRequestWithBody(mockKind1Event)
-      const res = createMockResponse()
-
-      mockUseCases.publishEvent.execute.rejects(new Error('Network error'))
-
-      await uut.publishEvent(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 500)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Network error')
-    })
-
-    it('should return 400 for validation errors', async () => {
-      const req = createMockRequestWithBody(mockKind1Event)
-      const res = createMockResponse()
-
-      mockUseCases.publishEvent.execute.rejects(new Error('Invalid event structure'))
-
-      await uut.publishEvent(req, res)
-
-      // Assert validation error returns 400
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Invalid event structure')
-    })
-
-    it('should handle errors with missing message', async () => {
-      const req = createMockRequestWithBody(mockKind1Event)
-      const res = createMockResponse()
-
-      const error = new Error()
-      error.message = undefined
-      mockUseCases.publishEvent.execute.rejects(error)
-
-      await uut.publishEvent(req, res)
-
-      // Assert error response with default message
-      assert.equal(res.statusValue, 500)
-      assert.property(res.jsonData, 'error')
-      assert.equal(res.jsonData.error, 'Internal server error')
-    })
-
-    it('should publish different event kinds', async () => {
-      const req = createMockRequestWithBody(mockKind0Event)
-      const res = createMockResponse()
-
-      mockUseCases.publishEvent.execute.resolves({
-        accepted: true,
-        message: 'event saved',
-        eventId: mockKind0Event.id
-      })
-
-      await uut.publishEvent(req, res)
-
-      assert.isTrue(mockUseCases.publishEvent.execute.calledOnce)
-      assert.equal(res.statusValue, 200)
-      assert.isTrue(res.jsonData.accepted)
-    })
-  })
-
-  describe('#constructor()', () => {
-    it('should require adapters instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new EventRESTControllerLib({ useCases: mockUseCases })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Adapters library required')
-      }
-    })
-
-    it('should require useCases instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new EventRESTControllerLib({ adapters: {} })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Use Cases library required')
-      }
-    })
-  })
-})

test/unit/controllers/fulcrum-controller-unit.js

@@ -0,0 +1,481 @@
+/*
+  Unit tests for FulcrumRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import FulcrumRESTController from '../../../src/controllers/rest-api/fulcrum/controller.js'
+import {
+  createMockRequest,
+  createMockResponse
+} from '../mocks/controller-mocks.js'
+
+// Valid mainnet cash address for testing
+const VALID_MAINNET_ADDRESS = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+
+describe('#fulcrum-controller.js', () => {
+  let sandbox
+  let mockUseCases
+  let mockAdapters
+  let uut
+
+  const createFulcrumUseCaseStubs = () => ({
+    getBalance: sandbox.stub().resolves({ balance: 1000 }),
+    getBalances: sandbox.stub().resolves({ balances: [] }),
+    getUtxos: sandbox.stub().resolves({ utxos: [] }),
+    getUtxosBulk: sandbox.stub().resolves({ utxos: [] }),
+    getTransactionDetails: sandbox.stub().resolves({ txid: 'abc' }),
+    getTransactionDetailsBulk: sandbox.stub().resolves({ transactions: [] }),
+    broadcastTransaction: sandbox.stub().resolves({ txid: 'abc' }),
+    getBlockHeaders: sandbox.stub().resolves({ headers: [] }),
+    getBlockHeadersBulk: sandbox.stub().resolves({ headers: [] }),
+    getTransactions: sandbox.stub().resolves({ transactions: [] }),
+    getTransactionsBulk: sandbox.stub().resolves({ transactions: [] }),
+    getMempool: sandbox.stub().resolves({ mempool: [] }),
+    getMempoolBulk: sandbox.stub().resolves({ mempool: [] })
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {
+      fullNode: {
+        validateArraySize: sandbox.stub().returns(true)
+      }
+    }
+    mockUseCases = {
+      fulcrum: createFulcrumUseCaseStubs()
+    }
+
+    uut = new FulcrumRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new FulcrumRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require fulcrum use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new FulcrumRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Fulcrum use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return service status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'fulcrum' })
+    })
+  })
+
+  describe('#getBalance()', () => {
+    it('should return balance on success', async () => {
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getBalance(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { balance: 1000 })
+      assert.isTrue(mockUseCases.fulcrum.getBalance.calledOnce)
+    })
+
+    it('should return error if address is array', async () => {
+      const req = createMockRequest({
+        params: { address: [] }
+      })
+      const res = createMockResponse()
+
+      await uut.getBalance(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('failure')
+      error.status = 503
+      mockUseCases.fulcrum.getBalance.rejects(error)
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getBalance(req, res)
+
+      assert.equal(res.statusValue, 503)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+
+  describe('#balanceBulk()', () => {
+    it('should return error if addresses is not array', async () => {
+      const req = createMockRequest({
+        body: { addresses: 'not-an-array' }
+      })
+      const res = createMockResponse()
+
+      await uut.balanceBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should validate array size and call use case', async () => {
+      const req = createMockRequest({
+        body: { addresses: [VALID_MAINNET_ADDRESS] }
+      })
+      const res = createMockResponse()
+
+      await uut.balanceBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockAdapters.fullNode.validateArraySize.calledOnce)
+      assert.isTrue(mockUseCases.fulcrum.getBalances.calledOnce)
+    })
+
+    it('should return error if array size invalid', async () => {
+      mockAdapters.fullNode.validateArraySize.returns(false)
+      const req = createMockRequest({
+        body: { addresses: [VALID_MAINNET_ADDRESS] }
+      })
+      const res = createMockResponse()
+
+      await uut.balanceBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.equal(res.jsonData.error, 'Array too large.')
+    })
+  })
+
+  describe('#getUtxos()', () => {
+    it('should return utxos on success', async () => {
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getUtxos(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { utxos: [] })
+      assert.isTrue(mockUseCases.fulcrum.getUtxos.calledOnce)
+    })
+  })
+
+  describe('#utxosBulk()', () => {
+    it('should validate array and call use case', async () => {
+      const req = createMockRequest({
+        body: { addresses: [VALID_MAINNET_ADDRESS] }
+      })
+      const res = createMockResponse()
+
+      await uut.utxosBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.fulcrum.getUtxosBulk.calledOnce)
+    })
+  })
+
+  describe('#getTransactionDetails()', () => {
+    it('should return transaction details on success', async () => {
+      const txid = 'a'.repeat(64)
+      const req = createMockRequest({
+        params: { txid }
+      })
+      const res = createMockResponse()
+
+      await uut.getTransactionDetails(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { txid: 'abc' })
+      assert.isTrue(mockUseCases.fulcrum.getTransactionDetails.calledOnce)
+    })
+
+    it('should return error if txid is not string', async () => {
+      const req = createMockRequest({
+        params: { txid: 123 }
+      })
+      const res = createMockResponse()
+
+      await uut.getTransactionDetails(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+  })
+
+  describe('#transactionDetailsBulk()', () => {
+    it('should validate array and call use case', async () => {
+      const req = createMockRequest({
+        body: { txids: ['a'.repeat(64)], verbose: true }
+      })
+      const res = createMockResponse()
+
+      await uut.transactionDetailsBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.fulcrum.getTransactionDetailsBulk.calledOnce)
+    })
+
+    it('should default verbose to true', async () => {
+      const req = createMockRequest({
+        body: { txids: ['a'.repeat(64)] }
+      })
+      const res = createMockResponse()
+
+      await uut.transactionDetailsBulk(req, res)
+
+      assert.isTrue(
+        mockUseCases.fulcrum.getTransactionDetailsBulk.calledWithMatch({
+          txids: ['a'.repeat(64)],
+          verbose: true
+        })
+      )
+    })
+  })
+
+  describe('#broadcastTransaction()', () => {
+    it('should broadcast transaction on success', async () => {
+      const req = createMockRequest({
+        body: { txHex: '010203' }
+      })
+      const res = createMockResponse()
+
+      await uut.broadcastTransaction(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { txid: 'abc' })
+      assert.isTrue(mockUseCases.fulcrum.broadcastTransaction.calledOnce)
+    })
+
+    it('should return error if txHex is not string', async () => {
+      const req = createMockRequest({
+        body: { txHex: 123 }
+      })
+      const res = createMockResponse()
+
+      await uut.broadcastTransaction(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+  })
+
+  describe('#getBlockHeaders()', () => {
+    it('should return block headers on success', async () => {
+      const req = createMockRequest({
+        params: { height: '100' },
+        query: { count: '2' }
+      })
+      const res = createMockResponse()
+
+      await uut.getBlockHeaders(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(
+        mockUseCases.fulcrum.getBlockHeaders.calledWithMatch({
+          height: 100,
+          count: 2
+        })
+      )
+    })
+
+    it('should default count to 1', async () => {
+      const req = createMockRequest({
+        params: { height: '100' }
+      })
+      const res = createMockResponse()
+
+      await uut.getBlockHeaders(req, res)
+
+      assert.isTrue(
+        mockUseCases.fulcrum.getBlockHeaders.calledWithMatch({
+          height: 100,
+          count: 1
+        })
+      )
+    })
+
+    it('should return error if height is invalid', async () => {
+      const req = createMockRequest({
+        params: { height: 'invalid' }
+      })
+      const res = createMockResponse()
+
+      await uut.getBlockHeaders(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+  })
+
+  describe('#blockHeadersBulk()', () => {
+    it('should validate heights array and call use case', async () => {
+      const req = createMockRequest({
+        body: { heights: [{ height: 100, count: 2 }] }
+      })
+      const res = createMockResponse()
+
+      await uut.blockHeadersBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.fulcrum.getBlockHeadersBulk.calledOnce)
+    })
+
+    it('should return error if heights is not array', async () => {
+      const req = createMockRequest({
+        body: { heights: 'not-an-array' }
+      })
+      const res = createMockResponse()
+
+      await uut.blockHeadersBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should validate height objects', async () => {
+      const req = createMockRequest({
+        body: { heights: [{ height: 'invalid', count: 2 }] }
+      })
+      const res = createMockResponse()
+
+      await uut.blockHeadersBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+  })
+
+  describe('#getTransactions()', () => {
+    it('should return transactions on success', async () => {
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getTransactions(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.fulcrum.getTransactions.calledOnce)
+    })
+
+    it('should handle allTxs from params', async () => {
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS, allTxs: 'true' }
+      })
+      const res = createMockResponse()
+
+      await uut.getTransactions(req, res)
+
+      assert.isTrue(
+        mockUseCases.fulcrum.getTransactions.calledWithMatch({
+          address: VALID_MAINNET_ADDRESS,
+          allTxs: true
+        })
+      )
+    })
+
+    it('should handle allTxs from query', async () => {
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS },
+        query: { allTxs: 'true' }
+      })
+      const res = createMockResponse()
+
+      await uut.getTransactions(req, res)
+
+      assert.isTrue(
+        mockUseCases.fulcrum.getTransactions.calledWithMatch({
+          allTxs: true
+        })
+      )
+    })
+  })
+
+  describe('#transactionsBulk()', () => {
+    it('should validate addresses and call use case', async () => {
+      const req = createMockRequest({
+        body: { addresses: [VALID_MAINNET_ADDRESS], allTxs: true }
+      })
+      const res = createMockResponse()
+
+      await uut.transactionsBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.fulcrum.getTransactionsBulk.calledOnce)
+    })
+  })
+
+  describe('#getMempool()', () => {
+    it('should return mempool on success', async () => {
+      const req = createMockRequest({
+        params: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getMempool(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { mempool: [] })
+      assert.isTrue(mockUseCases.fulcrum.getMempool.calledOnce)
+    })
+  })
+
+  describe('#mempoolBulk()', () => {
+    it('should validate addresses and call use case', async () => {
+      const req = createMockRequest({
+        body: { addresses: [VALID_MAINNET_ADDRESS] }
+      })
+      const res = createMockResponse()
+
+      await uut.mempoolBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.fulcrum.getMempoolBulk.calledOnce)
+    })
+  })
+
+  describe('#handleError()', () => {
+    it('should handle errors with status', async () => {
+      const error = new Error('test error')
+      error.status = 400
+      const res = createMockResponse()
+
+      uut.handleError(error, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'test error' })
+    })
+
+    it('should default status to 500', async () => {
+      const error = new Error('test error')
+      const res = createMockResponse()
+
+      uut.handleError(error, res)
+
+      assert.equal(res.statusValue, 500)
+      assert.deepEqual(res.jsonData, { error: 'test error' })
+    })
+  })
+})

test/unit/controllers/mining-controller-unit.js

@@ -0,0 +1,139 @@
+/*
+  Unit tests for MiningRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import MiningRESTController from '../../../src/controllers/rest-api/full-node/mining/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#mining-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      mining: {
+        getMiningInfo: sandbox.stub().resolves({ blocks: 100, difficulty: 1.5 }),
+        getNetworkHashPS: sandbox.stub().resolves(1234567890)
+      }
+    }
+
+    uut = new MiningRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new MiningRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require mining use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new MiningRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Mining use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return mining status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'mining' })
+    })
+  })
+
+  describe('#getMiningInfo()', () => {
+    it('should return mining info on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getMiningInfo(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { blocks: 100, difficulty: 1.5 })
+      assert.isTrue(mockUseCases.mining.getMiningInfo.calledOnce)
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('failure')
+      error.status = 503
+      mockUseCases.mining.getMiningInfo.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getMiningInfo(req, res)
+
+      assert.equal(res.statusValue, 503)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+
+  describe('#getNetworkHashPS()', () => {
+    it('should return network hash PS with default params', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getNetworkHashPS(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.equal(res.jsonData, 1234567890)
+      assert.isTrue(mockUseCases.mining.getNetworkHashPS.calledOnce)
+      assert.deepEqual(mockUseCases.mining.getNetworkHashPS.firstCall.args[0], {
+        nblocks: 120,
+        height: -1
+      })
+    })
+
+    it('should parse query params for nblocks and height', async () => {
+      const req = createMockRequest({
+        query: {
+          nblocks: '240',
+          height: '1000'
+        }
+      })
+      const res = createMockResponse()
+
+      await uut.getNetworkHashPS(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.isTrue(mockUseCases.mining.getNetworkHashPS.calledOnce)
+      assert.deepEqual(mockUseCases.mining.getNetworkHashPS.firstCall.args[0], {
+        nblocks: 240,
+        height: 1000
+      })
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('RPC error')
+      error.status = 500
+      mockUseCases.mining.getNetworkHashPS.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getNetworkHashPS(req, res)
+
+      assert.equal(res.statusValue, 500)
+      assert.deepEqual(res.jsonData, { error: 'RPC error' })
+    })
+  })
+})

test/unit/controllers/price-controller-unit.js

@@ -0,0 +1,116 @@
+/*
+  Unit tests for PriceRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import PriceRESTController from '../../../src/controllers/rest-api/price/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#price-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      price: {
+        getBCHUSD: sandbox.stub().resolves(250.5),
+        getPsffppWritePrice: sandbox.stub().resolves(0.08335233)
+      }
+    }
+
+    uut = new PriceRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new PriceRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require price use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new PriceRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Price use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return price status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'price' })
+    })
+  })
+
+  describe('#getBCHUSD()', () => {
+    it('should return BCH USD price on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getBCHUSD(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { usd: 250.5 })
+      assert.isTrue(mockUseCases.price.getBCHUSD.calledOnce)
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('API failure')
+      error.status = 503
+      mockUseCases.price.getBCHUSD.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getBCHUSD(req, res)
+
+      assert.equal(res.statusValue, 503)
+      assert.deepEqual(res.jsonData, { error: 'API failure' })
+    })
+  })
+
+  describe('#getPsffppWritePrice()', () => {
+    it('should return PSFFPP write price on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getPsffppWritePrice(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { writePrice: 0.08335233 })
+      assert.isTrue(mockUseCases.price.getPsffppWritePrice.calledOnce)
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('PSFFPP failure')
+      error.status = 500
+      mockUseCases.price.getPsffppWritePrice.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getPsffppWritePrice(req, res)
+
+      assert.equal(res.statusValue, 500)
+      assert.deepEqual(res.jsonData, { error: 'PSFFPP failure' })
+    })
+  })
+})

test/unit/controllers/rawtransactions-controller-unit.js

@@ -0,0 +1,388 @@
+/*
+  Unit tests for RawTransactionsRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import RawTransactionsRESTController from '../../../src/controllers/rest-api/full-node/rawtransactions/controller.js'
+import { createMockRequest, createMockResponse } from '../mocks/controller-mocks.js'
+
+describe('#rawtransactions-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {
+      fullNode: {
+        validateArraySize: sandbox.stub().returns(true)
+      }
+    }
+    mockUseCases = {
+      rawtransactions: {
+        decodeRawTransaction: sandbox.stub().resolves({ txid: 'abc123' }),
+        decodeRawTransactions: sandbox.stub().resolves([{ txid: 'abc123' }]),
+        decodeScript: sandbox.stub().resolves({ asm: 'OP_DUP' }),
+        decodeScripts: sandbox.stub().resolves([{ asm: 'OP_DUP' }]),
+        getRawTransaction: sandbox.stub().resolves({ txid: 'abc123' }),
+        getRawTransactionWithHeight: sandbox.stub().resolves({ txid: 'abc123', height: 100 }),
+        getRawTransactions: sandbox.stub().resolves([{ txid: 'abc123' }]),
+        sendRawTransaction: sandbox.stub().resolves('txid123'),
+        sendRawTransactions: sandbox.stub().resolves(['txid1', 'txid2'])
+      }
+    }
+
+    uut = new RawTransactionsRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new RawTransactionsRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require rawtransactions use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new RawTransactionsRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /RawTransactions use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return rawtransactions status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'rawtransactions' })
+    })
+  })
+
+  describe('#decodeRawTransactionSingle()', () => {
+    it('should return decoded transaction on success', async () => {
+      const req = createMockRequest({ params: { hex: '01000000' } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { txid: 'abc123' })
+      assert.isTrue(mockUseCases.rawtransactions.decodeRawTransaction.calledOnce)
+      assert.deepEqual(mockUseCases.rawtransactions.decodeRawTransaction.firstCall.args[0], { hex: '01000000' })
+    })
+
+    it('should return 400 if hex is empty', async () => {
+      const req = createMockRequest({ params: { hex: '' } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'hex can not be empty' })
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('RPC error')
+      error.status = 500
+      mockUseCases.rawtransactions.decodeRawTransaction.rejects(error)
+      const req = createMockRequest({ params: { hex: '01000000' } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 500)
+      assert.deepEqual(res.jsonData, { error: 'RPC error' })
+    })
+  })
+
+  describe('#decodeRawTransactionBulk()', () => {
+    it('should return decoded transactions on success', async () => {
+      const req = createMockRequest({ body: { hexes: ['hex1', 'hex2'] } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, [{ txid: 'abc123' }])
+      assert.isTrue(mockUseCases.rawtransactions.decodeRawTransactions.calledOnce)
+    })
+
+    it('should return 400 if hexes is not an array', async () => {
+      const req = createMockRequest({ body: { hexes: 'not-array' } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'hexes must be an array' })
+    })
+
+    it('should return 400 if array is too large', async () => {
+      mockAdapters.fullNode.validateArraySize.returns(false)
+      const req = createMockRequest({ body: { hexes: new Array(25).fill('hex') } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Array too large.' })
+    })
+
+    it('should return 400 if empty hex encountered', async () => {
+      const req = createMockRequest({ body: { hexes: ['hex1', '', 'hex2'] } })
+      const res = createMockResponse()
+
+      await uut.decodeRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Encountered empty hex' })
+    })
+  })
+
+  describe('#decodeScriptSingle()', () => {
+    it('should return decoded script on success', async () => {
+      const req = createMockRequest({ params: { hex: '76a914' } })
+      const res = createMockResponse()
+
+      await uut.decodeScriptSingle(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { asm: 'OP_DUP' })
+      assert.isTrue(mockUseCases.rawtransactions.decodeScript.calledOnce)
+    })
+
+    it('should return 400 if hex is empty', async () => {
+      const req = createMockRequest({ params: { hex: '' } })
+      const res = createMockResponse()
+
+      await uut.decodeScriptSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'hex can not be empty' })
+    })
+  })
+
+  describe('#decodeScriptBulk()', () => {
+    it('should return decoded scripts on success', async () => {
+      const req = createMockRequest({ body: { hexes: ['script1', 'script2'] } })
+      const res = createMockResponse()
+
+      await uut.decodeScriptBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, [{ asm: 'OP_DUP' }])
+    })
+
+    it('should return 400 if array is too large', async () => {
+      mockAdapters.fullNode.validateArraySize.returns(false)
+      const req = createMockRequest({ body: { hexes: new Array(25).fill('script') } })
+      const res = createMockResponse()
+
+      await uut.decodeScriptBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Array too large.' })
+    })
+  })
+
+  describe('#getRawTransactionSingle()', () => {
+    it('should return raw transaction on success', async () => {
+      const req = createMockRequest({ params: { txid: 'a'.repeat(64) }, query: {} })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { txid: 'abc123', height: 100 })
+      assert.isTrue(mockUseCases.rawtransactions.getRawTransactionWithHeight.calledOnce)
+    })
+
+    it('should pass verbose=true when query param is set', async () => {
+      const req = createMockRequest({ params: { txid: 'a'.repeat(64) }, query: { verbose: 'true' } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionSingle(req, res)
+
+      assert.isTrue(mockUseCases.rawtransactions.getRawTransactionWithHeight.calledOnce)
+      assert.deepEqual(mockUseCases.rawtransactions.getRawTransactionWithHeight.firstCall.args[0], {
+        txid: 'a'.repeat(64),
+        verbose: true
+      })
+    })
+
+    it('should return 400 if txid is empty', async () => {
+      const req = createMockRequest({ params: { txid: '' } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'txid can not be empty' })
+    })
+
+    it('should return 400 if txid length is not 64', async () => {
+      const req = createMockRequest({ params: { txid: 'short' } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'parameter 1 must be of length 64 (not 5)' })
+    })
+  })
+
+  describe('#getRawTransactionBulk()', () => {
+    it('should return raw transactions on success', async () => {
+      const req = createMockRequest({
+        body: {
+          txids: ['a'.repeat(64), 'b'.repeat(64)],
+          verbose: true
+        }
+      })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, [{ txid: 'abc123' }])
+      assert.isTrue(mockUseCases.rawtransactions.getRawTransactions.calledOnce)
+      assert.deepEqual(mockUseCases.rawtransactions.getRawTransactions.firstCall.args[0], {
+        txids: ['a'.repeat(64), 'b'.repeat(64)],
+        verbose: true
+      })
+    })
+
+    it('should return 400 if txids is not an array', async () => {
+      const req = createMockRequest({ body: { txids: 'not-array' } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'txids must be an array' })
+    })
+
+    it('should return 400 if array is too large', async () => {
+      mockAdapters.fullNode.validateArraySize.returns(false)
+      const req = createMockRequest({ body: { txids: new Array(25).fill('a'.repeat(64)) } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Array too large.' })
+    })
+
+    it('should return 400 if empty txid encountered', async () => {
+      const req = createMockRequest({ body: { txids: ['a'.repeat(64), ''] } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Encountered empty TXID' })
+    })
+
+    it('should return 400 if txid length is not 64', async () => {
+      const req = createMockRequest({ body: { txids: ['short'] } })
+      const res = createMockResponse()
+
+      await uut.getRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'parameter 1 must be of length 64 (not 5)' })
+    })
+  })
+
+  describe('#sendRawTransactionSingle()', () => {
+    it('should return txid on success', async () => {
+      const req = createMockRequest({ params: { hex: '01000000' } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.equal(res.jsonData, 'txid123')
+      assert.isTrue(mockUseCases.rawtransactions.sendRawTransaction.calledOnce)
+    })
+
+    it('should return 400 if hex is empty', async () => {
+      const req = createMockRequest({ params: { hex: '' } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Encountered empty hex' })
+    })
+
+    it('should return 400 if hex is not a string', async () => {
+      const req = createMockRequest({ params: { hex: 123 } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionSingle(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'hex must be a string' })
+    })
+  })
+
+  describe('#sendRawTransactionBulk()', () => {
+    it('should return txids on success', async () => {
+      const req = createMockRequest({ body: { hexes: ['hex1', 'hex2'] } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, ['txid1', 'txid2'])
+      assert.isTrue(mockUseCases.rawtransactions.sendRawTransactions.calledOnce)
+    })
+
+    it('should return 400 if hexes is not an array', async () => {
+      const req = createMockRequest({ body: { hexes: 'not-array' } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'hex must be an array' })
+    })
+
+    it('should return 400 if array is too large', async () => {
+      mockAdapters.fullNode.validateArraySize.returns(false)
+      const req = createMockRequest({ body: { hexes: new Array(25).fill('hex') } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Array too large.' })
+    })
+
+    it('should return 400 if empty hex encountered', async () => {
+      const req = createMockRequest({ body: { hexes: ['hex1', '', 'hex2'] } })
+      const res = createMockResponse()
+
+      await uut.sendRawTransactionBulk(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Encountered empty hex' })
+    })
+  })
+})

test/unit/controllers/req-controller-unit.js

@@ -1,344 +0,0 @@
-/*
-  Unit tests for ReqRESTControllerLib.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-
-// Mocking data libraries
-import { mockEventsArray } from '../mocks/nostr-relay-mocks.js'
-import {
-  createMockRequestWithParams,
-  createMockResponse
-} from '../mocks/controller-mocks.js'
-
-// Unit under test
-import ReqRESTControllerLib from '../../../src/controllers/rest-api/req/controller.js'
-
-describe('#req-controller.js', () => {
-  let sandbox
-  let mockUseCases
-  let uut
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    // Create mock use cases
-    mockUseCases = {
-      queryEvents: {
-        execute: sandbox.stub()
-      },
-      manageSubscription: {
-        createSubscription: sandbox.stub(),
-        closeSubscription: sandbox.stub()
-      }
-    }
-
-    uut = new ReqRESTControllerLib({
-      adapters: {},
-      useCases: mockUseCases
-    })
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  describe('#queryEvents()', () => {
-    it('should successfully query events with filters as JSON string', async () => {
-      const filters = [{ kinds: [1], limit: 10 }]
-      const filtersJson = JSON.stringify(filters)
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.query = { filters: filtersJson }
-      const res = createMockResponse()
-
-      mockUseCases.queryEvents.execute.resolves(mockEventsArray)
-
-      await uut.queryEvents(req, res)
-
-      // Assert use case was called with parsed filters
-      assert.isTrue(mockUseCases.queryEvents.execute.calledOnce)
-      const executeArgs = mockUseCases.queryEvents.execute.getCall(0).args
-      assert.deepEqual(executeArgs[0], filters)
-      assert.equal(executeArgs[1], 'test-sub-123')
-
-      // Assert response
-      assert.equal(res.statusValue, 200)
-      assert.isArray(res.jsonData)
-      assert.equal(res.jsonData.length, mockEventsArray.length)
-    })
-
-    it('should successfully query events with individual query params', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.query = {
-        kinds: JSON.stringify([1]),
-        authors: JSON.stringify(['abc123']),
-        limit: '10'
-      }
-      const res = createMockResponse()
-
-      mockUseCases.queryEvents.execute.resolves(mockEventsArray)
-
-      await uut.queryEvents(req, res)
-
-      // Assert use case was called
-      assert.isTrue(mockUseCases.queryEvents.execute.calledOnce)
-      const executeArgs = mockUseCases.queryEvents.execute.getCall(0).args
-      assert.isArray(executeArgs[0])
-      assert.equal(executeArgs[0][0].kinds[0], 1)
-      assert.equal(executeArgs[0][0].authors[0], 'abc123')
-      assert.equal(executeArgs[0][0].limit, 10)
-    })
-
-    it('should handle empty filters', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.query = {}
-      const res = createMockResponse()
-
-      mockUseCases.queryEvents.execute.resolves([])
-
-      await uut.queryEvents(req, res)
-
-      // Assert use case was called with empty filters array
-      assert.isTrue(mockUseCases.queryEvents.execute.calledOnce)
-      const executeArgs = mockUseCases.queryEvents.execute.getCall(0).args
-      assert.deepEqual(executeArgs[0], [{}])
-    })
-
-    it('should return 400 when subscription ID is missing', async () => {
-      const req = createMockRequestWithParams({})
-      const res = createMockResponse()
-
-      await uut.queryEvents(req, res)
-
-      // Assert use case was not called
-      assert.isFalse(mockUseCases.queryEvents.execute.called)
-
-      // Assert error response
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Subscription ID is required')
-    })
-
-    it('should return 400 when filters JSON is invalid', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.query = { filters: 'invalid-json{' }
-      const res = createMockResponse()
-
-      await uut.queryEvents(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Invalid filters JSON')
-    })
-
-    it('should handle use case errors', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.query = { filters: JSON.stringify([{ kinds: [1] }]) }
-      const res = createMockResponse()
-
-      mockUseCases.queryEvents.execute.rejects(new Error('Query failed'))
-
-      await uut.queryEvents(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 500)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Query failed')
-    })
-  })
-
-  describe('#createSubscription()', () => {
-    it('should successfully create SSE subscription', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.body = { kinds: [1] }
-      const res = createMockResponse()
-
-      mockUseCases.manageSubscription.createSubscription.resolves()
-
-      await uut.createSubscription(req, res)
-
-      // Assert use case was called
-      assert.isTrue(mockUseCases.manageSubscription.createSubscription.calledOnce)
-      const createArgs = mockUseCases.manageSubscription.createSubscription.getCall(0).args
-      assert.equal(createArgs[0], 'test-sub-123')
-      assert.isArray(createArgs[1])
-      assert.equal(createArgs[1][0].kinds[0], 1)
-      assert.isFunction(createArgs[2]) // onEvent
-      assert.isFunction(createArgs[3]) // onEose
-      assert.isFunction(createArgs[4]) // onClosed
-
-      // Assert SSE headers
-      assert.equal(res.headers['Content-Type'], 'text/event-stream')
-      assert.equal(res.headers['Cache-Control'], 'no-cache')
-      assert.equal(res.headers.Connection, 'keep-alive')
-
-      // Assert initial connection message was written
-      assert.isTrue(res.writeData.length > 0)
-    })
-
-    it('should return 400 when subscription ID is missing', async () => {
-      const req = createMockRequestWithParams({})
-      req.body = { kinds: [1] }
-      const res = createMockResponse()
-
-      await uut.createSubscription(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Subscription ID is required')
-    })
-
-    it('should return 400 when filters are missing', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.body = {}
-      const res = createMockResponse()
-
-      await uut.createSubscription(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Filters are required')
-    })
-
-    it('should handle filters as array', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.body = [{ kinds: [1] }, { kinds: [3] }]
-      const res = createMockResponse()
-
-      mockUseCases.manageSubscription.createSubscription.resolves()
-
-      await uut.createSubscription(req, res)
-
-      // Assert filters array was passed correctly
-      const createArgs = mockUseCases.manageSubscription.createSubscription.getCall(0).args
-      assert.isArray(createArgs[1])
-      assert.equal(createArgs[1].length, 2)
-    })
-
-    it('should handle client disconnect', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.body = { kinds: [1] }
-      req.on = sinon.stub()
-      const res = createMockResponse()
-
-      mockUseCases.manageSubscription.createSubscription.resolves()
-      mockUseCases.manageSubscription.closeSubscription.resolves()
-
-      await uut.createSubscription(req, res)
-
-      // Assert close handler was set up
-      assert.isTrue(req.on.calledWith('close'))
-
-      // Simulate client disconnect
-      const closeCallback = req.on.getCall(0).args[1]
-      await closeCallback()
-
-      // Assert closeSubscription was called
-      assert.isTrue(mockUseCases.manageSubscription.closeSubscription.calledOnce)
-      assert.equal(mockUseCases.manageSubscription.closeSubscription.getCall(0).args[0], 'test-sub-123')
-    })
-  })
-
-  describe('#closeSubscription()', () => {
-    it('should successfully close a subscription', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      const res = createMockResponse()
-
-      mockUseCases.manageSubscription.closeSubscription.resolves()
-
-      await uut.closeSubscription(req, res)
-
-      // Assert use case was called
-      assert.isTrue(mockUseCases.manageSubscription.closeSubscription.calledOnce)
-      assert.equal(mockUseCases.manageSubscription.closeSubscription.getCall(0).args[0], 'test-sub-123')
-
-      // Assert response
-      assert.equal(res.statusValue, 200)
-      assert.property(res.jsonData, 'message')
-      assert.include(res.jsonData.message, 'closed successfully')
-    })
-
-    it('should return 400 when subscription ID is missing', async () => {
-      const req = createMockRequestWithParams({})
-      const res = createMockResponse()
-
-      await uut.closeSubscription(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 400)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Subscription ID is required')
-    })
-
-    it('should handle use case errors', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      const res = createMockResponse()
-
-      mockUseCases.manageSubscription.closeSubscription.rejects(new Error('Relay connection error'))
-
-      await uut.closeSubscription(req, res)
-
-      // Assert error response
-      assert.equal(res.statusValue, 500)
-      assert.property(res.jsonData, 'error')
-      assert.include(res.jsonData.error, 'Relay connection error')
-    })
-
-    it('should handle idempotent close (subscription already closed)', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      const res = createMockResponse()
-
-      // closeSubscription resolves successfully even if subscription doesn't exist
-      mockUseCases.manageSubscription.closeSubscription.resolves()
-
-      await uut.closeSubscription(req, res)
-
-      // Assert success response even for already-closed subscription
-      assert.equal(res.statusValue, 200)
-      assert.property(res.jsonData, 'message')
-      assert.include(res.jsonData.message, 'closed successfully')
-    })
-  })
-
-  describe('#createSubscriptionPut()', () => {
-    it('should call createSubscription', async () => {
-      const req = createMockRequestWithParams({ subId: 'test-sub-123' })
-      req.body = { kinds: [1] }
-      const res = createMockResponse()
-
-      mockUseCases.manageSubscription.createSubscription.resolves()
-
-      await uut.createSubscriptionPut(req, res)
-
-      // Assert createSubscription was called
-      assert.isTrue(mockUseCases.manageSubscription.createSubscription.calledOnce)
-    })
-  })
-
-  describe('#constructor()', () => {
-    it('should require adapters instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new ReqRESTControllerLib({ useCases: mockUseCases })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Adapters library required')
-      }
-    })
-
-    it('should require useCases instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new ReqRESTControllerLib({ adapters: {} })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Use Cases library required')
-      }
-    })
-  })
-})

test/unit/controllers/rest-api-index-unit.js

@@ -0,0 +1,163 @@
+/*
+  Unit tests for RESTControllers index.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import RESTControllers from '../../../src/controllers/rest-api/index.js'
+import BlockchainRouter from '../../../src/controllers/rest-api/full-node/blockchain/router.js'
+import ControlRouter from '../../../src/controllers/rest-api/full-node/control/router.js'
+import DSProofRouter from '../../../src/controllers/rest-api/full-node/dsproof/router.js'
+import MiningRouter from '../../../src/controllers/rest-api/full-node/mining/router.js'
+import PriceRouter from '../../../src/controllers/rest-api/price/router.js'
+import RawTransactionsRouter from '../../../src/controllers/rest-api/full-node/rawtransactions/router.js'
+import FulcrumRouter from '../../../src/controllers/rest-api/fulcrum/router.js'
+import SlpRouter from '../../../src/controllers/rest-api/slp/router.js'
+
+describe('#controllers/rest-api/index.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+
+  const createBlockchainUseCaseStubs = () => ({
+    getBestBlockHash: () => {},
+    getBlockchainInfo: () => {},
+    getBlockCount: () => {},
+    getBlockHeader: () => {},
+    getBlockHeaders: () => {},
+    getChainTips: () => {},
+    getDifficulty: () => {},
+    getMempoolEntry: () => {},
+    getMempoolEntries: () => {},
+    getMempoolAncestors: () => {},
+    getMempoolInfo: () => {},
+    getRawMempool: () => {},
+    getTxOut: () => {},
+    getTxOutProof: () => {},
+    getTxOutProofs: () => {},
+    verifyTxOutProof: () => {},
+    verifyTxOutProofs: () => {},
+    getBlock: () => {},
+    getBlockHash: () => {}
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {
+      fullNode: {
+        validateArraySize: sandbox.stub().returns(true)
+      }
+    }
+    mockUseCases = {
+      blockchain: createBlockchainUseCaseStubs(),
+      control: {
+        getNetworkInfo: () => {}
+      },
+      dsproof: {
+        getDSProof: () => {}
+      },
+      fulcrum: {
+        getBalance: () => {},
+        getBalances: () => {},
+        getUtxos: () => {},
+        getUtxosBulk: () => {},
+        getTransactionDetails: () => {},
+        getTransactionDetailsBulk: () => {},
+        broadcastTransaction: () => {},
+        getBlockHeaders: () => {},
+        getBlockHeadersBulk: () => {},
+        getTransactions: () => {},
+        getTransactionsBulk: () => {},
+        getMempool: () => {},
+        getMempoolBulk: () => {}
+      },
+      mining: {
+        getMiningInfo: () => {},
+        getNetworkHashPS: () => {}
+      },
+      price: {
+        getBCHUSD: () => {},
+        getPsffppWritePrice: () => {}
+      },
+      rawtransactions: {
+        decodeRawTransaction: () => {},
+        decodeRawTransactions: () => {},
+        decodeScript: () => {},
+        decodeScripts: () => {},
+        getRawTransaction: () => {},
+        getRawTransactionWithHeight: () => {},
+        getRawTransactions: () => {},
+        sendRawTransaction: () => {},
+        sendRawTransactions: () => {}
+      },
+      slp: {
+        getStatus: () => {},
+        getAddress: () => {},
+        getTxid: () => {},
+        getTokenStats: () => {},
+        getTokenData: () => {},
+        getMutableCid: () => {},
+        decodeOpReturn: () => {},
+        getCIDData: () => {}
+      }
+    }
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters instance', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new RESTControllers({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require useCases instance', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new RESTControllers({ adapters: mockAdapters })
+      }, /Use Cases library required/)
+    })
+  })
+
+  describe('#attachRESTControllers()', () => {
+    it('should instantiate routers and attach to app', () => {
+      const blockchainAttachStub = sandbox.stub(BlockchainRouter.prototype, 'attach')
+      const controlAttachStub = sandbox.stub(ControlRouter.prototype, 'attach')
+      const dsproofAttachStub = sandbox.stub(DSProofRouter.prototype, 'attach')
+      const fulcrumAttachStub = sandbox.stub(FulcrumRouter.prototype, 'attach')
+      const miningAttachStub = sandbox.stub(MiningRouter.prototype, 'attach')
+      const priceAttachStub = sandbox.stub(PriceRouter.prototype, 'attach')
+      const rawtransactionsAttachStub = sandbox.stub(RawTransactionsRouter.prototype, 'attach')
+      const slpAttachStub = sandbox.stub(SlpRouter.prototype, 'attach')
+      const restControllers = new RESTControllers({
+        adapters: mockAdapters,
+        useCases: mockUseCases
+      })
+      const app = {}
+
+      restControllers.attachRESTControllers(app)
+
+      assert.isTrue(blockchainAttachStub.calledOnce)
+      assert.equal(blockchainAttachStub.getCall(0).args[0], app)
+      assert.isTrue(controlAttachStub.calledOnce)
+      assert.equal(controlAttachStub.getCall(0).args[0], app)
+      assert.isTrue(dsproofAttachStub.calledOnce)
+      assert.equal(dsproofAttachStub.getCall(0).args[0], app)
+      assert.isTrue(fulcrumAttachStub.calledOnce)
+      assert.equal(fulcrumAttachStub.getCall(0).args[0], app)
+      assert.isTrue(miningAttachStub.calledOnce)
+      assert.equal(miningAttachStub.getCall(0).args[0], app)
+      assert.isTrue(priceAttachStub.calledOnce)
+      assert.equal(priceAttachStub.getCall(0).args[0], app)
+      assert.isTrue(rawtransactionsAttachStub.calledOnce)
+      assert.equal(rawtransactionsAttachStub.getCall(0).args[0], app)
+      assert.isTrue(slpAttachStub.calledOnce)
+      assert.equal(slpAttachStub.getCall(0).args[0], app)
+    })
+  })
+})

test/unit/controllers/slp-controller-unit.js

@@ -0,0 +1,312 @@
+/*
+  Unit tests for SlpRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import SlpRESTController from '../../../src/controllers/rest-api/slp/controller.js'
+import {
+  createMockRequest,
+  createMockResponse
+} from '../mocks/controller-mocks.js'
+
+// Valid mainnet cash address for testing
+const VALID_MAINNET_ADDRESS = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+
+describe('#slp-controller.js', () => {
+  let sandbox
+  let mockUseCases
+  let mockAdapters
+  let uut
+
+  const createSlpUseCaseStubs = () => ({
+    getStatus: sandbox.stub().resolves({ status: 'ok' }),
+    getAddress: sandbox.stub().resolves({ balance: 1000 }),
+    getTxid: sandbox.stub().resolves({ txid: 'abc' }),
+    getTokenStats: sandbox.stub().resolves({ tokenData: {} }),
+    getTokenData: sandbox.stub().resolves({ genesisData: {}, immutableData: '', mutableData: '' })
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      slp: createSlpUseCaseStubs()
+    }
+
+    uut = new SlpRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new SlpRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require slp use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new SlpRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /SLP use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return service status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'psf-slp-indexer' })
+    })
+  })
+
+  describe('#getStatus()', () => {
+    it('should return status on success', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getStatus(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'ok' })
+      assert.isTrue(mockUseCases.slp.getStatus.calledOnce)
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('failure')
+      error.status = 503
+      mockUseCases.slp.getStatus.rejects(error)
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.getStatus(req, res)
+
+      assert.equal(res.statusValue, 503)
+      assert.deepEqual(res.jsonData, { error: 'failure' })
+    })
+  })
+
+  describe('#getAddress()', () => {
+    it('should return address balance on success', async () => {
+      const req = createMockRequest({
+        body: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getAddress(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { balance: 1000 })
+      assert.isTrue(mockUseCases.slp.getAddress.calledOnce)
+    })
+
+    it('should return error if address is empty', async () => {
+      const req = createMockRequest({
+        body: { address: '' }
+      })
+      const res = createMockResponse()
+
+      await uut.getAddress(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+      assert.include(res.jsonData.error, 'can not be empty')
+    })
+
+    it('should return error if address is missing', async () => {
+      const req = createMockRequest({
+        body: {}
+      })
+      const res = createMockResponse()
+
+      await uut.getAddress(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('Invalid address')
+      error.status = 400
+      mockUseCases.slp.getAddress.rejects(error)
+      const req = createMockRequest({
+        body: { address: VALID_MAINNET_ADDRESS }
+      })
+      const res = createMockResponse()
+
+      await uut.getAddress(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, { error: 'Invalid address' })
+    })
+  })
+
+  describe('#getTxid()', () => {
+    it('should return transaction data on success', async () => {
+      const req = createMockRequest({
+        body: { txid: 'a'.repeat(64) }
+      })
+      const res = createMockResponse()
+
+      await uut.getTxid(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { txid: 'abc' })
+      assert.isTrue(mockUseCases.slp.getTxid.calledOnce)
+    })
+
+    it('should return error if txid is empty', async () => {
+      const req = createMockRequest({
+        body: { txid: '' }
+      })
+      const res = createMockResponse()
+
+      await uut.getTxid(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+      assert.include(res.jsonData.error, 'can not be empty')
+    })
+
+    it('should return error if txid is not 64 characters', async () => {
+      const req = createMockRequest({
+        body: { txid: 'abc' }
+      })
+      const res = createMockResponse()
+
+      await uut.getTxid(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+      assert.include(res.jsonData.error, 'not a txid')
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('Transaction not found')
+      error.status = 404
+      mockUseCases.slp.getTxid.rejects(error)
+      const req = createMockRequest({
+        body: { txid: 'a'.repeat(64) }
+      })
+      const res = createMockResponse()
+
+      await uut.getTxid(req, res)
+
+      assert.equal(res.statusValue, 404)
+      assert.deepEqual(res.jsonData, { error: 'Transaction not found' })
+    })
+  })
+
+  describe('#getTokenStats()', () => {
+    it('should return token stats on success', async () => {
+      const req = createMockRequest({
+        body: { tokenId: 'a'.repeat(64) }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenStats(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { tokenData: {} })
+      assert.isTrue(mockUseCases.slp.getTokenStats.calledOnce)
+    })
+
+    it('should pass withTxHistory flag', async () => {
+      const req = createMockRequest({
+        body: { tokenId: 'a'.repeat(64), withTxHistory: true }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenStats(req, res)
+
+      assert.isTrue(mockUseCases.slp.getTokenStats.calledWith({
+        tokenId: 'a'.repeat(64),
+        withTxHistory: true
+      }))
+    })
+
+    it('should return error if tokenId is empty', async () => {
+      const req = createMockRequest({
+        body: { tokenId: '' }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenStats(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('Token not found')
+      error.status = 404
+      mockUseCases.slp.getTokenStats.rejects(error)
+      const req = createMockRequest({
+        body: { tokenId: 'a'.repeat(64) }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenStats(req, res)
+
+      assert.equal(res.statusValue, 404)
+      assert.deepEqual(res.jsonData, { error: 'Token not found' })
+    })
+  })
+
+  describe('#getTokenData()', () => {
+    it('should return token data on success', async () => {
+      const req = createMockRequest({
+        body: { tokenId: 'a'.repeat(64) }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenData(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.property(res.jsonData, 'genesisData')
+      assert.property(res.jsonData, 'immutableData')
+      assert.property(res.jsonData, 'mutableData')
+      assert.isTrue(mockUseCases.slp.getTokenData.calledOnce)
+    })
+
+    it('should return error if tokenId is empty', async () => {
+      const req = createMockRequest({
+        body: { tokenId: '' }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenData(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.property(res.jsonData, 'error')
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('Token data not found')
+      error.status = 404
+      mockUseCases.slp.getTokenData.rejects(error)
+      const req = createMockRequest({
+        body: { tokenId: 'a'.repeat(64) }
+      })
+      const res = createMockResponse()
+
+      await uut.getTokenData(req, res)
+
+      assert.equal(res.statusValue, 404)
+      assert.deepEqual(res.jsonData, { error: 'Token data not found' })
+    })
+  })
+})

test/unit/entities/event-unit.js

@@ -1,139 +0,0 @@
-/*
-  Unit tests for the Event entity.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Mocking data libraries
-import {
-  mockKind0Event,
-  mockKind1Event,
-  mockKind3Event,
-  mockKind7Event,
-  mockInvalidEventMissingId,
-  mockInvalidEventWrongIdLength,
-  mockInvalidEventMissingPubkey,
-  mockInvalidEventWrongPubkeyLength,
-  mockInvalidEventMissingCreatedAt,
-  mockInvalidEventWrongCreatedAtType,
-  mockInvalidEventMissingKind,
-  mockInvalidEventKindOutOfRange,
-  mockInvalidEventMissingSig,
-  mockInvalidEventWrongSigLength,
-  mockInvalidEventTagsNotArray
-} from '../mocks/event-mocks.js'
-
-// Unit under test
-import Event from '../../../src/entities/event.js'
-
-describe('#event.js', () => {
-  describe('#isValid()', () => {
-    it('should return true for valid kind 0 event', () => {
-      const event = new Event(mockKind0Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return true for valid kind 1 event', () => {
-      const event = new Event(mockKind1Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return true for valid kind 3 event', () => {
-      const event = new Event(mockKind3Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return true for valid kind 7 event', () => {
-      const event = new Event(mockKind7Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return false for event missing id', () => {
-      const event = new Event(mockInvalidEventMissingId)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong id length', () => {
-      const event = new Event(mockInvalidEventWrongIdLength)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing pubkey', () => {
-      const event = new Event(mockInvalidEventMissingPubkey)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong pubkey length', () => {
-      const event = new Event(mockInvalidEventWrongPubkeyLength)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing created_at', () => {
-      const event = new Event(mockInvalidEventMissingCreatedAt)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong created_at type', () => {
-      const event = new Event(mockInvalidEventWrongCreatedAtType)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing kind', () => {
-      const event = new Event(mockInvalidEventMissingKind)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with kind out of range', () => {
-      const event = new Event(mockInvalidEventKindOutOfRange)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing sig', () => {
-      const event = new Event(mockInvalidEventMissingSig)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong sig length', () => {
-      const event = new Event(mockInvalidEventWrongSigLength)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with tags not an array', () => {
-      const event = new Event(mockInvalidEventTagsNotArray)
-      assert.isFalse(event.isValid())
-    })
-  })
-
-  describe('#toJSON()', () => {
-    it('should serialize event to JSON correctly', () => {
-      const event = new Event(mockKind1Event)
-      const json = event.toJSON()
-
-      assert.property(json, 'id')
-      assert.property(json, 'pubkey')
-      assert.property(json, 'created_at')
-      assert.property(json, 'kind')
-      assert.property(json, 'tags')
-      assert.property(json, 'content')
-      assert.property(json, 'sig')
-
-      assert.equal(json.id, mockKind1Event.id)
-      assert.equal(json.pubkey, mockKind1Event.pubkey)
-      assert.equal(json.created_at, mockKind1Event.created_at)
-      assert.equal(json.kind, mockKind1Event.kind)
-      assert.deepEqual(json.tags, mockKind1Event.tags)
-      assert.equal(json.content, mockKind1Event.content)
-      assert.equal(json.sig, mockKind1Event.sig)
-    })
-
-    it('should serialize event with tags correctly', () => {
-      const event = new Event(mockKind3Event)
-      const json = event.toJSON()
-
-      assert.isArray(json.tags)
-      assert.equal(json.tags.length, 1)
-      assert.deepEqual(json.tags, mockKind3Event.tags)
-    })
-  })
-})

test/unit/mocks/nostr-relay-mocks.js

@@ -1,58 +0,0 @@
-/*
-  Mock responses from Nostr relay for unit tests.
-  Contains mock messages that would come from a Nostr relay WebSocket.
-*/
-
-import { mockKind1Event, validEventId } from './event-mocks.js'
-
-// Mock OK response (event accepted)
-const mockOkAccepted = ['OK', validEventId, true, 'event saved']
-
-// Mock OK response (event rejected)
-const mockOkRejected = ['OK', validEventId, false, 'duplicate: event already exists']
-
-// Mock EVENT message (from relay)
-const mockEventMessage = ['EVENT', 'subscription-id-123', mockKind1Event]
-
-// Mock EOSE message (end of stored events)
-const mockEoseMessage = ['EOSE', 'subscription-id-123']
-
-// Mock CLOSED message
-const mockClosedMessage = ['CLOSED', 'subscription-id-123', 'subscription closed']
-
-// Mock NOTICE message
-const mockNoticeMessage = ['NOTICE', 'rate limited: slow down']
-
-// Mock successful sendEvent response
-const mockSendEventSuccess = {
-  accepted: true,
-  message: 'event saved'
-}
-
-// Mock failed sendEvent response
-const mockSendEventFailure = {
-  accepted: false,
-  message: 'duplicate: event already exists'
-}
-
-// Mock events array for query tests
-const mockEventsArray = [
-  mockKind1Event,
-  {
-    ...mockKind1Event,
-    id: 'b'.repeat(64),
-    content: 'Another test message'
-  }
-]
-
-export {
-  mockOkAccepted,
-  mockOkRejected,
-  mockEventMessage,
-  mockEoseMessage,
-  mockClosedMessage,
-  mockNoticeMessage,
-  mockSendEventSuccess,
-  mockSendEventFailure,
-  mockEventsArray
-}

test/unit/use-cases/fulcrum-use-cases-unit.js

@@ -0,0 +1,297 @@
+/*
+  Unit tests for FulcrumUseCases.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+import BCHJS from '@psf/bch-js'
+
+import FulcrumUseCases from '../../../src/use-cases/fulcrum-use-cases.js'
+
+describe('#fulcrum-use-cases.js', () => {
+  let sandbox
+  let mockAdapters
+  let uut
+  let sortAllTxsStub
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {
+      fulcrum: {
+        get: sandbox.stub().resolves({}),
+        post: sandbox.stub().resolves({})
+      }
+    }
+
+    // Create a mock BCHJS instance with stubbed sortAllTxs method
+    const mockBchjs = new BCHJS()
+    if (!mockBchjs.Electrumx) {
+      mockBchjs.Electrumx = {}
+    }
+
+    // Create a stub that sorts transactions
+    sortAllTxsStub = sandbox.stub(mockBchjs.Electrumx, 'sortAllTxs')
+    sortAllTxsStub.callsFake(async (txs, order) => {
+      const sorted = [...txs].sort((a, b) => {
+        if (order === 'DESCENDING') {
+          return (b.height || 0) - (a.height || 0)
+        }
+        return (a.height || 0) - (b.height || 0)
+      })
+      return sorted
+    })
+
+    // Inject the mocked bchjs instance into the use cases
+    uut = new FulcrumUseCases({ adapters: mockAdapters, bchjs: mockBchjs })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new FulcrumUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require fulcrum adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new FulcrumUseCases({ adapters: {} })
+      }, /Fulcrum adapter required/)
+    })
+  })
+
+  describe('#getBalance()', () => {
+    it('should call fulcrum adapter get method', async () => {
+      const address = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      mockAdapters.fulcrum.get.resolves({ balance: 1000 })
+
+      const result = await uut.getBalance({ address })
+
+      assert.isTrue(mockAdapters.fulcrum.get.calledOnceWith(`electrumx/balance/${address}`))
+      assert.deepEqual(result, { balance: 1000 })
+    })
+  })
+
+  describe('#getBalances()', () => {
+    it('should call fulcrum adapter post method', async () => {
+      const addresses = ['bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf']
+      mockAdapters.fulcrum.post.resolves({ balances: [] })
+
+      const result = await uut.getBalances({ addresses })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/balance/', { addresses })
+      )
+      assert.deepEqual(result, { balances: [] })
+    })
+  })
+
+  describe('#getUtxos()', () => {
+    it('should call fulcrum adapter get method', async () => {
+      const address = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      mockAdapters.fulcrum.get.resolves({ utxos: [] })
+
+      const result = await uut.getUtxos({ address })
+
+      assert.isTrue(mockAdapters.fulcrum.get.calledOnceWith(`electrumx/utxos/${address}`))
+      assert.deepEqual(result, { utxos: [] })
+    })
+  })
+
+  describe('#getUtxosBulk()', () => {
+    it('should call fulcrum adapter post method', async () => {
+      const addresses = ['bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf']
+      mockAdapters.fulcrum.post.resolves({ utxos: [] })
+
+      const result = await uut.getUtxosBulk({ addresses })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/utxos/', { addresses })
+      )
+      assert.deepEqual(result, { utxos: [] })
+    })
+  })
+
+  describe('#getTransactionDetails()', () => {
+    it('should call fulcrum adapter get method', async () => {
+      const txid = 'a'.repeat(64)
+      mockAdapters.fulcrum.get.resolves({ txid })
+
+      const result = await uut.getTransactionDetails({ txid })
+
+      assert.isTrue(mockAdapters.fulcrum.get.calledOnceWith(`electrumx/tx/data/${txid}`))
+      assert.deepEqual(result, { txid })
+    })
+  })
+
+  describe('#getTransactionDetailsBulk()', () => {
+    it('should call fulcrum adapter post method with verbose', async () => {
+      const txids = ['a'.repeat(64)]
+      const verbose = true
+      mockAdapters.fulcrum.post.resolves({ transactions: [] })
+
+      const result = await uut.getTransactionDetailsBulk({ txids, verbose })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/tx/data', { txids, verbose })
+      )
+      assert.deepEqual(result, { transactions: [] })
+    })
+  })
+
+  describe('#broadcastTransaction()', () => {
+    it('should call fulcrum adapter post method', async () => {
+      const txHex = '010203'
+      mockAdapters.fulcrum.post.resolves({ txid: 'abc' })
+
+      const result = await uut.broadcastTransaction({ txHex })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/tx/broadcast', { txHex })
+      )
+      assert.deepEqual(result, { txid: 'abc' })
+    })
+  })
+
+  describe('#getBlockHeaders()', () => {
+    it('should call fulcrum adapter get method with height and count', async () => {
+      const height = 100
+      const count = 2
+      mockAdapters.fulcrum.get.resolves({ headers: [] })
+
+      const result = await uut.getBlockHeaders({ height, count })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.get.calledOnceWith(`electrumx/block/headers/${height}?count=${count}`)
+      )
+      assert.deepEqual(result, { headers: [] })
+    })
+  })
+
+  describe('#getBlockHeadersBulk()', () => {
+    it('should call fulcrum adapter post method', async () => {
+      const heights = [{ height: 100, count: 2 }]
+      mockAdapters.fulcrum.post.resolves({ headers: [] })
+
+      const result = await uut.getBlockHeadersBulk({ heights })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/block/headers', { heights })
+      )
+      assert.deepEqual(result, { headers: [] })
+    })
+  })
+
+  describe('#getTransactions()', () => {
+    it('should call fulcrum adapter and sort transactions when allTxs is false', async () => {
+      const address = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      const allTxs = false
+      const mockTransactions = [
+        { tx_hash: 'aaa', height: 100 },
+        { tx_hash: 'bbb', height: 200 },
+        { tx_hash: 'ccc', height: 150 }
+      ]
+      mockAdapters.fulcrum.get.resolves({
+        transactions: mockTransactions
+      })
+
+      const result = await uut.getTransactions({ address, allTxs })
+
+      assert.isTrue(mockAdapters.fulcrum.get.calledOnceWith(`electrumx/transactions/${address}`))
+      assert.property(result, 'transactions')
+      // Transactions should be sorted and limited to 100
+      if (result.transactions && result.transactions.length > 100) {
+        assert.isAtMost(result.transactions.length, 100)
+      }
+    })
+
+    it('should return all transactions when allTxs is true', async () => {
+      const address = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      const allTxs = true
+      const mockTransactions = Array(150).fill({ tx_hash: 'aaa', height: 100 })
+      mockAdapters.fulcrum.get.resolves({
+        transactions: mockTransactions
+      })
+
+      const result = await uut.getTransactions({ address, allTxs })
+
+      assert.property(result, 'transactions')
+      // All transactions should be returned when allTxs is true
+      assert.equal(result.transactions.length, 150)
+    })
+  })
+
+  describe('#getTransactionsBulk()', () => {
+    it('should call fulcrum adapter and sort transactions for each address', async () => {
+      const addresses = ['bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf']
+      const allTxs = false
+      const mockResponse = {
+        transactions: [
+          {
+            transactions: [
+              { tx_hash: 'aaa', height: 100 },
+              { tx_hash: 'bbb', height: 200 }
+            ]
+          }
+        ]
+      }
+      mockAdapters.fulcrum.post.resolves(mockResponse)
+
+      const result = await uut.getTransactionsBulk({ addresses, allTxs })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/transactions/', { addresses })
+      )
+      assert.property(result, 'transactions')
+    })
+
+    it('should limit to 100 transactions when allTxs is false', async () => {
+      const addresses = ['bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf']
+      const allTxs = false
+      const mockTransactions = Array(150).fill({ tx_hash: 'aaa', height: 100 })
+      const mockResponse = {
+        transactions: [
+          {
+            transactions: mockTransactions
+          }
+        ]
+      }
+      mockAdapters.fulcrum.post.resolves(mockResponse)
+
+      const result = await uut.getTransactionsBulk({ addresses, allTxs })
+
+      assert.isAtMost(result.transactions[0].transactions.length, 100)
+    })
+  })
+
+  describe('#getMempool()', () => {
+    it('should call fulcrum adapter get method', async () => {
+      const address = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      mockAdapters.fulcrum.get.resolves({ mempool: [] })
+
+      const result = await uut.getMempool({ address })
+
+      assert.isTrue(mockAdapters.fulcrum.get.calledOnceWith(`electrumx/unconfirmed/${address}`))
+      assert.deepEqual(result, { mempool: [] })
+    })
+  })
+
+  describe('#getMempoolBulk()', () => {
+    it('should call fulcrum adapter post method', async () => {
+      const addresses = ['bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf']
+      mockAdapters.fulcrum.post.resolves({ mempool: [] })
+
+      const result = await uut.getMempoolBulk({ addresses })
+
+      assert.isTrue(
+        mockAdapters.fulcrum.post.calledOnceWith('electrumx/unconfirmed/', { addresses })
+      )
+      assert.deepEqual(result, { mempool: [] })
+    })
+  })
+})

test/unit/use-cases/full-node-blockchain-use-cases-unit.js

@@ -0,0 +1,137 @@
+/*
+  Unit tests for BlockchainUseCases.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import BlockchainUseCases from '../../../src/use-cases/full-node-blockchain-use-cases.js'
+
+describe('#full-node-blockchain-use-cases.js', () => {
+  let sandbox
+  let mockAdapters
+  let uut
+
+  const createAdapters = () => {
+    return {
+      fullNode: {
+        call: sandbox.stub()
+      }
+    }
+  }
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = createAdapters()
+    uut = new BlockchainUseCases({ adapters: mockAdapters })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new BlockchainUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new BlockchainUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getBestBlockHash()', () => {
+    it('should call full node adapter without parameters', async () => {
+      mockAdapters.fullNode.call.resolves('hash')
+
+      const result = await uut.getBestBlockHash()
+
+      assert.equal(result, 'hash')
+      assert.isTrue(mockAdapters.fullNode.call.calledOnceWithExactly('getbestblockhash'))
+    })
+  })
+
+  describe('#getBlockHeaders()', () => {
+    it('should call adapter for each hash and return aggregated result', async () => {
+      const hashes = ['a'.repeat(64), 'b'.repeat(64)]
+      mockAdapters.fullNode.call
+        .onFirstCall().resolves('header-1')
+        .onSecondCall().resolves('header-2')
+
+      const result = await uut.getBlockHeaders({ hashes, verbose: true })
+
+      assert.deepEqual(result, ['header-1', 'header-2'])
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledWithExactly(
+          'getblockheader',
+          [hashes[0], true],
+          `getblockheader-${hashes[0]}`
+        )
+      )
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledWithExactly(
+          'getblockheader',
+          [hashes[1], true],
+          `getblockheader-${hashes[1]}`
+        )
+      )
+    })
+
+    it('should rethrow errors from adapter', async () => {
+      const hashes = ['a'.repeat(64)]
+      mockAdapters.fullNode.call.rejects(new Error('failure'))
+
+      try {
+        await uut.getBlockHeaders({ hashes })
+        assert.fail('Unexpected success')
+      } catch (err) {
+        assert.equal(err.message, 'failure')
+      }
+    })
+  })
+
+  describe('#getTxOut()', () => {
+    it('should pass parameters to full node call', async () => {
+      mockAdapters.fullNode.call.resolves({ value: 1 })
+
+      const result = await uut.getTxOut({
+        txid: 'txid',
+        n: 0,
+        includeMempool: true
+      })
+
+      assert.deepEqual(result, { value: 1 })
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledOnceWithExactly(
+          'gettxout',
+          ['txid', 0, true]
+        )
+      )
+    })
+  })
+
+  describe('#verifyTxOutProofs()', () => {
+    it('should call adapter for each proof and return aggregated results', async () => {
+      const proofs = ['proof-1', 'proof-2']
+      mockAdapters.fullNode.call.onFirstCall().resolves(['txid-1'])
+      mockAdapters.fullNode.call.onSecondCall().resolves(['txid-2'])
+
+      const result = await uut.verifyTxOutProofs({ proofs })
+
+      assert.deepEqual(result, [['txid-1'], ['txid-2']])
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledWithExactly(
+          'verifytxoutproof',
+          ['proof-1'],
+          `verifytxoutproof-${proofs[0].slice(0, 16)}`
+        )
+      )
+    })
+  })
+})

test/unit/use-cases/full-node-control-use-cases-unit.js

@@ -0,0 +1,53 @@
+/*
+  Unit tests for ControlUseCases.
+*/
+
+import { assert } from 'chai'
+
+import ControlUseCases from '../../../src/use-cases/full-node-control-use-cases.js'
+
+describe('#full-node-control-use-cases.js', () => {
+  let mockAdapters
+  let uut
+
+  beforeEach(() => {
+    mockAdapters = {
+      fullNode: {
+        call: async () => ({})
+      }
+    }
+
+    uut = new ControlUseCases({ adapters: mockAdapters })
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new ControlUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getNetworkInfo()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      mockAdapters.fullNode.call = async method => {
+        capturedMethod = method
+        return { version: 1 }
+      }
+
+      const result = await uut.getNetworkInfo()
+
+      assert.equal(capturedMethod, 'getnetworkinfo')
+      assert.deepEqual(result, { version: 1 })
+    })
+  })
+})

test/unit/use-cases/full-node-dsproof-use-cases-unit.js

@@ -0,0 +1,54 @@
+/*
+  Unit tests for DSProofUseCases.
+*/
+
+import { assert } from 'chai'
+
+import DSProofUseCases from '../../../src/use-cases/full-node-dsproof-use-cases.js'
+
+describe('#full-node-dsproof-use-cases.js', () => {
+  let mockAdapters
+  let uut
+
+  beforeEach(() => {
+    mockAdapters = {
+      fullNode: {
+        call: async () => ({})
+      }
+    }
+
+    uut = new DSProofUseCases({ adapters: mockAdapters })
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new DSProofUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getDSProof()', () => {
+    it('should pass txid and verbose parameters to adapter', async () => {
+      let capturedArgs = null
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedArgs = { method, params }
+        return { success: true }
+      }
+
+      const result = await uut.getDSProof({ txid: 'a'.repeat(64), verbose: 2 })
+
+      assert.equal(capturedArgs.method, 'getdsproof')
+      assert.deepEqual(capturedArgs.params, ['a'.repeat(64), 2])
+      assert.deepEqual(result, { success: true })
+    })
+  })
+})

test/unit/use-cases/full-node-mining-use-cases-unit.js

@@ -0,0 +1,84 @@
+/*
+  Unit tests for MiningUseCases.
+*/
+
+import { assert } from 'chai'
+
+import MiningUseCases from '../../../src/use-cases/full-node-mining-use-cases.js'
+
+describe('#full-node-mining-use-cases.js', () => {
+  let mockAdapters
+  let uut
+
+  beforeEach(() => {
+    mockAdapters = {
+      fullNode: {
+        call: async () => ({})
+      }
+    }
+
+    uut = new MiningUseCases({ adapters: mockAdapters })
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new MiningUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new MiningUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getMiningInfo()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      mockAdapters.fullNode.call = async method => {
+        capturedMethod = method
+        return { blocks: 100, difficulty: 1.5 }
+      }
+
+      const result = await uut.getMiningInfo()
+
+      assert.equal(capturedMethod, 'getmininginfo')
+      assert.deepEqual(result, { blocks: 100, difficulty: 1.5 })
+    })
+  })
+
+  describe('#getNetworkHashPS()', () => {
+    it('should call full node adapter with correct method and default params', async () => {
+      let capturedMethod = ''
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedMethod = method
+        capturedParams = params
+        return 1234567890
+      }
+
+      const result = await uut.getNetworkHashPS({ nblocks: 120, height: -1 })
+
+      assert.equal(capturedMethod, 'getnetworkhashps')
+      assert.deepEqual(capturedParams, [120, -1])
+      assert.equal(result, 1234567890)
+    })
+
+    it('should call full node adapter with custom params', async () => {
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedParams = params
+        return 9876543210
+      }
+
+      const result = await uut.getNetworkHashPS({ nblocks: 240, height: 1000 })
+
+      assert.deepEqual(capturedParams, [240, 1000])
+      assert.equal(result, 9876543210)
+    })
+  })
+})

test/unit/use-cases/full-node-rawtransactions-use-cases-unit.js

@@ -0,0 +1,267 @@
+/*
+  Unit tests for RawTransactionsUseCases.
+*/
+
+import { assert } from 'chai'
+
+import RawTransactionsUseCases from '../../../src/use-cases/full-node-rawtransactions-use-cases.js'
+
+describe('#full-node-rawtransactions-use-cases.js', () => {
+  let mockAdapters
+  let uut
+
+  beforeEach(() => {
+    mockAdapters = {
+      fullNode: {
+        call: async () => ({})
+      }
+    }
+
+    uut = new RawTransactionsUseCases({ adapters: mockAdapters })
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new RawTransactionsUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new RawTransactionsUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#decodeRawTransaction()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedMethod = method
+        capturedParams = params
+        return { txid: 'abc123', version: 2 }
+      }
+
+      const result = await uut.decodeRawTransaction({ hex: '01000000' })
+
+      assert.equal(capturedMethod, 'decoderawtransaction')
+      assert.deepEqual(capturedParams, ['01000000'])
+      assert.deepEqual(result, { txid: 'abc123', version: 2 })
+    })
+  })
+
+  describe('#decodeRawTransactions()', () => {
+    it('should call full node adapter for each hex in parallel', async () => {
+      const callCount = { count: 0 }
+      mockAdapters.fullNode.call = async (method, params) => {
+        callCount.count++
+        return { txid: `tx${callCount.count}`, hex: params[0] }
+      }
+
+      const hexes = ['hex1', 'hex2', 'hex3']
+      const result = await uut.decodeRawTransactions({ hexes })
+
+      assert.equal(callCount.count, 3)
+      assert.equal(result.length, 3)
+      assert.equal(result[0].txid, 'tx1')
+      assert.equal(result[1].txid, 'tx2')
+      assert.equal(result[2].txid, 'tx3')
+    })
+  })
+
+  describe('#decodeScript()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedMethod = method
+        capturedParams = params
+        return { asm: 'OP_DUP OP_HASH160', type: 'pubkeyhash' }
+      }
+
+      const result = await uut.decodeScript({ hex: '76a914' })
+
+      assert.equal(capturedMethod, 'decodescript')
+      assert.deepEqual(capturedParams, ['76a914'])
+      assert.deepEqual(result, { asm: 'OP_DUP OP_HASH160', type: 'pubkeyhash' })
+    })
+  })
+
+  describe('#decodeScripts()', () => {
+    it('should call full node adapter for each hex in parallel', async () => {
+      const callCount = { count: 0 }
+      mockAdapters.fullNode.call = async (method, params) => {
+        callCount.count++
+        return { asm: `script${callCount.count}`, hex: params[0] }
+      }
+
+      const hexes = ['script1', 'script2']
+      const result = await uut.decodeScripts({ hexes })
+
+      assert.equal(callCount.count, 2)
+      assert.equal(result.length, 2)
+    })
+  })
+
+  describe('#getRawTransaction()', () => {
+    it('should call full node adapter with verbose=false by default', async () => {
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedParams = params
+        return '01000000'
+      }
+
+      await uut.getRawTransaction({ txid: 'abc123' })
+
+      assert.deepEqual(capturedParams, ['abc123', 0])
+    })
+
+    it('should call full node adapter with verbose=true when specified', async () => {
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedParams = params
+        return { txid: 'abc123', version: 2 }
+      }
+
+      await uut.getRawTransaction({ txid: 'abc123', verbose: true })
+
+      assert.deepEqual(capturedParams, ['abc123', 1])
+    })
+  })
+
+  describe('#getRawTransactions()', () => {
+    it('should call full node adapter for each txid in parallel', async () => {
+      const callCount = { count: 0 }
+      mockAdapters.fullNode.call = async (method, params) => {
+        callCount.count++
+        return { txid: params[0], version: 2 }
+      }
+
+      const txids = ['tx1', 'tx2']
+      const result = await uut.getRawTransactions({ txids, verbose: true })
+
+      assert.equal(callCount.count, 2)
+      assert.equal(result.length, 2)
+    })
+  })
+
+  describe('#getRawTransactionWithHeight()', () => {
+    it('should return transaction without height when verbose=false', async () => {
+      mockAdapters.fullNode.call = async (method, params) => {
+        if (method === 'getrawtransaction') {
+          return '01000000'
+        }
+        return {}
+      }
+
+      const result = await uut.getRawTransactionWithHeight({ txid: 'abc123', verbose: false })
+
+      assert.equal(result, '01000000')
+    })
+
+    it('should fetch and append height when verbose=true and blockhash exists', async () => {
+      let callCount = 0
+      mockAdapters.fullNode.call = async (method, params) => {
+        callCount++
+        if (method === 'getrawtransaction') {
+          return { txid: 'abc123', blockhash: 'block123' }
+        }
+        if (method === 'getblockheader') {
+          return { height: 100, hash: 'block123' }
+        }
+        return {}
+      }
+
+      const result = await uut.getRawTransactionWithHeight({ txid: 'abc123', verbose: true })
+
+      assert.equal(callCount, 2)
+      assert.equal(result.height, 100)
+      assert.equal(result.txid, 'abc123')
+    })
+
+    it('should handle block header lookup failure gracefully', async () => {
+      let callCount = 0
+      mockAdapters.fullNode.call = async (method, params) => {
+        callCount++
+        if (method === 'getrawtransaction') {
+          return { txid: 'abc123', blockhash: 'block123' }
+        }
+        if (method === 'getblockheader') {
+          throw new Error('Block not found')
+        }
+        return {}
+      }
+
+      const result = await uut.getRawTransactionWithHeight({ txid: 'abc123', verbose: true })
+
+      assert.equal(callCount, 2)
+      assert.isNull(result.height)
+      assert.equal(result.txid, 'abc123')
+    })
+  })
+
+  describe('#getBlockHeader()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedMethod = method
+        capturedParams = params
+        return { height: 100, hash: 'block123' }
+      }
+
+      const result = await uut.getBlockHeader({ blockHash: 'block123', verbose: true })
+
+      assert.equal(capturedMethod, 'getblockheader')
+      assert.deepEqual(capturedParams, ['block123', true])
+      assert.deepEqual(result, { height: 100, hash: 'block123' })
+    })
+  })
+
+  describe('#sendRawTransaction()', () => {
+    it('should call full node adapter with correct method', async () => {
+      let capturedMethod = ''
+      let capturedParams = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        capturedMethod = method
+        capturedParams = params
+        return 'txid123'
+      }
+
+      const result = await uut.sendRawTransaction({ hex: '01000000' })
+
+      assert.equal(capturedMethod, 'sendrawtransaction')
+      assert.deepEqual(capturedParams, ['01000000'])
+      assert.equal(result, 'txid123')
+    })
+  })
+
+  describe('#sendRawTransactions()', () => {
+    it('should send transactions serially, not in parallel', async () => {
+      const callOrder = []
+      mockAdapters.fullNode.call = async (method, params) => {
+        callOrder.push(params[0])
+        // Simulate some async work
+        await new Promise(resolve => setTimeout(resolve, 10))
+        return `txid-${params[0]}`
+      }
+
+      const hexes = ['hex1', 'hex2', 'hex3']
+      const startTime = Date.now()
+      const result = await uut.sendRawTransactions({ hexes })
+      const endTime = Date.now()
+
+      // Should take at least 30ms if serial (3 * 10ms)
+      assert.isAtLeast(endTime - startTime, 25)
+      assert.deepEqual(callOrder, ['hex1', 'hex2', 'hex3'])
+      assert.equal(result.length, 3)
+      assert.equal(result[0], 'txid-hex1')
+      assert.equal(result[1], 'txid-hex2')
+      assert.equal(result[2], 'txid-hex3')
+    })
+  })
+})

test/unit/use-cases/manage-subscription-unit.js

@@ -1,242 +0,0 @@
-/*
-  Unit tests for ManageSubscriptionUseCase.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-
-// Mocking data libraries
-import { mockKind1Event } from '../mocks/event-mocks.js'
-
-// Unit under test
-import ManageSubscriptionUseCase from '../../../src/use-cases/manage-subscription.js'
-
-describe('#manage-subscription.js', () => {
-  let sandbox
-  let mockAdapters
-  let uut
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    // Create mock adapters with multiple relays support
-    const mockRelay1 = {
-      relayUrl: 'wss://relay1.example.com',
-      sendReq: sandbox.stub(),
-      sendClose: sandbox.stub()
-    }
-    const mockRelay2 = {
-      relayUrl: 'wss://relay2.example.com',
-      sendReq: sandbox.stub(),
-      sendClose: sandbox.stub()
-    }
-
-    mockAdapters = {
-      nostrRelays: [mockRelay1, mockRelay2]
-    }
-
-    uut = new ManageSubscriptionUseCase({ adapters: mockAdapters })
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  describe('#createSubscription()', () => {
-    it('should successfully create a subscription across all relays', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-      let onEventCalled = false
-      let onEoseCalled = false
-      let onClosedCalled = false
-
-      const onEvent = (event) => {
-        onEventCalled = true
-      }
-      const onEose = () => {
-        onEoseCalled = true
-      }
-      const onClosed = (message) => {
-        onClosedCalled = true
-      }
-
-      // Mock adapters to resolve
-      mockAdapters.nostrRelays[0].sendReq.resolves()
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-
-      await uut.createSubscription(subscriptionId, filters, onEvent, onEose, onClosed)
-
-      // Assert adapters were called for both relays
-      assert.isTrue(mockAdapters.nostrRelays[0].sendReq.calledOnce)
-      assert.isTrue(mockAdapters.nostrRelays[1].sendReq.calledOnce)
-
-      // Assert subscription is tracked
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      // Test handlers - get them from the subscription info
-      const subscriptionInfo = uut.activeSubscriptions.get(subscriptionId)
-      const handlers = subscriptionInfo.handlers
-
-      // Test event handler (should de-duplicate)
-      handlers.onEvent(mockKind1Event)
-      assert.isTrue(onEventCalled)
-
-      // Simulate EOSE from both relays
-      const relayStatuses = subscriptionInfo.relayStatuses
-      relayStatuses[0].eoseReceived = true
-      relayStatuses[1].eoseReceived = true
-      handlers.onEose()
-      assert.isTrue(onEoseCalled)
-
-      handlers.onClosed('test message')
-      assert.isTrue(onClosedCalled)
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-    })
-
-    it('should prevent duplicate subscriptions', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-
-      mockAdapters.nostrRelays[0].sendReq.resolves()
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-
-      await uut.createSubscription(subscriptionId, filters)
-
-      try {
-        await uut.createSubscription(subscriptionId, filters)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'already exists')
-      }
-    })
-
-    it('should clean up subscription on error', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-
-      mockAdapters.nostrRelays[0].sendReq.rejects(new Error('Connection error'))
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-
-      try {
-        await uut.createSubscription(subscriptionId, filters)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        // Should clean up even if some relays fail
-        assert.isFalse(uut.hasSubscription(subscriptionId))
-      }
-    })
-
-    it('should handle missing callbacks gracefully', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-
-      mockAdapters.nostrRelays[0].sendReq.resolves()
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-
-      await uut.createSubscription(subscriptionId, filters, null, null, null)
-
-      // Should not throw when handlers are null
-      const subscriptionInfo = uut.activeSubscriptions.get(subscriptionId)
-      const handlers = subscriptionInfo.handlers
-      handlers.onEvent(mockKind1Event)
-      handlers.onEose()
-      handlers.onClosed('test')
-    })
-  })
-
-  describe('#closeSubscription()', () => {
-    it('should successfully close a subscription across all relays', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-
-      mockAdapters.nostrRelays[0].sendReq.resolves()
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-      mockAdapters.nostrRelays[0].sendClose.resolves()
-      mockAdapters.nostrRelays[1].sendClose.resolves()
-
-      // Create subscription first
-      await uut.createSubscription(subscriptionId, filters)
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      // Close subscription
-      await uut.closeSubscription(subscriptionId)
-
-      // Assert adapters were called for both relays
-      assert.isTrue(mockAdapters.nostrRelays[0].sendClose.calledOnce)
-      assert.isTrue(mockAdapters.nostrRelays[1].sendClose.calledOnce)
-
-      // Assert subscription is removed
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-    })
-
-    it('should return successfully when closing non-existent subscription (idempotent)', async () => {
-      const subscriptionId = 'non-existent-sub'
-
-      // Should not throw - idempotent operation
-      await uut.closeSubscription(subscriptionId)
-
-      // Should return successfully without error
-      assert.isTrue(true, 'closeSubscription should succeed for non-existent subscription')
-    })
-
-    it('should clean up subscription even on error', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-
-      mockAdapters.nostrRelays[0].sendReq.resolves()
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-      mockAdapters.nostrRelays[0].sendClose.rejects(new Error('Close error'))
-      mockAdapters.nostrRelays[1].sendClose.resolves()
-
-      // Create subscription first
-      await uut.createSubscription(subscriptionId, filters)
-
-      // Close should succeed even if one relay fails
-      await uut.closeSubscription(subscriptionId)
-
-      // Should still clean up
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-    })
-  })
-
-  describe('#hasSubscription()', () => {
-    it('should return false for non-existent subscription', () => {
-      assert.isFalse(uut.hasSubscription('non-existent'))
-    })
-
-    it('should return true for existing subscription', async () => {
-      const subscriptionId = 'test-sub-123'
-      const filters = [{ kinds: [1] }]
-
-      mockAdapters.nostrRelays[0].sendReq.resolves()
-      mockAdapters.nostrRelays[1].sendReq.resolves()
-
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-      await uut.createSubscription(subscriptionId, filters)
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-    })
-  })
-
-  describe('#constructor()', () => {
-    it('should require adapters instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new ManageSubscriptionUseCase()
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Adapters instance required')
-      }
-    })
-
-    it('should require NostrRelay adapters array', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new ManageSubscriptionUseCase({ adapters: {} })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'NostrRelay adapters array required')
-      }
-    })
-  })
-})

test/unit/use-cases/price-use-cases-unit.js

@@ -0,0 +1,103 @@
+/*
+  Unit tests for PriceUseCases.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import PriceUseCases from '../../../src/use-cases/price-use-cases.js'
+
+describe('#price-use-cases.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockAxios
+  let mockConfig
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+
+    mockConfig = {
+      restURL: 'http://localhost:3000/v5/'
+    }
+
+    // Mock axios
+    mockAxios = {
+      request: sandbox.stub()
+    }
+
+    uut = new PriceUseCases({
+      adapters: mockAdapters,
+      axios: mockAxios,
+      config: mockConfig
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new PriceUseCases()
+      }, /Adapters instance required/)
+    })
+  })
+
+  describe('#getBCHUSD()', () => {
+    it('should return BCH price from Coinex API', async () => {
+      const mockPrice = 250.5
+      mockAxios.request.resolves({
+        data: {
+          data: {
+            ticker: {
+              last: mockPrice.toString()
+            }
+          }
+        }
+      })
+
+      const result = await uut.getBCHUSD()
+
+      assert.equal(result, mockPrice)
+      assert.isTrue(mockAxios.request.calledOnce)
+      const callArgs = mockAxios.request.getCall(0).args[0]
+      assert.equal(callArgs.method, 'get')
+      assert.equal(callArgs.baseURL, 'https://api.coinex.com/v1/market/ticker?market=bchusdt')
+      assert.equal(callArgs.timeout, 15000)
+    })
+
+    it('should handle errors', async () => {
+      const error = new Error('API error')
+      mockAxios.request.rejects(error)
+
+      try {
+        await uut.getBCHUSD()
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.equal(err.message, 'API error')
+      }
+    })
+  })
+
+  describe('#getPsffppWritePrice()', () => {
+    it('should handle errors properly', async () => {
+      // Note: Full unit testing of getPsffppWritePrice is difficult due to dynamic imports
+      // of SlpWallet and PSFFPP. Integration tests should verify the full flow.
+      // This test verifies that errors are properly handled and propagated.
+      try {
+        // This will likely fail in unit test environment without proper setup
+        // but we verify error handling works correctly
+        await uut.getPsffppWritePrice()
+        // If it succeeds, that's also acceptable
+      } catch (err) {
+        // Verify error is properly formatted
+        assert.isTrue(err instanceof Error)
+        // Verify error was logged (indirectly through wlogger)
+      }
+    })
+  })
+})

test/unit/use-cases/publish-event-unit.js

@@ -1,146 +0,0 @@
-/*
-  Unit tests for PublishEventUseCase.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-
-// Mocking data libraries
-import {
-  mockKind1Event,
-  mockInvalidEventMissingId
-} from '../mocks/event-mocks.js'
-
-// Unit under test
-import PublishEventUseCase from '../../../src/use-cases/publish-event.js'
-
-describe('#publish-event.js', () => {
-  let sandbox
-  let mockAdapters
-  let uut
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    // Create mock adapters with multiple relays support
-    mockAdapters = {
-      nostrRelays: [
-        { relayUrl: 'wss://relay1.example.com' },
-        { relayUrl: 'wss://relay2.example.com' }
-      ],
-      broadcastEvent: sandbox.stub()
-    }
-
-    uut = new PublishEventUseCase({ adapters: mockAdapters })
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  describe('#execute()', () => {
-    it('should successfully publish a valid event to all relays', async () => {
-      // Mock broadcast response - at least one relay accepts
-      mockAdapters.broadcastEvent.resolves([
-        { accepted: true, message: 'event saved', relayUrl: 'wss://relay1.example.com', success: true },
-        { accepted: true, message: 'event saved', relayUrl: 'wss://relay2.example.com', success: true }
-      ])
-
-      const result = await uut.execute(mockKind1Event)
-
-      // Assert adapter was called correctly
-      assert.isTrue(mockAdapters.broadcastEvent.calledOnce)
-      const callArgs = mockAdapters.broadcastEvent.getCall(0).args[0]
-      assert.equal(callArgs.id, mockKind1Event.id)
-      assert.equal(callArgs.kind, mockKind1Event.kind)
-
-      // Assert result
-      assert.property(result, 'accepted')
-      assert.property(result, 'message')
-      assert.property(result, 'eventId')
-      assert.property(result, 'relayResults')
-      assert.property(result, 'acceptedCount')
-      assert.property(result, 'totalRelays')
-      assert.isTrue(result.accepted)
-      assert.equal(result.eventId, mockKind1Event.id)
-      assert.equal(result.acceptedCount, 2)
-      assert.equal(result.totalRelays, 2)
-    })
-
-    it('should handle event rejection from all relays', async () => {
-      // Mock broadcast response - all relays reject
-      mockAdapters.broadcastEvent.resolves([
-        { accepted: false, message: 'duplicate', relayUrl: 'wss://relay1.example.com', success: true },
-        { accepted: false, message: 'duplicate', relayUrl: 'wss://relay2.example.com', success: true }
-      ])
-
-      const result = await uut.execute(mockKind1Event)
-
-      // Assert result shows rejection
-      assert.isFalse(result.accepted)
-      assert.property(result, 'message')
-      assert.equal(result.eventId, mockKind1Event.id)
-      assert.equal(result.acceptedCount, 0)
-    })
-
-    it('should succeed if at least one relay accepts', async () => {
-      // Mock broadcast response - one accepts, one rejects
-      mockAdapters.broadcastEvent.resolves([
-        { accepted: true, message: 'event saved', relayUrl: 'wss://relay1.example.com', success: true },
-        { accepted: false, message: 'duplicate', relayUrl: 'wss://relay2.example.com', success: true }
-      ])
-
-      const result = await uut.execute(mockKind1Event)
-
-      // Should succeed if at least one accepts
-      assert.isTrue(result.accepted)
-      assert.equal(result.acceptedCount, 1)
-      assert.equal(result.totalRelays, 2)
-    })
-
-    it('should throw error for invalid event structure', async () => {
-      try {
-        await uut.execute(mockInvalidEventMissingId)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Invalid event structure')
-        assert.isFalse(mockAdapters.broadcastEvent.called)
-      }
-    })
-
-    it('should handle adapter errors', async () => {
-      // Mock adapter error
-      const adapterError = new Error('Network error')
-      mockAdapters.broadcastEvent.rejects(adapterError)
-
-      try {
-        await uut.execute(mockKind1Event)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.equal(err.message, 'Network error')
-        assert.isTrue(mockAdapters.broadcastEvent.calledOnce)
-      }
-    })
-
-    it('should require adapters instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new PublishEventUseCase()
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Adapters instance required')
-      }
-    })
-
-    it('should require NostrRelay adapters array', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new PublishEventUseCase({ adapters: {} })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'NostrRelay adapters array required')
-      }
-    })
-  })
-})

test/unit/use-cases/query-events-unit.js

@@ -1,106 +0,0 @@
-/*
-  Unit tests for QueryEventsUseCase.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-
-// Mocking data libraries
-import { mockEventsArray } from '../mocks/nostr-relay-mocks.js'
-
-// Unit under test
-import QueryEventsUseCase from '../../../src/use-cases/query-events.js'
-
-describe('#query-events.js', () => {
-  let sandbox
-  let mockAdapters
-  let uut
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    // Create mock adapters with multiple relays support
-    mockAdapters = {
-      nostrRelays: [
-        { relayUrl: 'wss://relay1.example.com' },
-        { relayUrl: 'wss://relay2.example.com' }
-      ],
-      queryAllRelays: sandbox.stub()
-    }
-
-    uut = new QueryEventsUseCase({ adapters: mockAdapters })
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  describe('#execute()', () => {
-    it('should successfully query events from all relays and return merged results', async () => {
-      const filters = [{ kinds: [1], limit: 10 }]
-      const subscriptionId = 'test-sub-123'
-
-      // Mock queryAllRelays to return events
-      mockAdapters.queryAllRelays.resolves(mockEventsArray)
-
-      const result = await uut.execute(filters, subscriptionId)
-
-      // Assert adapter was called correctly
-      assert.isTrue(mockAdapters.queryAllRelays.calledOnce)
-      const callArgs = mockAdapters.queryAllRelays.getCall(0).args
-      assert.deepEqual(callArgs[0], filters)
-      assert.equal(callArgs[1], subscriptionId)
-
-      // Assert result contains events
-      assert.isArray(result)
-      assert.equal(result.length, mockEventsArray.length)
-    })
-
-    it('should handle errors from queryAllRelays', async () => {
-      const filters = [{ kinds: [1] }]
-      const subscriptionId = 'test-sub-123'
-
-      mockAdapters.queryAllRelays.rejects(new Error('Query failed'))
-
-      try {
-        await uut.execute(filters, subscriptionId)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Query failed')
-      }
-    })
-
-    it('should return empty array when no events found', async () => {
-      const filters = [{ kinds: [1] }]
-      const subscriptionId = 'test-sub-123'
-
-      mockAdapters.queryAllRelays.resolves([])
-
-      const result = await uut.execute(filters, subscriptionId)
-
-      assert.isArray(result)
-      assert.equal(result.length, 0)
-    })
-
-    it('should require adapters instance', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new QueryEventsUseCase()
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Adapters instance required')
-      }
-    })
-
-    it('should require NostrRelay adapters array', () => {
-      try {
-        // eslint-disable-next-line no-new
-        new QueryEventsUseCase({ adapters: {} })
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'NostrRelay adapters array required')
-      }
-    })
-  })
-})

test/unit/use-cases/slp-use-cases-unit.js

@@ -0,0 +1,296 @@
+/*
+  Unit tests for SlpUseCases.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+import BCHJS from '@psf/bch-js'
+
+import SlpUseCases from '../../../src/use-cases/slp-use-cases.js'
+
+describe('#slp-use-cases.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockConfig
+  let uut
+  let mockBchjs
+  let mockWallet
+  let mockSlpTokenMedia
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockConfig = {
+      restURL: 'http://localhost:3000/v5/',
+      ipfsGateway: 'p2wdb-gateway-678.fullstack.cash'
+    }
+
+    mockAdapters = {
+      slpIndexer: {
+        get: sandbox.stub().resolves({}),
+        post: sandbox.stub().resolves({})
+      }
+    }
+
+    // Create mock BCHJS
+    mockBchjs = new BCHJS()
+    mockBchjs.Electrumx = {
+      txData: sandbox.stub().resolves({
+        details: {
+          vout: [
+            {
+              scriptPubKey: {
+                hex: '6a0c48656c6c6f20576f726c6421'
+              }
+            }
+          ]
+        }
+      })
+    }
+    mockBchjs.Script = {
+      toASM: sandbox.stub().returns('OP_RETURN 48656c6c6f20576f726c6421')
+    }
+
+    // Create mock wallet
+    mockWallet = {
+      walletInfoPromise: Promise.resolve(),
+      getTransactions: sandbox.stub().resolves([]),
+      getTxData: sandbox.stub().resolves([{
+        vin: [{
+          address: 'bitcoincash:test123'
+        }]
+      }])
+    }
+
+    // Create mock SlpTokenMedia
+    mockSlpTokenMedia = {
+      getIcon: sandbox.stub().resolves({ tokenIcon: 'test-icon.png' })
+    }
+
+    // Mock the imports
+    uut = new SlpUseCases({
+      adapters: mockAdapters,
+      bchjs: mockBchjs,
+      config: mockConfig
+    })
+
+    // Replace the wallet initialization with our mocks
+    uut.wallet = mockWallet
+    uut.slpTokenMedia = mockSlpTokenMedia
+    uut.walletInitialized = true
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new SlpUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require slpIndexer adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new SlpUseCases({ adapters: {} })
+      }, /SLP Indexer adapter required/)
+    })
+  })
+
+  describe('#getStatus()', () => {
+    it('should call slpIndexer adapter get method', async () => {
+      mockAdapters.slpIndexer.get.resolves({ status: 'ok' })
+
+      const result = await uut.getStatus()
+
+      assert.isTrue(mockAdapters.slpIndexer.get.calledOnceWith('slp/status/'))
+      assert.deepEqual(result, { status: 'ok' })
+    })
+  })
+
+  describe('#getAddress()', () => {
+    it('should call slpIndexer adapter post method', async () => {
+      const address = 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      mockAdapters.slpIndexer.post.resolves({ balance: 1000 })
+
+      const result = await uut.getAddress({ address })
+
+      assert.isTrue(
+        mockAdapters.slpIndexer.post.calledOnceWith('slp/address/', { address })
+      )
+      assert.deepEqual(result, { balance: 1000 })
+    })
+  })
+
+  describe('#getTxid()', () => {
+    it('should call slpIndexer adapter post method', async () => {
+      const txid = 'a'.repeat(64)
+      mockAdapters.slpIndexer.post.resolves({ txid })
+
+      const result = await uut.getTxid({ txid })
+
+      assert.isTrue(
+        mockAdapters.slpIndexer.post.calledOnceWith('slp/tx/', { txid })
+      )
+      assert.deepEqual(result, { txid })
+    })
+  })
+
+  describe('#getTokenStats()', () => {
+    it('should call slpIndexer adapter post method', async () => {
+      const tokenId = 'a'.repeat(64)
+      const withTxHistory = false
+      mockAdapters.slpIndexer.post.resolves({ tokenData: {} })
+
+      const result = await uut.getTokenStats({ tokenId, withTxHistory })
+
+      assert.isTrue(
+        mockAdapters.slpIndexer.post.calledOnceWith('slp/token/', { tokenId, withTxHistory })
+      )
+      assert.deepEqual(result, { tokenData: {} })
+    })
+  })
+
+  describe('#getTokenData()', () => {
+    it('should get token data with mutable and immutable data', async () => {
+      const tokenId = 'a'.repeat(64)
+      const tokenStats = {
+        tokenData: {
+          documentUri: 'ipfs://test123',
+          documentHash: 'b'.repeat(64)
+        }
+      }
+      mockAdapters.slpIndexer.post.resolves(tokenStats)
+
+      // Mock decodeOpReturn to return JSON with mda
+      sandbox.stub(uut, 'decodeOpReturn').resolves(JSON.stringify({ mda: 'bitcoincash:test123' }))
+      sandbox.stub(uut, 'getMutableCid').resolves('mutable-cid-123')
+
+      const result = await uut.getTokenData({ tokenId })
+
+      assert.property(result, 'genesisData')
+      assert.property(result, 'immutableData')
+      assert.property(result, 'mutableData')
+    })
+
+    it('should handle errors when getting mutable data', async () => {
+      const tokenId = 'a'.repeat(64)
+      const tokenStats = {
+        tokenData: {
+          documentUri: 'ipfs://test123',
+          documentHash: 'b'.repeat(64)
+        }
+      }
+      mockAdapters.slpIndexer.post.resolves(tokenStats)
+
+      sandbox.stub(uut, 'getMutableCid').rejects(new Error('Test error'))
+
+      const result = await uut.getTokenData({ tokenId })
+
+      assert.property(result, 'genesisData')
+      assert.property(result, 'immutableData')
+      assert.equal(result.mutableData, '')
+    })
+  })
+
+  describe('#decodeOpReturn()', () => {
+    it('should decode OP_RETURN data from transaction', async () => {
+      const txid = 'a'.repeat(64)
+      const mockTxData = {
+        details: {
+          vout: [
+            {
+              scriptPubKey: {
+                hex: '6a0c48656c6c6f20576f726c6421'
+              }
+            }
+          ]
+        }
+      }
+      mockBchjs.Electrumx.txData.resolves(mockTxData)
+      mockBchjs.Script.toASM.returns('OP_RETURN 48656c6c6f20576f726c6421')
+
+      const result = await uut.decodeOpReturn({ txid })
+
+      assert.isTrue(mockBchjs.Electrumx.txData.calledOnceWith(txid))
+      assert.isString(result)
+    })
+
+    it('should throw error if txid is not a string', async () => {
+      try {
+        await uut.decodeOpReturn({ txid: null })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.include(err.message, 'txid must be a string')
+      }
+    })
+  })
+
+  describe('#getCIDData()', () => {
+    it('should fetch IPFS data from CID', async () => {
+      const cid = 'ipfs://test123'
+      const mockData = { name: 'Test Token' }
+
+      // Mock axios
+      const axios = await import('axios')
+      sandbox.stub(axios.default, 'get').resolves({ data: mockData })
+
+      const result = await uut.getCIDData({ cid })
+
+      assert.deepEqual(result, mockData)
+    })
+
+    it('should throw error if cid is not a string', async () => {
+      try {
+        await uut.getCIDData({ cid: null })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.include(err.message, 'cid must be a string')
+      }
+    })
+  })
+
+  describe('#getMutableCid()', () => {
+    it('should extract mutable CID from token stats', async () => {
+      const tokenStats = {
+        documentHash: 'a'.repeat(64)
+      }
+
+      const mockOpReturn = JSON.stringify({ mda: 'bitcoincash:test123' })
+      sandbox.stub(uut, 'decodeOpReturn').resolves(mockOpReturn)
+
+      mockWallet.getTransactions.resolves([
+        {
+          tx_hash: 'b'.repeat(64),
+          height: 100
+        }
+      ])
+
+      mockWallet.getTxData.resolves([{
+        vin: [{
+          address: 'bitcoincash:test123'
+        }]
+      }])
+
+      // Mock decodeOpReturn for the transaction
+      uut.decodeOpReturn.onSecondCall().resolves(JSON.stringify({ cid: 'ipfs://mutable-cid-123', ts: 1234567890 }))
+
+      const result = await uut.getMutableCid({ tokenStats })
+
+      assert.isString(result)
+    })
+
+    it('should return false if no documentHash in tokenStats', async () => {
+      const tokenStats = {}
+
+      try {
+        await uut.getMutableCid({ tokenStats })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.include(err.message, 'No documentHash property found')
+      }
+    })
+  })
+})