psf-bch-api 1.1.0

package/src/adapters/full-node-rpc.js

@@ -0,0 +1,133 @@
+/*
+  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, options = {}) {
+    const { isProUser = false } = options
+    const freemiumLimit = Number(this.config.fullNode?.freemiumArrayLimit || 20)
+    const proLimit = Number(this.config.fullNode?.proArrayLimit || freemiumLimit)
+
+    const limit = isProUser ? proLimit : freemiumLimit
+    return length <= limit
+  }
+
+  _formatError (message, status = 500) {
+    return {
+      message: message || 'Internal server error',
+      status: status || 500
+    }
+  }
+}
+
+export default FullNodeRPCAdapter

package/src/adapters/index.js

@@ -0,0 +1,217 @@
+/*
+  This is a top-level library that encapsulates all the additional Adapters.
+  The concept of Adapters comes from Clean Architecture:
+  https://troutsblog.com/blog/clean-architecture
+*/
+
+// Load individual adapter libraries.
+// import NostrRelayAdapter from './nostr-relay.js'
+import FullNodeRPCAdapter from './full-node-rpc.js'
+import config from '../config/index.js'
+
+class Adapters {
+  constructor (localConfig = {}) {
+    // Encapsulate dependencies
+    this.config = config
+
+    // Determine relay URLs: prefer localConfig, fall back to config
+    // let relayUrls = []
+    // if (localConfig.relayUrls && Array.isArray(localConfig.relayUrls)) {
+    //   relayUrls = localConfig.relayUrls
+    // } else if (localConfig.relayUrl) {
+    //   // Backward compatibility: single relay URL
+    //   relayUrls = [localConfig.relayUrl]
+    // } else {
+    //   relayUrls = config.nostrRelayUrls
+    // }
+
+    // Create one adapter per relay URL
+    // this.nostrRelays = relayUrls.map(relayUrl => new NostrRelayAdapter({ relayUrl }))
+
+    // 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 })
+  }
+
+  async start () {
+    // try {
+    // Connect to all Nostr relays concurrently
+    // const connectPromises = this.nostrRelays.map(async (relay, index) => {
+    //   try {
+    //     await relay.connect()
+    //     console.log(`Nostr relay adapter ${index + 1}/${this.nostrRelays.length} started: ${relay.relayUrl}`)
+    //     return { success: true, relay }
+    //   } catch (err) {
+    //     console.error(`Failed to connect to relay ${relay.relayUrl}:`, err.message)
+    //     return { success: false, relay, error: err }
+    //   }
+    // })
+
+    // const results = await Promise.allSettled(connectPromises)
+
+    // const successful = results.filter(r => r.status === 'fulfilled' && r.value.success).length
+    // const failed = results.length - successful
+
+    // if (successful === 0) {
+    //   throw new Error('Failed to connect to any Nostr relay')
+    // }
+
+    // if (failed > 0) {
+    //   console.warn(`Connected to ${successful}/${this.nostrRelays.length} relays. Some relays failed to connect.`)
+    // } else {
+    //   console.log(`All ${successful} Nostr relay adapters started successfully.`)
+    // }
+
+    return true
+    // } catch (err) {
+    //   console.error('Error in adapters/index.js/start()')
+    //   throw err
+    // }
+  }
+
+  /**
+   * Get all relay adapters
+   * @returns {Array<NostrRelayAdapter>}
+   */
+  getRelays () {
+    return this.nostrRelays
+  }
+
+  /**
+   * Broadcast an event to all relays
+   * @param {Object} event - Event object to broadcast
+   * @returns {Promise<Array>} Array of results from each relay: { accepted, message, relayUrl }
+   */
+  async broadcastEvent (event) {
+    const broadcastPromises = this.nostrRelays.map(async (relay) => {
+      try {
+        const result = await relay.sendEvent(event)
+        return {
+          accepted: result.accepted,
+          message: result.message || '',
+          relayUrl: relay.relayUrl,
+          success: true
+        }
+      } catch (err) {
+        return {
+          accepted: false,
+          message: err.message || 'Error broadcasting to relay',
+          relayUrl: relay.relayUrl,
+          success: false,
+          error: err
+        }
+      }
+    })
+
+    return Promise.allSettled(broadcastPromises).then(results => {
+      return results.map((result, index) => {
+        if (result.status === 'fulfilled') {
+          return result.value
+        } else {
+          return {
+            accepted: false,
+            message: result.reason?.message || 'Unknown error',
+            relayUrl: this.nostrRelays[index].relayUrl,
+            success: false,
+            error: result.reason
+          }
+        }
+      })
+    })
+  }
+
+  /**
+   * Query all relays concurrently and merge results
+   * @param {Array} filters - Array of filter objects
+   * @param {string} subscriptionId - Unique subscription ID (will be modified per relay)
+   * @returns {Promise<Array>} Merged and de-duplicated array of events
+   */
+  async queryAllRelays (filters, subscriptionId) {
+    // Create unique subscription IDs for each relay
+    const subscriptionIds = this.nostrRelays.map((relay, index) =>
+      `${subscriptionId}-relay-${index}`
+    )
+
+    // Collect events from all relays
+    const allEvents = []
+    const relayStatuses = this.nostrRelays.map(() => ({
+      eoseReceived: false,
+      closedReceived: false,
+      closedMessage: ''
+    }))
+
+    // Query all relays concurrently
+    const queryPromises = this.nostrRelays.map(async (relay, index) => {
+      const subscriptionIdForRelay = subscriptionIds[index]
+      const status = relayStatuses[index]
+
+      // Create handlers for this relay
+      const handlers = {
+        onEvent: (event) => {
+          allEvents.push(event)
+        },
+        onEose: () => {
+          status.eoseReceived = true
+        },
+        onClosed: (message) => {
+          status.closedReceived = true
+          status.closedMessage = message
+        }
+      }
+
+      try {
+        await relay.sendReq(subscriptionIdForRelay, filters, handlers)
+
+        // Wait for EOSE or CLOSED with timeout
+        const timeout = 30000 // 30 seconds
+        const startTime = Date.now()
+
+        while (!status.eoseReceived && !status.closedReceived && (Date.now() - startTime) < timeout) {
+          await new Promise(resolve => setTimeout(resolve, 100))
+        }
+
+        // Clean up subscription - always try to close, even if EOSE didn't come
+        try {
+          await relay.sendClose(subscriptionIdForRelay)
+        } catch (err) {
+          // Ignore close errors
+        }
+
+        if (status.closedReceived) {
+          throw new Error(`Subscription closed on ${relay.relayUrl}: ${status.closedMessage}`)
+        }
+
+        // If EOSE never came but timeout expired, that's OK - we proceed with what we got
+        if (!status.eoseReceived && (Date.now() - startTime) >= timeout) {
+          // Timeout reached without EOSE - proceed anyway with events collected so far
+        }
+      } catch (err) {
+        // Ensure cleanup even on error
+        try {
+          await relay.sendClose(subscriptionIdForRelay)
+        } catch (closeErr) {
+          // Ignore close errors
+        }
+        // Log error but don't fail the entire query
+        console.warn(`Query failed for relay ${relay.relayUrl}:`, err.message)
+      }
+    })
+
+    // Wait for all queries to complete
+    await Promise.allSettled(queryPromises)
+
+    // Merge and de-duplicate events by event ID
+    const eventMap = new Map()
+    allEvents.forEach(event => {
+      if (event && event.id && !eventMap.has(event.id)) {
+        eventMap.set(event.id, event)
+      }
+    })
+
+    return Array.from(eventMap.values())
+  }
+}
+
+export default Adapters

