psf-bch-api 1.1.0

package/src/controllers/timer-controller.js

@@ -0,0 +1,72 @@
+/*
+  Timer-based controller functions.
+  This controller handles scheduled tasks and timers.
+*/
+
+// Local libraries
+import wlogger from '../adapters/wlogger.js'
+
+class TimerController {
+  constructor (localConfig = {}) {
+    // Dependency Injection
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating TimerController.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating TimerController.'
+      )
+    }
+
+    // Constants
+    this.SHUTDOWN_INTERVAL_MS = 10 * 60 * 1000 // 10 minutes in milliseconds
+    this.LIVENESS_CHECK_INTERVAL_MS = 1 * 60 * 1000 // 1 minute in milliseconds
+
+    // Handlers
+    this.shutdownHandler = null
+    this.livenessCheckHandler = null
+
+    // Bind 'this' object to all subfunctions
+    this.startTimerControllers = this.startTimerControllers.bind(this)
+    this.stopTimerControllers = this.stopTimerControllers.bind(this)
+    this.shutdown = this.shutdown.bind(this)
+    this.livenessCheck = this.livenessCheck.bind(this)
+  }
+
+  startTimerControllers () {
+    console.log('Starting Timer Controllers.')
+
+    // this.shutdownHandler = setInterval(() => {
+    //   this.shutdown()
+    // }, this.SHUTDOWN_INTERVAL_MS)
+
+    // this.livenessCheckHandler = setInterval(() => {
+    //   this.livenessCheck()
+    // }, this.LIVENESS_CHECK_INTERVAL_MS)
+  }
+
+  stopTimerControllers () {
+    console.log('Stopping Timer Controllers.')
+
+    clearInterval(this.shutdownHandler)
+    this.shutdownHandler = null
+    clearInterval(this.livenessCheckHandler)
+    this.livenessCheckHandler = null
+  }
+
+  // Execute the shutdown callback
+  shutdown () {
+    wlogger.info(`TimerController: Shutting down application at ${new Date().toISOString()}, depending on process manager to restart application.`)
+    process.exit(1)
+  }
+
+  livenessCheck () {
+    wlogger.info(`TimerController: Liveness check at ${new Date().toISOString()}`)
+  }
+}
+
+export default TimerController

package/src/entities/event.js

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

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

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

package/src/use-cases/index.js

@@ -0,0 +1,29 @@
+/*
+  This is a top-level library that encapsulates all the additional Use Cases.
+  The concept of Use Cases comes from Clean Architecture:
+  https://troutsblog.com/blog/clean-architecture
+*/
+
+// Local libraries
+import BlockchainUseCases from './full-node-blockchain-use-cases.js'
+
+class UseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of adapters must be passed in when instantiating Use Cases library.'
+      )
+    }
+
+    this.blockchain = new BlockchainUseCases({ adapters: this.adapters })
+  }
+
+  // Run any startup Use Cases at the start of the app.
+  async start () {
+    console.log('Use Cases have been started.')
+    return true
+  }
+}
+
+export default UseCases

package/test/integration/api/event-integration.js

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