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

Improved debugging of interaction with x402 Facilitator

.env-example

@@ -0,0 +1,35 @@
+# 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
+
+PORT=5942
+
+# x402 payments required to access this API?
+X402_ENABLED=true
+SERVER_BCH_ADDRESS=bitcoincash:qqlrzp23w08434twmvr4fxw672whkjy0py26r63g3d
+FACILITATOR_URL=http://localhost:4345/facilitator
+X402_PRICE_SAT=200
+
+# Basic Authentication required to access this API?
+USE_BASIC_AUTH=true
+BASIC_AUTH_TOKEN=some-random-token
+
+# END ACCESS CONTROL
+

.env-local

@@ -1,13 +0,0 @@
-# Full Node Connection
-RPC_BASEURL=http://172.17.0.1:8332
-RPC_USERNAME=bitcoin
-RPC_PASSWORD=password
-
-# x402 payments required to access this API?
-X402_ENABLED=false
-
-# Fulcrum Indexer
-FULCRUM_API=http://192.168.2.127:3001
-
-# SLP Indexer
-SLP_INDEXER_API=http://192.168.2.127:5010

README.md

@@ -8,7 +8,7 @@ This is a REST API for communicating with Bitcoin Cash infrastructure. It replac
 
 ## 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.
+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 **200 satoshis**. The middleware advertises payment requirements via HTTP 402 responses and validates incoming `X-PAYMENT` headers with a configured Facilitator.
 
 ### Configuration
 