package/src/adapters/wlogger.js

@@ -0,0 +1,79 @@
+/*
+  Instantiates and configures the Winston logging library. This utility library
+  can be called by other parts of the application to conveniently tap into the
+  logging library.
+*/
+
+// Global npm libraries
+import winston from 'winston'
+import 'winston-daily-rotate-file'
+
+// Local libraries
+import config from '../config/index.js'
+
+// Hack to get __dirname back.
+// https://blog.logrocket.com/alternatives-dirname-node-js-es-modules/
+import * as url from 'url'
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+let _this = null
+
+class Wlogger {
+  constructor (localConfig = {}) {
+    this.config = config
+
+    // Configure daily-rotation transport.
+    this.transport = new winston.transports.DailyRotateFile({
+      filename: `${__dirname.toString()}/../../logs/rest2nostr-${
+        this.config.env
+      }-%DATE%.log`,
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: false,
+      maxSize: '1m', // 1 megabyte
+      maxFiles: '5d', // 5 days
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json()
+      )
+    })
+
+    this.transport.on('rotate', this.notifyRotation)
+
+    // This controls what goes into the log FILES
+    this.wlogger = winston.createLogger({
+      level: this.config.logLevel || 'info',
+      format: winston.format.json(),
+      transports: [
+        this.transport
+      ]
+    })
+
+    // Bind 'this' object to all methods
+    this.notifyRotation = this.notifyRotation.bind(this)
+    this.outputToConsole = this.outputToConsole.bind(this)
+
+    _this = this
+  }
+
+  notifyRotation (oldFilename, newFilename) {
+    _this.wlogger.info('Rotating log files')
+  }
+
+  outputToConsole () {
+    this.wlogger.add(
+      new winston.transports.Console({
+        format: winston.format.simple(),
+        level: this.config.logLevel || 'info'
+      })
+    )
+  }
+}
+
+const logger = new Wlogger()
+
+// Allow the logger to write to the console.
+logger.outputToConsole()
+
+const wlogger = logger.wlogger
+
+export { wlogger as default, Wlogger }

