psf-bch-api 1.2.0 → 7.1.0

package/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

package/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

package/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

package/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

package/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()
+}

package/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

package/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

package/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