@@ -17,7 +17,7 @@ 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`).
+- `X402_PRICE_SAT` — Optional; override the satoshi price per call (defaults to `200`).
 
 When `X402_ENABLED=false`, the server continues to operate without payment headers for local development or trusted deployments.
 

bin/server.js

@@ -15,7 +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 } from '../src/config/x402.js'
+import { buildX402Routes, getX402Settings, getBasicAuthSettings } from '../src/config/x402.js'
+import { basicAuthMiddleware } from '../src/middleware/basic-auth.js'
 
 // Load environment variables
 dotenv.config()
@@ -60,6 +61,7 @@ class Server {
       const app = express()
 
       const x402Settings = getX402Settings()
+      const basicAuthSettings = getBasicAuthSettings()
 
       // MIDDLEWARE START
       app.use(express.json())
@@ -72,28 +74,94 @@ class Server {
         allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With']
       }))
 
-      // Wrap all endpoints in x402 middleware. This handles payments for the API calls.
-      if (x402Settings.enabled) {
+      // 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=true AND USE_BASIC_AUTH=true: Apply x402 conditionally (bypass if basic auth valid)
+      // - If X402_ENABLED=true AND USE_BASIC_AUTH=false: Apply x402 unconditionally (no basic auth bypass)
+      // - If X402_ENABLED=false AND USE_BASIC_AUTH=true: Require basic auth only
+      // - If X402_ENABLED=false AND USE_BASIC_AUTH=false: No access control
+
+      // 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; enforcing ${x402Settings.priceSat} satoshis per request`)
-        app.use(
-          x402PaymentMiddleware(
+        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 (x402Settings.enabled && !basicAuthSettings.enabled) {
+        // X402_ENABLED=true AND USE_BASIC_AUTH=false: Apply x402 unconditionally (no basic auth bypass)
+        const routes = buildX402Routes(this.config.apiPrefix)
+        const facilitatorOptions = x402Settings.facilitatorUrl
+          ? { url: x402Settings.facilitatorUrl }
+          : undefined
+
+        wlogger.info(`x402 middleware enabled (basic auth disabled); enforcing ${x402Settings.priceSat} satoshis per request`)
+
+        // Apply x402 middleware unconditionally - no basic auth bypass
+        app.use(x402PaymentMiddleware(
+          x402Settings.serverAddress,
+          routes,
+          facilitatorOptions
+        ))
+      } 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 {
-        wlogger.info('x402 middleware disabled via configuration')
+        // 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}`)
+        console.log(`Endpoint called: ${req.method} ${req.path} by ${req.ip}`)
         res.on('finish', () => {
           console.log(`Endpoint responded: ${req.method} ${req.path} - ${res.statusCode}`)
         })

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,16 +15,17 @@
   "license": "MIT",
   "description": "REST API proxy to Bitcoin Cash infrastructure",
   "dependencies": {
-    "@psf/bch-js": "6.8.3",
+    "@psf/bch-js": "7.1.2",
     "axios": "1.7.7",
     "cors": "2.8.5",
     "dotenv": "16.3.1",
     "express": "5.1.0",
-    "minimal-slp-wallet": "5.13.3",
+    "minimal-slp-wallet": "7.0.2",
+    "psffpp": "1.2.1",
     "slp-token-media": "1.2.10",
     "winston": "3.11.0",
     "winston-daily-rotate-file": "4.7.1",
-    "x402-bch-express": "1.1.1"
+    "x402-bch-express": "1.1.3"
   },
   "devDependencies": {
     "apidoc": "1.2.0",

production/docker/.env-example

@@ -0,0 +1,37 @@
+# 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://172.17.0.1:5010
+
+# REST API URL for wallet operations
+LOCAL_RESTURL=http://172.17.0.1:5942/v6
+
+# END INFRASTRUCTURE SETUP
+
+
+# START ACCESS CONTROL
+
+PORT=5942
+
+# x402 payments required to access this API?
+X402_ENABLED=false
+#X402_ENABLED=true
+#SERVER_BCH_ADDRESS=bitcoincash:qqlrzp23w08434twmvr4fxw672whkjy0py26r63g3d
+#FACILITATOR_URL=http://localhost:4345/facilitator
+#X402_PRICE_SAT=200
+
+# Basic Authentication required to access this API?
+USE_BASIC_AUTH=false
+#USE_BASIC_AUTH=true
+#BASIC_AUTH_TOKEN=some-random-token
+
+# END ACCESS CONTROL
+

production/docker/Dockerfile

@@ -2,8 +2,6 @@
 #
 
 #IMAGE BUILD COMMANDS
-# ct-base-ubuntu = ubuntu 18.04 + nodejs v10 LTS
-#FROM christroutner/ct-base-ubuntu
 FROM ubuntu:22.04
 MAINTAINER Chris Troutner <chris.troutner@gmail.com>
 
@@ -47,39 +45,26 @@ RUN runuser -l safeuser -c "npm config set prefix '~/.npm-global'"
 
 # Clone the rest.bitcoin.com repository
 WORKDIR /home/safeuser
-RUN git clone https://github.com/christroutner/REST2NOSTR
+RUN git clone https://github.com/Permissionless-Software-Foundation/psf-bch-api
 
 # Switch to the desired branch. `master` is usually stable,
 # and `stage` has the most up-to-date changes.
-WORKDIR /home/safeuser/REST2NOSTR
+WORKDIR /home/safeuser/psf-bch-api
 
-# For development: switch to unstable branch
-#RUN git checkout pin-ipfs
+RUN git checkout ct-unstable
 
 # Install dependencies
 RUN npm install
+RUN npm install minimal-slp-wallet
 
 # Generate the API docs
 RUN npm run docs
 
-#VOLUME /home/safeuser/keys
+COPY .env .env
 
-# Make leveldb folders
-#RUN mkdir leveldb
-#WORKDIR /home/safeuser/psf-slp-indexer/leveldb
-#RUN mkdir current
-#RUN mkdir zips
-#RUN mkdir backup
-#WORKDIR /home/safeuser/psf-slp-indexer/leveldb/zips
-#COPY restore-auto.sh restore-auto.sh
-#WORKDIR /home/safeuser/psf-slp-indexer
 
-# Expose the port the API will be served on.
-#EXPOSE 5011
+CMD ["npm", "start"]
 
-# Start the application.
-#COPY start-production.sh start-production.sh
-VOLUME start-rest2nostr.sh
-CMD ["./start-rest2nostr.sh"]
-
-#CMD ["npm", "start"]
+# Used to debug the container.
+#COPY temp.js temp.js
+#CMD ["node", "temp.js"]

production/docker/docker-compose.yml

@@ -1,9 +1,9 @@
 # Start the service with the command 'docker-compose up -d'
 
 services:
-    rest2nostr:
+    psf-bch-api:
       build: .
-      container_name: rest2nostr
+      container_name: psf-bch-api
       logging:
         driver: 'json-file'
         options:
@@ -15,5 +15,6 @@ services:
       ports:
         - '5942:5942' # <host port>:<container port>
       volumes:
-        - ./start-rest2nostr.sh:/home/safeuser/REST2NOSTR/start-rest2nostr.sh
+        #- ./start-rest2nostr.sh:/home/safeuser/REST2NOSTR/start-rest2nostr.sh
+        - ./.env:/home/safeuser/.env
       restart: always

production/docker/start-rest2nostr.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-npm start

src/config/env/common.js

@@ -26,21 +26,26 @@ const normalizeBoolean = (value, defaultValue) => {
   return defaultValue
 }
 
-// By default, the price per API call is 2000 satoshis.
+// By default, the price per API call is 200 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 priceSat = Number.isFinite(parsedPriceSat) && parsedPriceSat > 0 ? parsedPriceSat : 200
 
 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:qqlrzp23w08434twmvr4fxw672whkjy0py26r63g3d',
+  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,
+  port: parseInt(process.env.PORT, 10) || 5942,
 
   // Environment
   env: process.env.NODE_ENV || 'development',
@@ -73,13 +78,15 @@ export default {
   },
 
   // REST API URL for wallet operations
-  restURL: process.env.REST_URL || process.env.LOCAL_RESTURL || 'http://127.0.0.1:3000/v5/',
+  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

@@ -26,7 +26,7 @@ export function buildX402Routes (apiPrefix = '/v6') {
       price: config.x402.priceSat,
       network: NETWORK,
       config: {
-        description: `${DEFAULT_DESCRIPTION} (2000 satoshis)`,
+        description: `${DEFAULT_DESCRIPTION} (${config.x402.priceSat} satoshis)`,
         maxTimeoutSeconds: DEFAULT_TIMEOUT_SECONDS
       }
     }
@@ -41,3 +41,10 @@ export function getX402Settings () {
     priceSat: config.x402?.priceSat
   }
 }
+
+export function getBasicAuthSettings () {
+  return {
+    enabled: Boolean(config.basicAuth?.enabled),
+    token: config.basicAuth?.token || ''
+  }
+}

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

@@ -0,0 +1,100 @@
+/*
+  REST API Controller for the /encryption routes.
+*/
+
+import wlogger from '../../../adapters/wlogger.js'
+
+class EncryptionRESTController {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Encryption REST Controller.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases || !this.useCases.encryption) {
+      throw new Error(
+        'Instance of Encryption use cases required when instantiating Encryption REST Controller.'
+      )
+    }
+
+    this.encryptionUseCases = this.useCases.encryption
+
+    // Bind functions
+    this.root = this.root.bind(this)
+    this.getPublicKey = this.getPublicKey.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {get} /v6/encryption/ Service status
+   * @apiName EncryptionRoot
+   * @apiGroup Encryption
+   *
+   * @apiDescription Returns the status of the encryption service.
+   *
+   * @apiSuccess {String} status Service identifier
+   */
+  async root (req, res) {
+    return res.status(200).json({ status: 'encryption' })
+  }
+
+  /**
+   * @api {get} /v6/encryption/publickey/:address Get public key for a BCH address
+   * @apiName GetPublicKey
+   * @apiGroup Encryption
+   * @apiDescription Searches the blockchain for a public key associated with a
+   * BCH address. Returns an object. If successful, the publicKey property will
+   * contain a hexadecimal representation of the public key.
+   *
+   * @apiParam {String} address BCH address (cash address or legacy format)
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v6/encryption/publickey/bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf" -H "accept: application/json"
+   *
+   * @apiSuccess {Boolean} success Indicates if the operation was successful
+   * @apiSuccess {String} publicKey The public key in hexadecimal format, or "not found"
+   */
+  async getPublicKey (req, res) {
+    try {
+      const address = req.params.address
+
+      // Reject if address is an array
+      if (Array.isArray(address)) {
+        res.status(400)
+        return res.json({
+          success: false,
+          error: 'address can not be an array.'
+        })
+      }
+
+      // Reject if address is missing
+      if (!address) {
+        res.status(400)
+        return res.json({
+          success: false,
+          error: 'address is required.'
+        })
+      }
+
+      const result = await this.encryptionUseCases.getPublicKey({ address })
+
+      return res.status(200).json(result)
+    } catch (err) {
+      return this.handleError(err, res)
+    }
+  }
+
+  handleError (err, res) {
+    wlogger.error('Error in EncryptionRESTController:', err)
+
+    const status = err.status || 500
+    const message = err.message || 'Internal server error'
+
+    return res.status(status).json({ success: false, error: message })
+  }
+}
+
+export default EncryptionRESTController

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

@@ -0,0 +1,51 @@
+/*
+  REST API router for /encryption routes.
+*/
+
+import express from 'express'
+import EncryptionRESTController from './controller.js'
+
+class EncryptionRouter {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating Encryption REST Router.'
+      )
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating Encryption REST Router.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    this.encryptionController = new EncryptionRESTController(dependencies)
+
+    this.apiPrefix = (localConfig.apiPrefix || '').replace(/\/$/, '')
+    this.baseUrl = `${this.apiPrefix}/encryption`
+    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.encryptionController.root)
+    this.router.get('/publickey/:address', this.encryptionController.getPublicKey)
+
+    app.use(this.baseUrl, this.router)
+  }
+}
+
+export default EncryptionRouter

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