package/src/config/env/common.js

@@ -0,0 +1,64 @@
+/*
+  This file is used to store unsecure, application-specific data common to all
+  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
+
+export default {
+  // Server port
+  port: process.env.PORT || 5942,
+
+  // Environment
+  env: process.env.NODE_ENV || 'development',
+
+  // 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]
+    }
+
+    // Default
+    return ['wss://nostr-relay.psfoundation.info', 'wss://relay.damus.io']
+  })(),
+
+  // 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'
+  },
+
+  // Version
+  version
+}

package/src/config/env/development.js

@@ -0,0 +1,7 @@
+/*
+  These are the environment settings for the DEVELOPMENT environment.
+*/
+
+export default {
+  env: 'development'
+}

package/src/config/env/production.js

@@ -0,0 +1,7 @@
+/*
+  These are the environment settings for the PRODUCTION environment.
+*/
+
+export default {
+  env: 'production'
+}

package/src/config/index.js

@@ -0,0 +1,14 @@
+import common from './env/common.js'
+
+import development from './env/development.js'
+import production from './env/production.js'
+
+const env = process.env.NODE_ENV || 'development'
+console.log(`Loading config for this environment: ${env}`)
+
+let config = development
+if (env === 'production') {
+  config = production
+}
+
+export default Object.assign({}, common, config)

package/src/controllers/index.js

@@ -0,0 +1,56 @@
+/*
+  This is a top-level library that encapsulates all the additional Controllers.
+  The concept of Controllers comes from Clean Architecture:
+  https://troutsblog.com/blog/clean-architecture
+*/
+
+// Local libraries
+import Adapters from '../adapters/index.js'
+import UseCases from '../use-cases/index.js'
+import RESTControllers from './rest-api/index.js'
+import TimerController from './timer-controller.js'
+import config from '../config/index.js'
+
+class Controllers {
+  constructor (localConfig = {}) {
+    // Encapsulate dependencies
+    this.adapters = new Adapters(localConfig)
+    this.useCases = new UseCases({ adapters: this.adapters })
+    this.config = config
+    this.timerController = new TimerController({ adapters: this.adapters, useCases: this.useCases })
+
+    // Bind 'this' object to all subfunctions
+    this.initAdapters = this.initAdapters.bind(this)
+    this.initUseCases = this.initUseCases.bind(this)
+    this.attachRESTControllers = this.attachRESTControllers.bind(this)
+  }
+
+  // Spin up any adapter libraries that have async startup needs.
+  async initAdapters () {
+    await this.adapters.start()
+  }
+
+  // Run any Use Cases to startup the app.
+  async initUseCases () {
+    await this.useCases.start()
+  }
+
+  // Initialize all the controllers.
+  async initControllers () {
+    this.timerController.startTimerControllers()
+  }
+
+  // Top-level function for this library.
+  // Start the various Controllers and attach them to the app.
+  attachRESTControllers (app) {
+    const restControllers = new RESTControllers({
+      adapters: this.adapters,
+      useCases: this.useCases
+    })
+
+    // Attach the REST API Controllers to the Express app.
+    restControllers.attachRESTControllers(app)
+  }
+}
+
+export default Controllers