@@ -4,8 +4,9 @@
 
 import wlogger from '../../../adapters/wlogger.js'
 import BCHJS from '@psf/bch-js'
+import config from '../../../config/index.js'
 
-const bchjs = new BCHJS()
+const bchjs = new BCHJS({ restURL: config.restURL })
 
 class FulcrumRESTController {
   constructor (localConfig = {}) {

src/controllers/rest-api/index.js

@@ -10,8 +10,10 @@
 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 EncryptionRouter from './encryption/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'
@@ -69,12 +71,18 @@ class RESTControllers {
     const dsproofRouter = new DSProofRouter(dependencies)
     dsproofRouter.attach(app)
 
+    const encryptionRouter = new EncryptionRouter(dependencies)
+    encryptionRouter.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)
 

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/slp/controller.js

@@ -4,8 +4,9 @@
 
 import wlogger from '../../../adapters/wlogger.js'
 import BCHJS from '@psf/bch-js'
+import config from '../../../config/index.js'
 
-const bchjs = new BCHJS()
+const bchjs = new BCHJS({ restURL: config.restURL })
 
 class SlpRESTController {
   constructor (localConfig = {}) {
@@ -201,6 +202,7 @@ class SlpRESTController {
       const result = await this.slpUseCases.getTokenData({ tokenId, withTxHistory })
       return res.status(200).json(result)
     } catch (err) {
+      console.log('Error in /v6/slp/token/data getTokenData(): ', err)
       return this.handleError(err, res)
     }
   }

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/encryption-use-cases.js

@@ -0,0 +1,120 @@
+/*
+  Use cases for encryption-related operations.
+  Retrieves public keys from the blockchain for BCH addresses.
+*/
+
+// Global npm libraries
+import BCHJS from '@psf/bch-js'
+
+// Local libraries
+import wlogger from '../adapters/wlogger.js'
+import config from '../config/index.js'
+
+const bchjs = new BCHJS({ restURL: config.restURL })
+
+class EncryptionUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error('Adapters instance required when instantiating Encryption use cases.')
+    }
+
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error('UseCases instance required when instantiating Encryption use cases.')
+    }
+
+    // Allow bchjs to be injected for testing
+    this.bchjs = localConfig.bchjs || bchjs
+  }
+
+  /**
+   * Get the public key for a BCH address by searching the blockchain.
+   * Searches the transaction history of the address for a transaction input
+   * that contains the public key.
+   *
+   * @param {Object} params - Parameters object
+   * @param {string} params.address - BCH address (cash address or legacy format)
+   * @returns {Promise<Object>} Object with success status and publicKey if found
+   */
+  async getPublicKey ({ address }) {
+    try {
+      // Convert to cash address format
+      const cashAddr = this.bchjs.Address.toCashAddress(address)
+
+      // Get transaction history for the address
+      const txHistory = await this.useCases.fulcrum.getTransactions({ address: cashAddr })
+
+      // Extract just the TXIDs
+      const txids = txHistory.transactions.map((elem) => elem.tx_hash)
+
+      // Throw error if there is no transaction history
+      if (!txids || txids.length === 0) {
+        throw new Error('No transaction history.')
+      }
+
+      // Loop through the transaction history and search for the public key
+      for (let i = 0; i < txids.length; i++) {
+        const thisTx = txids[i]
+
+        // Get verbose transaction details
+        const txDetails = await this.useCases.rawtransactions.getRawTransaction({
+          txid: thisTx,
+          verbose: true
+        })
+
+        const vin = txDetails.vin
+
+        // Loop through each input
+        for (let j = 0; j < vin.length; j++) {
+          const thisVin = vin[j]
+
+          // Skip if no scriptSig (e.g., coinbase transactions)
+          if (!thisVin.scriptSig || !thisVin.scriptSig.asm) {
+            continue
+          }
+
+          // Extract the script signature
+          const scriptSig = thisVin.scriptSig.asm.split(' ')
+
+          // Extract the public key from the script signature (last element)
+          const pubKey = scriptSig[scriptSig.length - 1]
+
+          // Skip if pubKey is not a valid hex string (basic validation)
+          if (!pubKey || !/^[0-9a-fA-F]+$/.test(pubKey)) {
+            continue
+          }
+
+          try {
+            // Generate cash address from public key
+            const keyBuf = Buffer.from(pubKey, 'hex')
+            const ec = this.bchjs.ECPair.fromPublicKey(keyBuf)
+            const cashAddr2 = this.bchjs.ECPair.toCashAddress(ec)
+
+            // If public keys match, this is the correct public key
+            if (cashAddr === cashAddr2) {
+              return {
+                success: true,
+                publicKey: pubKey
+              }
+            }
+          } catch (err) {
+            // Skip invalid public keys - continue searching
+            continue
+          }
+        }
+      }
+
+      // Public key not found in any transaction
+      return {
+        success: false,
+        publicKey: 'not found'
+      }
+    } catch (err) {
+      wlogger.error('Error in EncryptionUseCases.getPublicKey()', err)
+      throw err
+    }
+  }
+}
+
+export default EncryptionUseCases

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

@@ -4,8 +4,12 @@
 
 import wlogger from '../adapters/wlogger.js'
 import BCHJS from '@psf/bch-js'
+import config from '../config/index.js'
 
-const bchjs = new BCHJS()
+const bchjs = new BCHJS({ 
+  restURL: config.restURL,
+  bearerToken: config.basicAuth.token
+})
 
 class FulcrumUseCases {
   constructor (localConfig = {}) {
@@ -53,7 +57,14 @@ class FulcrumUseCases {
   }
 
   async getTransactionDetails ({ txid }) {
-    return this.fulcrum.get(`electrumx/tx/data/${txid}`)
+    try {
+      const response = await this.fulcrum.get(`electrumx/tx/data/${txid}`)
+      // console.log(`getTransactionDetails() TXID ${txid}: ${JSON.stringify(response, null, 2)}`)
+      return response
+    } catch (err) {
+      wlogger.error('Error in FulcrumUseCases.getTransactionDetails()', err)
+      throw err
+    }
   }
 
   async getTransactionDetailsBulk ({ txids, verbose }) {

src/use-cases/index.js

@@ -8,8 +8,10 @@
 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 EncryptionUseCases from './encryption-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'
 
@@ -27,8 +29,15 @@ class UseCases {
     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 })
+
+    // Encryption use cases require access to other use cases (fulcrum, rawtransactions)
+    this.encryption = new EncryptionUseCases({
+      adapters: this.adapters,
+      useCases: this
+    })
   }
 
   // Run any startup Use Cases at the start of the app.

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/slp-use-cases.js

@@ -9,7 +9,7 @@ import SlpTokenMedia from 'slp-token-media'
 import axios from 'axios'
 import config from '../config/index.js'
 
-const bchjs = new BCHJS()
+const bchjs = new BCHJS({ restURL: config.restURL })
 
 class SlpUseCases {
   constructor (localConfig = {}) {
@@ -259,6 +259,7 @@ class SlpUseCases {
 
       return mutableCid
     } catch (err) {
+      console.log('Error in SlpUseCases.getMutableCid()', err)
       wlogger.error('Error in SlpUseCases.getMutableCid()', err)
       return false
     }
@@ -271,7 +272,9 @@ class SlpUseCases {
       }
 
       // Get transaction data
+      console.log('Decoding OP_RETURN for TXID: ', txid)
       const txData = await this.bchjs.Electrumx.txData(txid)
+      // console.log(`TXID ${txid}: ${JSON.stringify(txData, null, 2)}`)
       let data = false
 
       // Map the vout of the transaction in search of an OP_RETURN
@@ -291,6 +294,7 @@ class SlpUseCases {
 
       return data
     } catch (error) {
+      console.log('Error in SlpUseCases.decodeOpReturn()', error)
       wlogger.error('Error in SlpUseCases.decodeOpReturn()', error)
       throw error
     }

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

@@ -0,0 +1,203 @@
+/*
+  Unit tests for EncryptionRESTController.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import EncryptionRESTController from '../../../src/controllers/rest-api/encryption/controller.js'
+import { createMockRequest, createMockResponse, createMockRequestWithParams } from '../mocks/controller-mocks.js'
+
+describe('#encryption-controller.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+    mockUseCases = {
+      encryption: {
+        getPublicKey: sandbox.stub().resolves({
+          success: true,
+          publicKey: '02abc123def456789'
+        })
+      }
+    }
+
+    uut = new EncryptionRESTController({
+      adapters: mockAdapters,
+      useCases: mockUseCases
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new EncryptionRESTController({ useCases: mockUseCases })
+      }, /Adapters library required/)
+    })
+
+    it('should require encryption use cases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new EncryptionRESTController({ adapters: mockAdapters, useCases: {} })
+      }, /Encryption use cases required/)
+    })
+  })
+
+  describe('#root()', () => {
+    it('should return encryption status', async () => {
+      const req = createMockRequest()
+      const res = createMockResponse()
+
+      await uut.root(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, { status: 'encryption' })
+    })
+  })
+
+  describe('#getPublicKey()', () => {
+    it('should return public key on success', async () => {
+      const req = createMockRequestWithParams({
+        address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      })
+      const res = createMockResponse()
+
+      await uut.getPublicKey(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, {
+        success: true,
+        publicKey: '02abc123def456789'
+      })
+      assert.isTrue(mockUseCases.encryption.getPublicKey.calledOnce)
+      assert.isTrue(mockUseCases.encryption.getPublicKey.calledWith({
+        address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      }))
+    })
+
+    it('should return not found when public key is not found', async () => {
+      mockUseCases.encryption.getPublicKey.resolves({
+        success: false,
+        publicKey: 'not found'
+      })
+
+      const req = createMockRequestWithParams({
+        address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      })
+      const res = createMockResponse()
+
+      await uut.getPublicKey(req, res)
+
+      assert.equal(res.statusValue, 200)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        publicKey: 'not found'
+      })
+    })
+
+    it('should reject array addresses', async () => {
+      const req = createMockRequestWithParams({
+        address: ['addr1', 'addr2']
+      })
+      const res = createMockResponse()
+
+      await uut.getPublicKey(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        error: 'address can not be an array.'
+      })
+      assert.isFalse(mockUseCases.encryption.getPublicKey.called)
+    })
+
+    it('should reject missing address', async () => {
+      const req = createMockRequestWithParams({})
+      const res = createMockResponse()
+
+      await uut.getPublicKey(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        error: 'address is required.'
+      })
+      assert.isFalse(mockUseCases.encryption.getPublicKey.called)
+    })
+
+    it('should handle errors via handleError', async () => {
+      const error = new Error('No transaction history.')
+      error.status = 400
+      mockUseCases.encryption.getPublicKey.rejects(error)
+
+      const req = createMockRequestWithParams({
+        address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      })
+      const res = createMockResponse()
+
+      await uut.getPublicKey(req, res)
+
+      assert.equal(res.statusValue, 400)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        error: 'No transaction history.'
+      })
+    })
+
+    it('should default to 500 status for errors without status', async () => {
+      const error = new Error('Internal error')
+      mockUseCases.encryption.getPublicKey.rejects(error)
+
+      const req = createMockRequestWithParams({
+        address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      })
+      const res = createMockResponse()
+
+      await uut.getPublicKey(req, res)
+
+      assert.equal(res.statusValue, 500)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        error: 'Internal error'
+      })
+    })
+  })
+
+  describe('#handleError()', () => {
+    it('should use error status and message when provided', () => {
+      const error = new Error('Custom error')
+      error.status = 422
+      const res = createMockResponse()
+
+      uut.handleError(error, res)
+
+      assert.equal(res.statusValue, 422)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        error: 'Custom error'
+      })
+    })
+
+    it('should default to 500 and Internal server error', () => {
+      const error = {}
+      const res = createMockResponse()
+
+      uut.handleError(error, res)
+
+      assert.equal(res.statusValue, 500)
+      assert.deepEqual(res.jsonData, {
+        success: false,
+        error: 'Internal server 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/rest-api-index-unit.js

@@ -9,7 +9,9 @@ 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 EncryptionRouter from '../../../src/controllers/rest-api/encryption/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'
@@ -75,6 +77,10 @@ describe('#controllers/rest-api/index.js', () => {
         getMiningInfo: () => {},
         getNetworkHashPS: () => {}
       },
+      price: {
+        getBCHUSD: () => {},
+        getPsffppWritePrice: () => {}
+      },
       rawtransactions: {
         decodeRawTransaction: () => {},
         decodeRawTransactions: () => {},
@@ -95,6 +101,9 @@ describe('#controllers/rest-api/index.js', () => {
         getMutableCid: () => {},
         decodeOpReturn: () => {},
         getCIDData: () => {}
+      },
+      encryption: {
+        getPublicKey: () => {}
       }
     }
   })
@@ -124,8 +133,10 @@ describe('#controllers/rest-api/index.js', () => {
       const blockchainAttachStub = sandbox.stub(BlockchainRouter.prototype, 'attach')
       const controlAttachStub = sandbox.stub(ControlRouter.prototype, 'attach')
       const dsproofAttachStub = sandbox.stub(DSProofRouter.prototype, 'attach')
+      const encryptionAttachStub = sandbox.stub(EncryptionRouter.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({
@@ -142,10 +153,14 @@ describe('#controllers/rest-api/index.js', () => {
       assert.equal(controlAttachStub.getCall(0).args[0], app)
       assert.isTrue(dsproofAttachStub.calledOnce)
       assert.equal(dsproofAttachStub.getCall(0).args[0], app)
+      assert.isTrue(encryptionAttachStub.calledOnce)
+      assert.equal(encryptionAttachStub.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)

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

@@ -0,0 +1,247 @@
+/*
+  Unit tests for EncryptionUseCases.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import EncryptionUseCases from '../../../src/use-cases/encryption-use-cases.js'
+
+describe('#encryption-use-cases.js', () => {
+  let sandbox
+  let mockAdapters
+  let mockUseCases
+  let mockBchjs
+  let uut
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = {}
+
+    // Mock bchjs
+    mockBchjs = {
+      Address: {
+        toCashAddress: sandbox.stub().returns('bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf')
+      },
+      ECPair: {
+        fromPublicKey: sandbox.stub().returns({}),
+        toCashAddress: sandbox.stub().returns('bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf')
+      }
+    }
+
+    // Mock use cases
+    mockUseCases = {
+      fulcrum: {
+        getTransactions: sandbox.stub().resolves({
+          transactions: [
+            { tx_hash: 'abc123def456' }
+          ]
+        })
+      },
+      rawtransactions: {
+        getRawTransaction: sandbox.stub().resolves({
+          vin: [
+            {
+              scriptSig: {
+                asm: 'signature 02abc123def456789'
+              }
+            }
+          ]
+        })
+      }
+    }
+
+    uut = new EncryptionUseCases({
+      adapters: mockAdapters,
+      useCases: mockUseCases,
+      bchjs: mockBchjs
+    })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new EncryptionUseCases({ useCases: mockUseCases })
+      }, /Adapters instance required/)
+    })
+
+    it('should require useCases', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new EncryptionUseCases({ adapters: mockAdapters })
+      }, /UseCases instance required/)
+    })
+  })
+
+  describe('#getPublicKey()', () => {
+    it('should return public key when found', async () => {
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isTrue(result.success)
+      assert.equal(result.publicKey, '02abc123def456789')
+      assert.isTrue(mockBchjs.Address.toCashAddress.calledOnce)
+      assert.isTrue(mockUseCases.fulcrum.getTransactions.calledOnce)
+      assert.isTrue(mockUseCases.rawtransactions.getRawTransaction.calledOnce)
+    })
+
+    it('should return not found when public key does not match', async () => {
+      // Make the ECPair.toCashAddress return a different address
+      mockBchjs.ECPair.toCashAddress.returns('bitcoincash:qqq000000000000000000000000000000000000000')
+
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isFalse(result.success)
+      assert.equal(result.publicKey, 'not found')
+    })
+
+    it('should throw error when no transaction history', async () => {
+      mockUseCases.fulcrum.getTransactions.resolves({
+        transactions: []
+      })
+
+      try {
+        await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.equal(err.message, 'No transaction history.')
+      }
+    })
+
+    it('should handle transactions without scriptSig', async () => {
+      mockUseCases.rawtransactions.getRawTransaction.resolves({
+        vin: [
+          { txid: 'coinbase' } // No scriptSig
+        ]
+      })
+
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isFalse(result.success)
+      assert.equal(result.publicKey, 'not found')
+    })
+
+    it('should handle invalid public key hex gracefully', async () => {
+      mockUseCases.rawtransactions.getRawTransaction.resolves({
+        vin: [
+          {
+            scriptSig: {
+              asm: 'signature NOT_VALID_HEX'
+            }
+          }
+        ]
+      })
+
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isFalse(result.success)
+      assert.equal(result.publicKey, 'not found')
+    })
+
+    it('should handle ECPair.fromPublicKey throwing error', async () => {
+      mockBchjs.ECPair.fromPublicKey.throws(new Error('Invalid public key'))
+
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isFalse(result.success)
+      assert.equal(result.publicKey, 'not found')
+    })
+
+    it('should search through multiple transactions', async () => {
+      // First transaction has no matching public key
+      mockUseCases.fulcrum.getTransactions.resolves({
+        transactions: [
+          { tx_hash: 'tx1' },
+          { tx_hash: 'tx2' }
+        ]
+      })
+
+      // Return different data for each tx - first tx has input with non-matching key
+      mockUseCases.rawtransactions.getRawTransaction
+        .onFirstCall().resolves({
+          vin: [
+            {
+              scriptSig: {
+                asm: 'sig 02aaa111bbb222ccc'
+              }
+            }
+          ]
+        })
+        .onSecondCall().resolves({
+          vin: [
+            {
+              scriptSig: {
+                asm: 'sig 02abc123def456789'
+              }
+            }
+          ]
+        })
+
+      // First tx doesn't match, second tx matches
+      mockBchjs.ECPair.toCashAddress
+        .onFirstCall().returns('bitcoincash:qqq000000000000000000000000000000000000000')
+        .onSecondCall().returns('bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf')
+
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isTrue(result.success)
+      assert.equal(result.publicKey, '02abc123def456789')
+      assert.equal(mockUseCases.rawtransactions.getRawTransaction.callCount, 2)
+    })
+
+    it('should search through multiple inputs in a transaction', async () => {
+      mockUseCases.rawtransactions.getRawTransaction.resolves({
+        vin: [
+          {
+            scriptSig: {
+              asm: 'sig 02aaa111bbb222ccc'
+            }
+          },
+          {
+            scriptSig: {
+              asm: 'sig 02abc123def456789'
+            }
+          }
+        ]
+      })
+
+      // First input doesn't match, second input matches
+      mockBchjs.ECPair.toCashAddress
+        .onFirstCall().returns('bitcoincash:qqq000000000000000000000000000000000000000')
+        .onSecondCall().returns('bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf')
+
+      const result = await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+
+      assert.isTrue(result.success)
+      assert.equal(result.publicKey, '02abc123def456789')
+    })
+
+    it('should propagate fulcrum errors', async () => {
+      const error = new Error('Fulcrum API error')
+      mockUseCases.fulcrum.getTransactions.rejects(error)
+
+      try {
+        await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.equal(err.message, 'Fulcrum API error')
+      }
+    })
+
+    it('should propagate rawtransactions errors', async () => {
+      const error = new Error('RawTransactions API error')
+      mockUseCases.rawtransactions.getRawTransaction.rejects(error)
+
+      try {
+        await uut.getPublicKey({ address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf' })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert.equal(err.message, 'RawTransactions API error')
+      }
+    })
+  })
+})

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

@@ -24,7 +24,7 @@ describe('#fulcrum-use-cases.js', () => {
     }
 
     // Create a mock BCHJS instance with stubbed sortAllTxs method
-    const mockBchjs = new BCHJS()
+    const mockBchjs = new BCHJS({ restURL: 'http://localhost:5942/v6/' })
     if (!mockBchjs.Electrumx) {
       mockBchjs.Electrumx = {}
     }

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/slp-use-cases-unit.js

@@ -32,7 +32,7 @@ describe('#slp-use-cases.js', () => {
     }
 
     // Create mock BCHJS
-    mockBchjs = new BCHJS()
+    mockBchjs = new BCHJS({ restURL: 'http://localhost:5942/v6/' })
     mockBchjs.Electrumx = {
       txData: sandbox.stub().resolves({
         details: {