Merge pull request #121 from Permissionless-Software-Foundation/dh-track-counter-offrs

feat(offers): Track Counter Offers

config/env/common.js

@@ -47,8 +47,8 @@ export default {
   useFullStackCash: process.env.USE_FULLSTACKCASH ? true : false,
   consumerUrl: process.env.CONSUMER_URL
     ? process.env.CONSUMER_URL
-    // : 'https://free-bch.fullstack.cash',
-    : 'https://dev-consumer.psfoundation.info',
+    : 'https://free-bch.fullstack.cash',
+  // : 'https://dev-consumer.psfoundation.info',
   // : 'https://wa-usa-bch-consumer.fullstackcash.nl',
 
   // P2WDB URL that will accept API calls from the p2wdb npm library.
@@ -191,5 +191,9 @@ export default {
   disableNewAccounts: process.env.DISABLE_NEW_ACCOUNTS ? true : false,
 
   // Admin password
-  adminPassword: process.env.ADMIN_PASSWORD
+  adminPassword: process.env.ADMIN_PASSWORD,
+
+  // The Operator of BCH DEX can elect to receive a percentage of each sale.
+  operatorAddress: process.env.OPERATOR_ADDRESS ? process.env.OPERATOR_ADDRESS : 'bitcoincash:qqsrke9lh257tqen99dkyy2emh4uty0vky9y0z0lsr',
+  operatorPercentage: process.env.OPERATOR_PERCENTAGE ? parseFloat(process.env.OPERATOR_PERCENTAGE) : 2.0
 }

package.json

@@ -10,6 +10,7 @@
     "test:all": "export BCH_DEX=test && c8 --reporter=text mocha --exit --timeout 15000 --recursive test/unit test/e2e/automated/",
     "test:unit": "export BCH_DEX=test && c8 --reporter=text mocha --exit --timeout 15000 --recursive test/unit/",
     "test:e2e:auto": "export BCH_DEX=test && mocha --exit --timeout 30000 test/e2e/automated/",
+    "start:e2e:server": "export BCH_DEX=test && node index.js",
     "test:integration": "export BCH_DEX=test && mocha --exit --timeout 45000 --recursive test/integration",
     "test:temp": "export BCH_DEX=test && mocha --exit --timeout 15000 -g '#rate-limit' test/unit/json-rpc/",
     "lint": "standard --env mocha --fix",

src/adapters/bch.js

@@ -66,6 +66,9 @@ class Bch {
   //   }
   // }
 
+  /** DEV NOTE: This function are deprecated.?
+   *  https://github.com/Permissionless-Software-Foundation/bch-message-lib/pull/41
+  */
   async getMerit (slpAddr) {
     try {
       if (!slpAddr || typeof slpAddr !== 'string') {

src/adapters/localdb/index.js

@@ -9,6 +9,9 @@ import Order from './models/order.js'
 import Offer from './models/offer.js'
 import Usage from './models/usage.js'
 import SmAccount from './models/smAccount.js'
+import DeletedChat from './models/deletedChat.js'
+import DeletedPost from './models/deletedPost.js'
+import CounterOffer from './models/counter-offer.js'
 
 class LocalDB {
   constructor () {
@@ -19,6 +22,9 @@ class LocalDB {
     this.Offer = Offer
     this.Usage = Usage
     this.SmAccount = SmAccount
+    this.DeletedChat = DeletedChat
+    this.DeletedPost = DeletedPost
+    this.CounterOffer = CounterOffer
   }
 }
 

src/adapters/localdb/models/counter-offer.js

@@ -0,0 +1,11 @@
+import mongoose from 'mongoose'
+
+const CounterOffer = new mongoose.Schema({
+  nostrEventId: { type: String, required: true }, // Nostr Event Id.
+  takerAddr: { type: String, default: null },
+  takerNpub: { type: String, default: null },
+  counterOfferAddr: { type: String, default: null },
+  counterOfferUtxo: { type: String, default: null }
+})
+
+export default mongoose.model('counterOffer', CounterOffer)

src/adapters/localdb/models/deletedChat.js

@@ -0,0 +1,16 @@
+/*
+  Database model for tracking deleted Nostr chat messages.
+*/
+
+import mongoose from 'mongoose'
+
+const DeletedChat = new mongoose.Schema({
+  eventId: { type: String, required: true, default: null }, // Event ID of the deleted message.
+  npub: { type: String, default: null }, // Nostr public key of the user who created the message.
+  bchAddr: { type: String, default: null }, // bch address of the user who created the message.
+  pubkey: { type: String, default: null }, // Nostr public key of the user who created the message.
+  createdAt: { type: Date, default: Date.now },
+  updatedAt: { type: Date, default: Date.now }
+})
+
+export default mongoose.model('deletedChat', DeletedChat)

src/adapters/localdb/models/deletedPost.js

@@ -0,0 +1,16 @@
+/*
+  Database model for tracking deleted Nostr posts.
+*/
+
+import mongoose from 'mongoose'
+
+const DeletedPost = new mongoose.Schema({
+  eventId: { type: String, required: true, default: null }, // Event ID of the deleted post.
+  npub: { type: String, default: null }, // Nostr public key of the user who created the post.
+  bchAddr: { type: String, default: null }, // bch address of the user who created the post.
+  pubkey: { type: String, default: null }, // Nostr public key of the user who created the post.
+  createdAt: { type: Date, default: Date.now },
+  updatedAt: { type: Date, default: Date.now }
+})
+
+export default mongoose.model('deletedPost', DeletedPost)

src/adapters/localdb/models/offer.js

@@ -18,6 +18,7 @@ const Offer = new mongoose.Schema({
   p2wdbHash: { type: String },
   offerStatus: { type: String },
   makerAddr: { type: String },
+  makerNpub: { type: String, default: null },
 
   // Authentication data
   signature: { type: String },
@@ -35,8 +36,20 @@ const Offer = new mongoose.Schema({
   lokadId: { type: String },
   messageType: { type: Number },
   messageClass: { type: Number },
-  nostrEventId: { type: String } // Nostr Event Id.
+  nostrEventId: { type: String }, // Nostr Event Id.
 
+  // Operator fee and address
+  operatorAddress: { type: String },
+  operatorPercentage: { type: Number },
+
+  // Token Data
+  immutableDataCid: { type: String, default: null },
+  mutableDataCid: { type: String, default: null },
+  tokenIconUrl: { type: String, default: null },
+  tokenCategories: { type: Array, default: [] },
+  tokenTags: { type: Array, default: [] },
+  userDataStr: { type: String }, // Token user data
+  lastUpdatedTokenData: { type: String, default: null } // ISO timestamp of the last time token data was updated.
 })
 
 export default mongoose.model('offer', Offer)

src/adapters/localdb/models/order.js

@@ -24,6 +24,7 @@ const Order = new mongoose.Schema({
   p2wdbTxid: { type: String },
   p2wdbHash: { type: String },
   makerAddr: { type: String, required: true },
+  makerNpub: { type: String, required: true },
 
   // Authentication data
   signature: { type: String },
@@ -43,7 +44,11 @@ const Order = new mongoose.Schema({
   // Additional properties found in createOrder
   dataType: { type: String, required: true },
 
-  userId: { type: String, required: true }
+  userId: { type: String, required: true },
+
+  // Operator fee and address
+  operatorAddress: { type: String },
+  operatorPercentage: { type: Number }
 })
 
 export default mongoose.model('order', Order)

src/adapters/nostr.js

@@ -7,6 +7,8 @@ import BchNostr from 'bch-nostr'
 import { RelayPool } from 'nostr'
 import RetryQueue from '@chris.troutner/retry-queue'
 import * as nip19 from 'nostr-tools/nip19'
+import { base58_to_binary as base58Tobinary } from 'base58-js'
+import { getPublicKey } from 'nostr-tools/pure'
 
 class NostrAdapter {
   constructor (localConfig = { nostrRelay: '', nostrTopic: '' }) {
@@ -44,6 +46,7 @@ class NostrAdapter {
     this.npub2pubkey = this.npub2pubkey.bind(this)
     this.readGlobalFeed = this.readGlobalFeed.bind(this)
     this.getFollowers = this.getFollowers.bind(this)
+    this.privKeyToNpub = this.privKeyToNpub.bind(this)
   }
 
   // Create nostr keys.
@@ -247,6 +250,31 @@ class NostrAdapter {
       throw error
     }
   }
+
+  // Convert a BCH private key (WIF) to a Nostr npub.
+  privKeyToNpub (privKey) {
+    try {
+      if (!privKey || typeof privKey !== 'string') {
+        throw new Error('privKey must be a string!')
+      }
+      // Extract the privaty key from the WIF, using this guide:
+      // https://learnmeabitcoin.com/technical/keys/private-key/wif/
+      const wifBuf = base58Tobinary(privKey)
+      const privBuf = wifBuf.slice(1, 33)
+      // console.log('privBuf: ', privBuf)
+
+      const nostrPubKey = getPublicKey(privBuf)
+      // console.log('nostrPubKey: ', nostrPubKey)
+      // Convert pubkey to npub
+      const nostrNpub = nip19.npubEncode(nostrPubKey)
+      // console.log('nostrNpub: ', nostrNpub)
+
+      return nostrNpub
+    } catch (error) {
+      console.log(`Error in nostr.js/privKeyToNpub() ${error.message} `)
+      throw error
+    }
+  }
 }
 
 export default NostrAdapter

src/adapters/wallet.js

@@ -34,6 +34,7 @@ class WalletAdapter {
     this.config = config
     this.bitcoinJs = bitcoinJs
     this.BchWallet = BchWallet
+    this.BchTokenSweep = BchTokenSweep
     this.bchWallet = {} // Will be replaced when initialized.
     // this.advancedConfig = localConfig.advancedConfig
     this.retryQueue = new RetryQueue({
@@ -55,6 +56,7 @@ class WalletAdapter {
     this.completeTx = this.completeTx.bind(this)
     this.reclaimTokens = this.reclaimTokens.bind(this)
     this.moveTokensFromCustomWallet = this.moveTokensFromCustomWallet.bind(this)
+    this.cid2json = this.cid2json.bind(this)
   }
 
   // Open the wallet file, or create one if the file doesn't exist.
@@ -205,7 +207,9 @@ class WalletAdapter {
   // Generate a cryptographic signature, required to write to the P2WDB.
   async generateSignature (message) {
     try {
-      // TODO: Add input validation for message.
+      if (!message || typeof message !== 'string') {
+        throw new Error('message is required!')
+      }
 
       const privKey = this.bchWallet.walletInfo.privateKey
 
@@ -370,6 +374,12 @@ class WalletAdapter {
   async moveTokens (inObj = {}) {
     try {
       const { tokenId, qty } = inObj
+      if (!tokenId || typeof tokenId !== 'string') {
+        throw new Error('tokenId must be a string!')
+      }
+      if (!qty || typeof qty !== 'number') {
+        throw new Error('qty must be a number!')
+      }
 
       const keyPair = await this.getKeyPair()
       console.log('keyPair: ', keyPair)
@@ -392,6 +402,10 @@ class WalletAdapter {
         x => x.tokenId === tokenId
       )
 
+      if (tokenUtxos.length === 0) {
+        throw new Error('tokenId not found!')
+      }
+
       const txid = await this.bchWallet.sendTokens(receiver, 3)
 
       const utxoInfo = {
@@ -412,6 +426,10 @@ class WalletAdapter {
   // generate a segregated UTXO.
   async moveBch (amountSat) {
     try {
+      if (!amountSat) {
+        throw new Error('amountSat is required!')
+      }
+
       const keyPair = await this.getKeyPair()
       console.log('keyPair: ', keyPair)
 
@@ -444,6 +462,10 @@ class WalletAdapter {
   // representing the transaction.
   async deseralizeTx (txHex) {
     try {
+      // Input validation
+      if (!txHex || typeof txHex !== 'string') {
+        throw new Error('hex must be a string!')
+      }
       // Ensure the URL points at FullStack.cash, since the web 3 infra does not
       // yet support this call.
       const oldUrl = this.bchWallet.bchjs.RawTransactions.restURL
@@ -555,8 +577,12 @@ class WalletAdapter {
 
   // Given an Order database object, this function sends the tokens from the
   // HD index where they are stored, back to the root address of the wallet.
-  async reclaimTokens (orderData) {
+  async reclaimTokens (orderData = {}) {
     try {
+      if (!orderData.hdIndex) {
+        throw new Error('orderData.hdIndex is required!')
+      }
+
       // Get the key pair from the Order.
       const keyPair = await this.getKeyPair(orderData.hdIndex)
       console.log('keyPair: ', keyPair)
@@ -576,7 +602,7 @@ class WalletAdapter {
       // const txid = await tempWallet.sendTokens(receiver)
 
       // Sweep the tokens to the root address.
-      const sweeper = new BchTokenSweep(
+      const sweeper = new this.BchTokenSweep(
         keyPair.wif,
         this.bchWallet.walletInfo.privateKey,
         this.bchWallet,
@@ -652,6 +678,25 @@ class WalletAdapter {
       throw err
     }
   }
+
+  async cid2json (urlOrCid) {
+    try {
+      // Input validation
+      if (!urlOrCid || typeof urlOrCid !== 'string') {
+        throw new Error('urlOrCid must be a string!')
+      }
+      // Extract the cid from the url or cid.
+      const cid = urlOrCid.split('/').pop()
+      console.log('cid to json: ', cid)
+      const jsonRes = await this.bchWallet.cid2json({ cid })
+      const json = jsonRes.json
+      // console.log('json: ', json)
+      return json
+    } catch (err) {
+      console.error('Error in wallet.js/cid2json()', err.message)
+      throw err
+    }
+  }
 }
 
 export default WalletAdapter

src/adapters/webhook.js

@@ -6,13 +6,15 @@ import config from '../../config/index.js'
 
 import axios from 'axios'
 
-let _this
-
 class WebHook {
   constructor () {
-    _this = this
-    _this.config = config
-    _this.axios = axios
+    this.config = config
+    this.axios = axios
+    this.sleepTime = 2000
+    this.createWebhook = this.createWebhook.bind(this)
+    this.deleteWebhook = this.deleteWebhook.bind(this)
+    this.waitUntilSuccess = this.waitUntilSuccess.bind(this)
+    this.sleep = this.sleep.bind(this)
   }
 
   // REST petition to create a webhook in p2wdb-service
@@ -22,14 +24,14 @@ class WebHook {
         throw new Error('url must be a string')
       }
 
-      const endpoint = _this.config.webhookService
+      const endpoint = this.config.webhookService
 
       const obj = {
         appId: this.config.p2wdbAppId,
         url
       }
 
-      const result = await axios.post(endpoint, obj)
+      const result = await this.axios.post(endpoint, obj)
 
       return result.data
     } catch (err) {
@@ -45,14 +47,14 @@ class WebHook {
         throw new Error('url must be a string')
       }
 
-      const endpoint = _this.config.webhookService
+      const endpoint = this.config.webhookService
 
       const obj = {
         appId: this.config.p2wdbAppId,
         url
       }
 
-      const result = await axios.delete(endpoint, { data: obj })
+      const result = await this.axios.delete(endpoint, { data: obj })
 
       return result.data
     } catch (err) {
@@ -86,7 +88,7 @@ class WebHook {
         } catch (err) {
           const now = new Date()
           console.log(`${now.toLocaleString()}: Error trying to create webhook with P2WDB. Trying again...`)
-          await sleep(2000)
+          await this.sleep(this.sleepTime)
         }
       } while (!success)
 
@@ -96,10 +98,10 @@ class WebHook {
       throw err
     }
   }
-}
 
-function sleep (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
+  async sleep (ms) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
 }
 
 export default WebHook

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

@@ -29,7 +29,36 @@ class EntryRESTControllerLib {
     _this = this
   }
 
+  /**
+   * @api {post} /entry Create an entry
+   * @apiPermission public
+   * @apiName CreateEntry
+   * @apiGroup REST Entry
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{"entry": "1234567890", "description": "1234567890", "slpAddress": "1234567890", "signature": "1234567890", "category": "1234567890"}' localhost:5001/entry
+   *
+   * @apiSuccess {Object} entry          Entry object
+   * @apiSuccess {String} entry.id   Entry ID
+   * @apiSuccess {String} entry.description   Entry description
+   * @apiSuccess {String} entry.slpAddress   Entry slp address
+   * @apiSuccess {String} entry.signature   Entry signature
+   * @apiSuccess {String} entry.category   Entry category
+
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "entry": {
+   *         "id": "1234567890",
+   *         "description": "1234567890",
+   *         "slpAddress": "1234567890",
+   *         "signature": "1234567890",
+   *         "category": "1234567890"
+   *       }
+   *     }
+   */
   // No api-doc documentation because this wont be a public endpoint
+  // Note: this is a private endpoint, needs to be authenticated
   async createEntry (ctx) {
     try {
       console.log('body: ', ctx.request.body)

src/controllers/rest-api/index.js

@@ -19,6 +19,7 @@ import OrderRouter from './order/index.js'
 import P2WDBRouter from './p2wdb/index.js'
 import UsageRESTController from './usage/index.js'
 import SmAccountRouter from './smAccount/index.js'
+import NostrRouter from './nostr/index.js'
 
 class RESTControllers {
   constructor (localConfig = {}) {
@@ -90,6 +91,10 @@ class RESTControllers {
 
     const smAccountRouter = new SmAccountRouter(dependencies)
     smAccountRouter.attach(app)
+
+    // Attach the REST API Controllers associated with the /nostr route
+    const nostrRouter = new NostrRouter(dependencies)
+    nostrRouter.attach(app)
   }
 }
 

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

@@ -40,11 +40,23 @@ class IpfsRESTControllerLib {
    * @api {get} /ipfs Get status on IPFS infrastructure
    * @apiPermission public
    * @apiName GetIpfsStatus
-   * @apiGroup REST BCH
+   * @apiGroup REST IPFS
    *
    * @apiExample Example usage:
    * curl -H "Content-Type: application/json" -X GET localhost:5001/ipfs
    *
+   * @apiSuccess {Object} status          IPFS status object
+   * @apiSuccess {String} status.ipfsId   IPFS ID
+   * @apiSuccess {String} status.multiaddrs   IPFS multiaddrs
+
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "status": {
+   *         "ipfsId": "1234567890",
+   *         "multiaddrs": ["/ip4/123.45.67.89/tcp/4001/p2p/1234567890"]
+   *       }
+   *     }
    */
   async getStatus (ctx) {
     try {
@@ -58,7 +70,26 @@ class IpfsRESTControllerLib {
     }
   }
 
-  // Return information on IPFS peers this node is connected to.
+  /**
+   * @api {post} /ipfs/peers Get information on IPFS peers this node is connected to
+   * @apiPermission public
+   * @apiName GetIpfsPeers
+   * @apiGroup REST IPFS
+   *
+   * @apiParam {Boolean} [showAll=false] Whether to include detailed peer data
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST localhost:5001/ipfs/peers \
+   *   -d '{"showAll": false}'
+   *
+   * @apiSuccess {Object[]} peers Array of peer objects
+   * @apiSuccess {String} peers[].peer Peer ID
+   * @apiSuccess {String} peers[].name Peer name
+   * @apiSuccess {String} peers[].protocol Protocol used by the peer
+   * @apiSuccess {String} peers[].version Peer version
+   * @apiSuccess {String} peers[].connectionAddr Connection address
+   * @apiSuccess {Object} [peers[].peerData] Detailed peer data (when showAll=true)
+   */
   async getPeers (ctx) {
     try {
       const showAll = ctx.request.body.showAll
@@ -73,6 +104,24 @@ class IpfsRESTControllerLib {
     }
   }
 
+  /**
+   * @api {post} /ipfs/relays Get data about the known Circuit Relays
+   * @apiPermission public
+   * @apiName GetIpfsRelays
+   * @apiGroup REST IPFS
+   *
+   * @apiDescription Returns information about Circuit Relays, both v1 and v2, that this node knows about. V2 relays are hydrated with peer data from the connected peers list.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST localhost:5001/ipfs/relays
+   *
+   * @apiSuccess {Object} relays Object containing relay information
+   * @apiSuccess {Object[]} relays.v2Relays Array of v2 Circuit Relay objects
+   * @apiSuccess {String} relays.v2Relays[].ipfsId IPFS ID of the relay
+   * @apiSuccess {String} relays.v2Relays[].name Name of the relay (hydrated from peer data)
+   * @apiSuccess {String} relays.v2Relays[].description Description of the relay (hydrated from peer data)
+   * @apiSuccess {Object[]} relays.v1Relays Array of v1 Circuit Relay configurations
+   */
   // Get data about the known Circuit Relays. Hydrate with data from peers list.
   async getRelays (ctx) {
     try {
@@ -86,6 +135,24 @@ class IpfsRESTControllerLib {
     }
   }
 
+  /**
+   * @api {post} /ipfs/connect Connect to a specific IPFS peer
+   * @apiPermission public
+   * @apiName ConnectToIpfsPeer
+   * @apiGroup REST IPFS
+   *
+   * @apiDescription Attempts to establish a connection to a specific IPFS peer using the provided multiaddr. Optionally returns detailed information about the connection.
+   *
+   * @apiParam {String} multiaddr Multiaddress of the peer to connect to (required)
+   * @apiParam {Boolean} [getDetails=false] Whether to return detailed connection information
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST localhost:5001/ipfs/connect \
+   *   -d '{"multiaddr": "/ip4/161.35.99.207/tcp/4001/p2p/12D3KooWDtj9cfj1SKuLbDNKvKRKSsGN8qivq9M8CYpLPDpcD5pu", "getDetails": false}'
+   *
+   * @apiSuccess {Boolean} success Indicates whether the connection attempt was successful
+   * @apiSuccess {Object} [details] Additional connection details (when getDetails=true)
+   */
   async connect (ctx) {
     try {
       const multiaddr = ctx.request.body.multiaddr
@@ -107,7 +174,7 @@ class IpfsRESTControllerLib {
    * @api {get} /ipfs/node Get a copy of the thisNode object from helia-coord
    * @apiPermission public
    * @apiName GetThisNode
-   * @apiGroup REST BCH
+   * @apiGroup REST IPFS
    *
    * @apiExample Example usage:
    * curl -H "Content-Type: application/json" -X GET localhost:5001/ipfs/node

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

@@ -0,0 +1,219 @@
+/*
+  REST API Controller library for the /nostr route
+*/
+import wlogger from '../../../adapters/wlogger.js'
+
+class NostrRESTControllerLib {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating /nostr REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating /nostr REST Controller.'
+      )
+    }
+
+    this.createDeletedChat = this.createDeletedChat.bind(this)
+    this.getDeletedChats = this.getDeletedChats.bind(this)
+    this.createDeletedPost = this.createDeletedPost.bind(this)
+    this.getDeletedPosts = this.getDeletedPosts.bind(this)
+    this.handleError = this.handleError.bind(this)
+  }
+
+  /**
+   * @api {post} /nostr/deletedChat Create Deleted Chat.
+   * @apiPermission admin
+   * @apiName CreateDeletedChat
+   * @apiGroup REST Nostr
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -H "Authorization: Bearer <token>" -X POST -d '{"eventId": "note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q" , "npub" : "npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8" , "bchAddr" : "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a", "pubkey":"6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1"}' localhost:5700/nostr/deletedChat
+   *
+   * @apiSuccess {String} _id DB Model id
+   * @apiSuccess {String} eventId Event id
+   * @apiSuccess {String} bchAddr BCH Address
+   * @apiSuccess {String} npub Nostr Npub
+   * @apiSuccess {String} pubkey Nostr pubkey
+   * @apiSuccess {Date} createdAt Created at date.
+   * @apiSuccess {Date} updatedAt Updated at date.
+   *
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "_id": "6900f87f9cafee38028ea27e",
+   *       "npub": "npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8",
+   *       "bchAddr" : "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
+   *       "pubKey": "6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1",
+   *       "createdAt":"2025-10-28T17:08:15.409Z",
+   *       "updatedAt": "2025-10-28T17:08:15.409Z"
+   *     }
+   *
+   * @apiUse TokenError
+   */
+  async createDeletedChat (ctx) {
+    try {
+      const chat = ctx.request.body
+
+      const result = await this.useCases.nostr.createDeletedChat(chat)
+
+      ctx.body = {
+        deletedChat: result
+      }
+    } catch (err) {
+      wlogger.error('Error in createDeletedChat() REST API handler.')
+      this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {get} /nostr/deletedChat Get Deleted Chats.
+   * @apiPermission public
+   * @apiName GetDeletedChats
+   * @apiGroup REST Nostr
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5700/nostr/deletedChat
+   *
+   * @apiSuccess {String} _id DB Model id
+   * @apiSuccess {String} eventId Event id
+   * @apiSuccess {String} bchAddr BCH Address
+   * @apiSuccess {String} npub Nostr Npub
+   * @apiSuccess {String} pubkey Nostr pubkey
+   * @apiSuccess {Date} createdAt Created at date.
+   * @apiSuccess {Date} updatedAt Updated at date.
+   *
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     [{
+   *       "_id": "6900f87f9cafee38028ea27e",
+   *       "npub": "npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8",
+   *       "bchAddr" : "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
+   *       "pubKey": "6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1",
+   *       "createdAt":"2025-10-28T17:08:15.409Z",
+   *       "updatedAt": "2025-10-28T17:08:15.409Z"
+   *     }]
+   *
+   * */
+  async getDeletedChats (ctx) {
+    try {
+      const deletedChats = await this.useCases.nostr.getDeletedChats()
+
+      ctx.body = { deletedChats }
+    } catch (err) {
+      wlogger.error('Error in getDeletedChats() REST API handler.')
+      this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {post} /nostr/deletedPost Create Deleted Post.
+   * @apiPermission admin
+   * @apiName CreateDeletedPost
+   * @apiGroup REST Nostr
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -H "Authorization: Bearer <token>" -X POST -d '{"eventId": "note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q" , "npub" : "npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8" , "bchAddr" : "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a", "pubkey":"6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1"}' localhost:5700/nostr/deletedPost
+   *
+   * @apiSuccess {String} _id DB Model id
+   * @apiSuccess {String} eventId Event id
+   * @apiSuccess {String} bchAddr BCH Address
+   * @apiSuccess {String} npub Nostr Npub
+   * @apiSuccess {String} pubkey Nostr pubkey
+   * @apiSuccess {Date} createdAt Created at date.
+   * @apiSuccess {Date} updatedAt Updated at date.
+   *
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "_id": "6900f87f9cafee38028ea27e",
+   *       "npub": "npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8",
+   *       "bchAddr" : "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
+   *       "pubKey": "6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1",
+   *       "createdAt":"2025-10-28T17:08:15.409Z",
+   *       "updatedAt": "2025-10-28T17:08:15.409Z"
+   *     }
+   *
+   * @apiUse TokenError
+   */
+  async createDeletedPost (ctx) {
+    try {
+      const post = ctx.request.body
+
+      const result = await this.useCases.nostr.createDeletedPost(post)
+
+      ctx.body = {
+        deletedPost: result
+      }
+    } catch (err) {
+      wlogger.error('Error in createDeletedPost() REST API handler.')
+      this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {get} /nostr/deletedPost Get Deleted Posts.
+   * @apiPermission public
+   * @apiName GetDeletedPosts
+   * @apiGroup REST Nostr
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5700/nostr/deletedPost
+   *
+   * @apiSuccess {String} _id DB Model id
+   * @apiSuccess {String} eventId Event id
+   * @apiSuccess {String} bchAddr BCH Address
+   * @apiSuccess {String} npub Nostr Npub
+   * @apiSuccess {String} pubkey Nostr pubkey
+   * @apiSuccess {Date} createdAt Created at date.
+   * @apiSuccess {Date} updatedAt Updated at date.
+   *
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     [{
+   *       "_id": "6900f87f9cafee38028ea27e",
+   *       "npub": "npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8",
+   *       "bchAddr" : "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
+   *       "pubKey": "6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1",
+   *       "createdAt":"2025-10-28T17:08:15.409Z",
+   *       "updatedAt": "2025-10-28T17:08:15.409Z"
+   *     }]
+   *
+   * */
+  async getDeletedPosts (ctx) {
+    try {
+      const deletedPosts = await this.useCases.nostr.getDeletedPosts()
+
+      ctx.body = { deletedPosts }
+    } catch (err) {
+      wlogger.error('Error in getDeletedPosts() REST API handler.')
+      this.handleError(ctx, err)
+    }
+  }
+
+  // DRY error handler
+  handleError (ctx, err) {
+    // If an HTTP status is specified by the buisiness logic, use that.
+    if (err.status) {
+      if (err.message) {
+        ctx.throw(err.status, err.message)
+      } else {
+        ctx.throw(err.status)
+      }
+    } else {
+      // By default use a 422 error if the HTTP status is not specified.
+      ctx.throw(422, err.message)
+    }
+  }
+}
+
+export default NostrRESTControllerLib

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

@@ -0,0 +1,81 @@
+/*
+  REST API library for /nostr route.
+*/
+
+// Public npm libraries.
+import Router from 'koa-router'
+
+// Local libraries.
+import NostrRESTControllerLib from './controller.js'
+
+import Validators from '../middleware/validators.js'
+
+import config from '../../../../config/index.js'
+
+class NostrRouter {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating NostrRouter REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating NostrRouter REST Controller.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    // Encapsulate dependencies.
+    this.config = config
+    this.nostrRESTController = new NostrRESTControllerLib(dependencies)
+    this.validators = new Validators()
+
+    // Instantiate the router and set the base route.
+    const baseUrl = '/nostr'
+    this.router = new Router({ prefix: baseUrl })
+
+    this.attach = this.attach.bind(this)
+    this.createDeletedChat = this.createDeletedChat.bind(this)
+    this.createDeletedPost = this.createDeletedPost.bind(this)
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error(
+        'Must pass app object when attaching REST API controllers.'
+      )
+    }
+
+    // Define the routes and attach the controller.
+    this.router.post('/deletedChat', this.createDeletedChat)
+    this.router.get('/deletedChat', this.nostrRESTController.getDeletedChats)
+    this.router.post('/deletedPost', this.createDeletedPost)
+    this.router.get('/deletedPost', this.nostrRESTController.getDeletedPosts)
+
+    // Attach the Controller routes to the Koa app.
+    app.use(this.router.routes())
+    app.use(this.router.allowedMethods())
+  }
+
+  async createDeletedChat (ctx, next) {
+    await this.validators.ensureAdmin(ctx, next)
+    await this.nostrRESTController.createDeletedChat(ctx, next)
+    return true
+  }
+
+  async createDeletedPost (ctx, next) {
+    await this.validators.ensureAdmin(ctx, next)
+    await this.nostrRESTController.createDeletedPost(ctx, next)
+    return true
+  }
+}
+
+export default NostrRouter

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

@@ -34,10 +34,13 @@ class OfferRESTControllerLib {
     this.listFungibleOffers = this.listFungibleOffers.bind(this)
     this.takeOffer = this.takeOffer.bind(this)
     this.listOffersByAddress = this.listOffersByAddress.bind(this)
+    this.syncOfferMutableData = this.syncOfferMutableData.bind(this)
+    this.listCounterOffersByAddress = this.listCounterOffersByAddress.bind(this)
     this.handleError = this.handleError.bind(this)
   }
 
   // No api-doc documentation because this wont be a public endpoint
+  // This function  has no endpoint
   async createOffer (ctx) {
     try {
       console.log('body: ', ctx.request.body)
@@ -56,6 +59,65 @@ class OfferRESTControllerLib {
       this.handleError(ctx, err)
     }
   }
+  /**
+   * @api {get} /offer/list/all/:page Get all offers
+   * @apiPermission public
+   * @apiName ListOffers
+   * @apiGroup REST Offer
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5000/offer/list/all/0
+   *
+   * @apiSuccess {Object[]} offers           Array of offer objects
+   * @apiSuccess {ObjectId} offers._id       Offer id
+   * @apiSuccess {String} offers.ticker      Ticker
+   * @apiSuccess {String} offers.tokenId     Token id
+   * @apiSuccess {String} offers.utxoTxid   Utxo transaction id
+   * @apiSuccess {Number} offers.utxoVout   Utxo output index
+   * @apiSuccess {String} offers.buyOrSell  Buy or sell
+   * @apiSuccess {Number} offers.numTokens  Number of tokens
+   * @apiSuccess {String} offers.rateInBaseUnit Rate in base unit
+   * @apiSuccess {String} offers.minUnitsToExchange Minimum units to exchange
+   * @apiSuccess {String} offers.offerStatus Offer status
+   * @apiSuccess {String} offers.makerAddr Maker address
+   * @apiSuccess {Number} offers.timestamp Timestamp
+   * @apiSuccess {String} offers.displayCategory Display category
+   * @apiSuccess {Boolean} offers.nsfw Nsfw
+   * @apiSuccess {Array} offers.flags Flags
+   * @apiSuccess {Number} offers.messageType Message type
+   * @apiSuccess {Number} offers.messageClass Message class
+   * @apiSuccess {String} offers.nostrEventId Nostr event id
+   * @apiSuccess {String} offers.operatorAddress Operator address
+   * @apiSuccess {Number} offers.operatorPercentage Operator percentage
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "offers": [{
+   *          "_id": "56bd1da600a526986cf65c80",
+   *          "tokenId": "1234567890",
+   *          "utxoTxid": "1234567890",
+   *          "utxoVout": 0,
+   *          "buyOrSell": "buy",
+   *          "numTokens": 1,
+   *          "rateInBaseUnit": "100000000",
+   *          "minUnitsToExchange": "100000000",
+   *          "offerStatus": "active",
+   *          "makerAddr": "1234567890",
+   *          "timestamp": 1716883200,
+   *          "displayCategory": "nft",
+   *          "nsfw": false,
+   *          "flags": [],
+   *          "messageType": 1,
+   *          "messageClass": 1,
+   *          "nostrEventId": "1234567890",
+   *          "operatorAddress": "1234567890",
+   *          "operatorPercentage": 100
+   *       }]
+   *     }
+   *
+   * @apiUse TokenError
+   */
 
   // curl -X GET http://localhost:5700/offer/list/all/0
   async listOffers (ctx) {
@@ -72,6 +134,66 @@ class OfferRESTControllerLib {
     }
   }
 
+  /**
+   * @api {get} /offer/list/nft/:page Get all nft offers
+   * @apiPermission public
+   * @apiName ListNftOffers
+   * @apiGroup REST Offer
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5000/offer/list/nft/0
+   *
+   * @apiSuccess {Object[]} offers           Array of offer objects
+   * @apiSuccess {ObjectId} offers._id       Offer id
+   * @apiSuccess {String} offers.ticker      Ticker
+   * @apiSuccess {String} offers.tokenId     Token id
+   * @apiSuccess {String} offers.utxoTxid   Utxo transaction id
+   * @apiSuccess {Number} offers.utxoVout   Utxo output index
+   * @apiSuccess {String} offers.buyOrSell  Buy or sell
+   * @apiSuccess {Number} offers.numTokens  Number of tokens
+   * @apiSuccess {String} offers.rateInBaseUnit Rate in base unit
+   * @apiSuccess {String} offers.minUnitsToExchange Minimum units to exchange
+   * @apiSuccess {String} offers.offerStatus Offer status
+   * @apiSuccess {String} offers.makerAddr Maker address
+   * @apiSuccess {Number} offers.timestamp Timestamp
+   * @apiSuccess {String} offers.displayCategory Display category
+   * @apiSuccess {Boolean} offers.nsfw Nsfw
+   * @apiSuccess {Array} offers.flags Flags
+   * @apiSuccess {Number} offers.messageType Message type
+   * @apiSuccess {Number} offers.messageClass Message class
+   * @apiSuccess {String} offers.nostrEventId Nostr event id
+   * @apiSuccess {String} offers.operatorAddress Operator address
+   * @apiSuccess {Number} offers.operatorPercentage Operator percentage
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "offers": [{
+   *          "_id": "56bd1da600a526986cf65c80",
+   *          "tokenId": "1234567890",
+   *          "utxoTxid": "1234567890",
+   *          "utxoVout": 0,
+   *          "buyOrSell": "buy",
+   *          "numTokens": 1,
+   *          "rateInBaseUnit": "100000000",
+   *          "minUnitsToExchange": "100000000",
+   *          "offerStatus": "active",
+   *          "makerAddr": "1234567890",
+   *          "timestamp": 1716883200,
+   *          "displayCategory": "nft",
+   *          "nsfw": false,
+   *          "flags": [],
+   *          "messageType": 1,
+   *          "messageClass": 1,
+   *          "nostrEventId": "1234567890",
+   *          "operatorAddress": "1234567890",
+   *          "operatorPercentage": 100
+   *       }]
+   *     }
+   *
+   * @apiUse TokenError
+   */
+
   // curl -X GET http://localhost:5700/offer/list/nft/0
   async listNftOffers (ctx) {
     try {
@@ -87,6 +209,65 @@ class OfferRESTControllerLib {
     }
   }
 
+  /**
+   * @api {get} /offer/list/fungible/:page Get all fungible offers
+   * @apiPermission public
+   * @apiName ListFungibleOffers
+   * @apiGroup REST Offer
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5000/offer/list/fungible/0
+   *
+   * @apiSuccess {Object[]} offers           Array of offer objects
+   * @apiSuccess {ObjectId} offers._id       Offer id
+   * @apiSuccess {String} offers.ticker      Ticker
+   * @apiSuccess {String} offers.tokenId     Token id
+   * @apiSuccess {String} offers.utxoTxid   Utxo transaction id
+   * @apiSuccess {Number} offers.utxoVout   Utxo output index
+   * @apiSuccess {String} offers.buyOrSell  Buy or sell
+   * @apiSuccess {Number} offers.numTokens  Number of tokens
+   * @apiSuccess {String} offers.rateInBaseUnit Rate in base unit
+   * @apiSuccess {String} offers.minUnitsToExchange Minimum units to exchange
+   * @apiSuccess {String} offers.offerStatus Offer status
+   * @apiSuccess {String} offers.makerAddr Maker address
+   * @apiSuccess {Number} offers.timestamp Timestamp
+   * @apiSuccess {String} offers.displayCategory Display category
+   * @apiSuccess {Boolean} offers.nsfw Nsfw
+   * @apiSuccess {Array} offers.flags Flags
+   * @apiSuccess {Number} offers.messageType Message type
+   * @apiSuccess {Number} offers.messageClass Message class
+   * @apiSuccess {String} offers.nostrEventId Nostr event id
+   * @apiSuccess {String} offers.operatorAddress Operator address
+   * @apiSuccess {Number} offers.operatorPercentage Operator percentage
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "offers": [{
+   *          "_id": "56bd1da600a526986cf65c80",
+   *          "tokenId": "1234567890",
+   *          "utxoTxid": "1234567890",
+   *          "utxoVout": 0,
+   *          "buyOrSell": "buy",
+   *          "numTokens": 1,
+   *          "rateInBaseUnit": "100000000",
+   *          "minUnitsToExchange": "100000000",
+   *          "offerStatus": "active",
+   *          "makerAddr": "1234567890",
+   *          "timestamp": 1716883200,
+   *          "displayCategory": "fungible",
+   *          "nsfw": false,
+   *          "flags": [],
+   *          "messageType": 1,
+   *          "messageClass": 1,
+   *          "nostrEventId": "1234567890",
+   *          "operatorAddress": "1234567890",
+   *          "operatorPercentage": 100
+   *       }]
+   *     }
+   *
+   * @apiUse TokenError
+   */
   // curl -X GET http://localhost:5700/offer/list/fungible/0
   async listFungibleOffers (ctx) {
     try {
@@ -102,6 +283,27 @@ class OfferRESTControllerLib {
     }
   }
 
+  /**
+   * @api {post} /offer/take Take an offer
+   * @apiPermission public
+   * @apiName TakeOffer
+   * @apiGroup REST Offer
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "nostrEventId": "1234567890" }' localhost:5010/offer/take
+   *
+   * @apiSuccess {String} eventId Event id
+   * @apiSuccess {String} noteId Note id
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "eventId": "1234567890",
+   *       "noteId": "1234567890"
+   *     }
+   *
+   * @apiUse TokenError
+   */
   // Currently only supports 'sell' offers, and will only buy the 'numTokens'
   // listed in the offer.
   async takeOffer (ctx) {
@@ -119,6 +321,67 @@ class OfferRESTControllerLib {
     }
   }
 
+  /**
+   * @api {get} /offer/list/addr/:addr List all offers being made by a given address
+   * @apiPermission public
+   * @apiName ListOffersByAddress
+   * @apiGroup REST Offer
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5000/offer/list/addr/bitcoincash:qrpxtnrlhfz9wsuuse7z5k2mxmvw0r3pu5qepyhmq2
+   *
+   *
+   * @apiSuccess {Object[]} offers           Array of offer objects
+   * @apiSuccess {ObjectId} offers._id       Offer id
+   * @apiSuccess {String} offers.ticker      Ticker
+   * @apiSuccess {String} offers.tokenId     Token id
+   * @apiSuccess {String} offers.utxoTxid   Utxo transaction id
+   * @apiSuccess {Number} offers.utxoVout   Utxo output index
+   * @apiSuccess {String} offers.buyOrSell  Buy or sell
+   * @apiSuccess {Number} offers.numTokens  Number of tokens
+   * @apiSuccess {String} offers.rateInBaseUnit Rate in base unit
+   * @apiSuccess {String} offers.minUnitsToExchange Minimum units to exchange
+   * @apiSuccess {String} offers.offerStatus Offer status
+   * @apiSuccess {String} offers.makerAddr Maker address
+   * @apiSuccess {Number} offers.timestamp Timestamp
+   * @apiSuccess {String} offers.displayCategory Display category
+   * @apiSuccess {Boolean} offers.nsfw Nsfw
+   * @apiSuccess {Array} offers.flags Flags
+   * @apiSuccess {Number} offers.messageType Message type
+   * @apiSuccess {Number} offers.messageClass Message class
+   * @apiSuccess {String} offers.nostrEventId Nostr event id
+   * @apiSuccess {String} offers.operatorAddress Operator address
+   * @apiSuccess {Number} offers.operatorPercentage Operator percentage
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "offers": [{
+   *          "_id": "56bd1da600a526986cf65c80",
+   *          "tokenId": "1234567890",
+   *          "utxoTxid": "1234567890",
+   *          "utxoVout": 0,
+   *          "buyOrSell": "buy",
+   *          "numTokens": 1,
+   *          "rateInBaseUnit": "100000000",
+   *          "minUnitsToExchange": "100000000",
+   *          "offerStatus": "active",
+   *          "makerAddr": "bitcoincash:qrpxtnrlhfz9wsuuse7z5k2mxmvw0r3pu5qepyhmq2",
+   *          "timestamp": 1716883200,
+   *          "displayCategory": "fungible",
+   *          "nsfw": false,
+   *          "flags": [],
+   *          "messageType": 1,
+   *          "messageClass": 1,
+   *          "nostrEventId": "1234567890",
+   *          "operatorAddress": "1234567890",
+   *          "operatorPercentage": 100
+   *       }]
+   *     }
+   *
+   * @apiUse TokenError
+   */
+
   // List all offers being made by a given address.
   // curl -X GET http://localhost:5700/offer/list/addr/bitcoincash:qrpxtnrlhfz9wsuuse7z5k2mxmvw0r3pu5qepyhmq2
   async listOffersByAddress (ctx) {
@@ -134,6 +397,64 @@ class OfferRESTControllerLib {
     }
   }
 
+  async syncOfferMutableData (ctx) {
+    try {
+      const tokenId = ctx.request.body.tokenId
+      const offer = await this.useCases.offer.syncOfferMutableData(tokenId)
+
+      ctx.body = offer
+    } catch (err) {
+      console.log('Error in syncOfferMutableData REST API handler: ', err)
+      this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {get} /offer/list/counter-offer/:addr List all counter offers being made by a given address
+   * @apiPermission public
+   * @apiName listCounterOffersByAddress
+   * @apiGroup REST Offer
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5000/offer/list/counter-offer/bitcoincash:qq54a3xyyptty63ztlcavzzh64gy4d247qs4ueaupe
+   *
+   *
+
+   * @apiSuccess {String} offers.nostrEventId Nostr event id
+   * @apiSuccess {String} offers.takerNpub Nostr Npub.
+   * @apiSuccess {String} offers.takerAddr BCH Address.
+   * @apiSuccess {String} offers.counterOfferAddr BCH Address
+   * @apiSuccess {String} offers.counterOfferUtxo Utxo txid.
+   *
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "counterOffers": [{
+   *          "_id": "56bd1da600a526986cf65c80",
+   *          "nostrEventId": "1234567890",
+   *          "takerAddr": "bitcoincash:qq54a3xyyptty63ztlcavzzh64gy4d247qs4ueaupe",
+   *          "takerNpub": "npub1nhc47z2tf42a4ps7plzcyax2j76gdausve763tqw3xuw7jjd7ceqppquly",
+   *          "counterOfferAddr": "bitcoincash:qzltx40ldxr53edchprppj5lpg4q7vl20usx25ga44",
+   *          "counterOfferUtxo": "71dab5b81cf06f3495aeebcc70fb351109e5e88bc85da67d0d144c0e5ca0bd6a",
+   *       }]
+   *     }
+   *
+   * @apiUse TokenError
+   */
+  async listCounterOffersByAddress (ctx) {
+    try {
+      const addr = ctx.params.addr
+
+      const counterOffers = await this.useCases.offer.listCounterOffersByAddress(addr)
+
+      ctx.body = { counterOffers }
+    } catch (err) {
+      console.log('Error in listCounterOffersByAddress REST API handler: ', err)
+      this.handleError(ctx, err)
+    }
+  }
+
   // DRY error handler
   handleError (ctx, err) {
     console.log('err', err.message)

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

@@ -55,10 +55,12 @@ class OfferRouter {
     // Define the routes and attach the controller.
     // this.router.post('/', _this.offerRESTController.createOffer) // Deprecated.
     this.router.post('/take', this.offerRESTController.takeOffer)
+    this.router.post('/mutable/sync/', this.offerRESTController.syncOfferMutableData)
     this.router.get('/list/all/:page', this.offerRESTController.listOffers)
     this.router.get('/list/nft/:page', this.offerRESTController.listNftOffers)
     this.router.get('/list/fungible/:page', this.offerRESTController.listFungibleOffers)
     this.router.get('/list/addr/:addr', this.offerRESTController.listOffersByAddress)
+    this.router.get('/list/counter-offer/:addr', this.offerRESTController.listCounterOffersByAddress)
 
     // Attach the Controller routes to the Koa app.
     app.use(this.router.routes())

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

@@ -29,7 +29,28 @@ class OrderRESTControllerLib {
     _this = this
   }
 
-  // No api-doc documentation because this wont be a public endpoint
+  /**
+   * @api {post} /order Create an order
+   * @apiPermission User
+   * @apiName CreateOrder
+   * @apiGroup REST Order
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{"messageType": "1", "messageClass": "1", "tokenId": "1234567890", "buyOrSell": "buy", "rateInBaseUnit": "100000000", "minUnitsToExchange": "100000000", "numTokens": "1", "makerAddr": "1234567890"}' localhost:5001/order
+   *
+   * @apiSuccess {String} eventId Event id
+   * @apiSuccess {String} noteId Note id
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "eventId": "1234567890",
+   *       "noteId": "1234567890"
+   *     }
+   *
+   * @apiUse TokenError
+   */
+
   async createOrder (ctx) {
     try {
       // console.log('body: ', ctx.request.body)
@@ -49,6 +70,68 @@ class OrderRESTControllerLib {
       _this.handleError(ctx, err)
     }
   }
+  /**
+   * @api {get} /order/list/all/:page List all orders
+   * @apiPermission user
+   * @apiName ListOrders
+   * @apiGroup REST Order
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5000/order/list/all/0
+   *
+   * @apiSuccess {Object[]} orders           Array of order objects
+   * @apiSuccess {ObjectId} orders._id       Order id
+   * @apiSuccess {String} orders.tokenId     Token id
+   * @apiSuccess {String} orders.ticker      Ticker
+   * @apiSuccess {String} orders.dataType    Data type
+   * @apiSuccess {String} orders.utxoTxid   Utxo transaction id
+   * @apiSuccess {Number} orders.utxoVout   Utxo output index
+   * @apiSuccess {String} orders.buyOrSell  Buy or sell
+   * @apiSuccess {Number} orders.numTokens  Number of tokens
+   * @apiSuccess {String} orders.rateInBaseUnit Rate in base unit
+   * @apiSuccess {String} orders.minUnitsToExchange Minimum units to exchange
+   * @apiSuccess {String} orders.offerStatus Offer status
+   * @apiSuccess {String} orders.makerAddr Maker address
+   * @apiSuccess {Number} orders.timestamp Timestamp
+   * @apiSuccess {String} orders.displayCategory Display category
+   * @apiSuccess {Boolean} orders.nsfw Nsfw
+   * @apiSuccess {Array} orders.flags Flags
+   * @apiSuccess {Number} orders.messageType Message type
+   * @apiSuccess {Number} orders.messageClass Message class
+   * @apiSuccess {String} orders.nostrEventId Nostr event id
+   * @apiSuccess {String} orders.operatorAddress Operator address
+   * @apiSuccess {Number} orders.operatorPercentage Operator percentage
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "orders": [{
+   *          "_id": "56bd1da600a526986cf65c80",
+   *          "tokenId": "1234567890",
+   *          "ticker": "BTC",
+   *          "dataType": "offer",
+   *          "utxoTxid": "1234567890",
+   *          "utxoVout": 0,
+   *          "buyOrSell": "buy",
+   *          "numTokens": 1,
+   *          "rateInBaseUnit": "100000000",
+   *          "minUnitsToExchange": "100000000",
+   *          "offerStatus": "active",
+   *          "makerAddr": "1234567890",
+   *          "timestamp": 1716883200,
+   *          "displayCategory": "nft",
+   *          "nsfw": false,
+   *          "flags": [],
+   *          "messageType": 1,
+   *          "messageClass": 1,
+   *          "nostrEventId": "1234567890",
+   *          "operatorAddress": "1234567890",
+   *          "operatorPercentage": 100
+   *       }]
+   *     }
+   *
+   * @apiUse TokenError
+   */
 
   // curl -X GET http://localhost:5700/order/list/all/0
   async listOrders (ctx) {
@@ -67,6 +150,28 @@ class OrderRESTControllerLib {
 
   // Delete an existing order by returning the token to the root address of
   // the DEX wallet.
+  /**
+   * @api {post} /order/delete Delete an order
+   * @apiPermission user
+   * @apiName DeleteOrder
+   * @apiGroup REST Order
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "nostrEventId": "1234567890" }' localhost:5000/order/delete
+   *
+   * @apiSuccess {String} txid Transaction id
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "txid": "1234567890"
+   *     }
+   *
+   * @apiUse TokenError
+   */
+
+  // curl -X POST http://localhost:5700/order/delete -d '{ "nostrEventId": "1234567890" }'
+
   async deleteOrder (ctx) {
     try {
       // console.log('body: ', ctx.request.body)

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

@@ -54,7 +54,7 @@ class OrderRouter {
     // Define the routes and attach the controller.
     this.router.post('/', this.createOrder)
     this.router.get('/list/all/:page', _this.orderRESTController.listOrders)
-    this.router.post('/delete', _this.orderRESTController.deleteOrder)
+    this.router.post('/delete', this.deleteOrder)
 
     // Attach the Controller routes to the Koa app.
     app.use(_this.router.routes())
@@ -65,6 +65,11 @@ class OrderRouter {
     await _this.validators.ensureUser(ctx, next)
     await _this.orderRESTController.createOrder(ctx, next)
   }
+
+  async deleteOrder (ctx, next) {
+    await _this.validators.ensureUser(ctx, next)
+    await _this.orderRESTController.deleteOrder(ctx, next)
+  }
 }
 
 export default OrderRouter

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

@@ -31,7 +31,25 @@ class P2WDBRESTControllerLib {
     _this = this
   }
 
-  // No api-doc documentation because this wont be a public endpoint
+  /**
+   * @api {post} /p2wdb Route a P2WDB webhook
+   * @apiPermission public
+   * @apiName RouteWebhook
+   * @apiGroup REST P2WDB
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{"data": {"dataType": "offer"} } ' localhost:5001/p2wdb
+   *
+   * @apiSuccess {String} success Success message
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *       "success": true
+   *     }
+   */
+
+  // Note: verify if this is a private endpoint, needs to be authenticated
   async routeWebhook (ctx) {
     try {
       console.log('p2wdb REST API handler: body: ', ctx.request.body)
@@ -64,6 +82,7 @@ class P2WDBRESTControllerLib {
         await _this.useCases.offer.flagOffer(flagData)
       } else {
         console.log('Could not route P2WDB webhook data.')
+        // NOTE: Should we throw an error here?
       }
 
       // const orderObj = ctx.request.body.order

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

@@ -12,13 +12,13 @@ class SmAccountRESTControllerLib {
     this.adapters = localConfig.adapters
     if (!this.adapters) {
       throw new Error(
-        'Instance of Adapters library required when instantiating /order REST Controller.'
+        'Instance of Adapters library required when instantiating /sm REST Controller.'
       )
     }
     this.useCases = localConfig.useCases
     if (!this.useCases) {
       throw new Error(
-        'Instance of Use Cases library required when instantiating /order REST Controller.'
+        'Instance of Use Cases library required when instantiating /sm REST Controller.'
       )
     }
 

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

@@ -40,7 +40,6 @@ class SmAccountRouter {
     const baseUrl = '/sm'
     this.router = new Router({ prefix: baseUrl })
 
-    this.listAccounts = this.listAccounts.bind(this)
     _this = this
   }
 
@@ -60,11 +59,6 @@ class SmAccountRouter {
     app.use(_this.router.routes())
     app.use(_this.router.allowedMethods())
   }
-
-  async listAccounts (ctx, next) {
-    // await _this.validators.ensureUser(ctx, next)
-    await _this.smAccountRESTController.listAccounts(ctx, next)
-  }
 }
 
 export default SmAccountRouter

src/controllers/timer-controllers.js

@@ -28,6 +28,7 @@ class TimerControllers {
     this.backupUsageInterval = 60000 * 10 // 10 minutes
     this.newSmAccountsInterval = 60000 * 60 // 60 minutes
     this.updateSmAccountsInterval = 60000 * 10 // 10 minutes
+    this.removeOlderDeletedChatsAndPostsInterval = 60000 * 60 * 1 // 1 hour
 
     // Encapsulate dependencies
     this.config = config
@@ -42,7 +43,7 @@ class TimerControllers {
     this.backupUsage = this.backupUsage.bind(this)
     this.newSmAccounts = this.newSmAccounts.bind(this)
     this.updateSmAccounts = this.updateSmAccounts.bind(this)
-
+    this.removeOlderDeletedChatsAndPosts = this.removeOlderDeletedChatsAndPosts.bind(this)
     // State
     this.gcOrdersInt = null
     this.gcOffersInt = null
@@ -50,6 +51,7 @@ class TimerControllers {
     this.loadOffersInt = null
     this.newSmAccountsInt = null
     this.updateSmAccountsInt = null
+    this.removeOlderDeletedChatsAndPostsInt = null
   }
 
   // Start all the time-based controllers.
@@ -62,6 +64,7 @@ class TimerControllers {
     this.backupUsageHandle = setInterval(this.backupUsage, this.backupUsageInterval)
     this.newSmAccountsInt = setInterval(this.newSmAccounts, this.newSmAccountsInterval)
     this.updateSmAccountsInt = setInterval(this.updateSmAccounts, this.updateSmAccountsInterval)
+    this.removeOlderDeletedChatsAndPostsInt = setInterval(this.removeOlderDeletedChatsAndPosts, this.removeOlderDeletedChatsAndPostsInterval)
     return true
   }
 
@@ -74,6 +77,7 @@ class TimerControllers {
     clearInterval(this.backupUsageHandle)
     clearInterval(this.newSmAccountsInt)
     clearInterval(this.updateSmAccountsInt)
+    clearInterval(this.removeOlderDeletedChatsAndPostsInt)
   }
 
   // Garbage Collect the Orders.
@@ -105,6 +109,7 @@ class TimerControllers {
       console.error('Error in time-controller.js/cleanUsage(): ', err)
 
       this.cleanUsageHandle = setInterval(this.cleanUsage, this.cleanUsageInterval)
+      return false
     }
   }
 
@@ -193,6 +198,22 @@ class TimerControllers {
       return false
     }
   }
+
+  // Remove older deleted chats and posts.
+  async removeOlderDeletedChatsAndPosts () {
+    try {
+      // console.log('removeOlderDeletedChatsAndPosts() Timer Controller executing at ', new Date().toLocaleString())
+      clearInterval(this.removeOlderDeletedChatsAndPostsInt)
+      await this.useCases.nostr.removeOlderDeletedChats()
+      await this.useCases.nostr.removeOlderDeletedPosts()
+      this.removeOlderDeletedChatsAndPostsInt = setInterval(this.removeOlderDeletedChatsAndPosts, this.removeOlderDeletedChatsAndPostsInterval)
+      return true
+    } catch (err) {
+      console.error('Error in time-controller.js/removeOlderDeletedChatsAndPosts(): ', err)
+      this.removeOlderDeletedChatsAndPostsInt = setInterval(this.removeOlderDeletedChatsAndPosts, this.removeOlderDeletedChatsAndPostsInterval)
+      return false
+    }
+  }
 }
 
 export default TimerControllers

src/entities/counterOffer.js

@@ -0,0 +1,53 @@
+/*
+  Counter Offer Entity
+*/
+
+class CounterOfferEntity {
+  validate (offerData = {}) {
+    console.log('counter offer data input validation ', offerData)
+    // Throw an error if input object does not have a data property
+    if (!offerData.data) {
+      throw new Error(
+        'Input to counterOffer.validate() must be an object with a data property.'
+      )
+    }
+
+    const {
+      nostrEventId,
+      takerAddr,
+      takerNpub,
+      counterOfferAddr,
+      counterOfferUtxo
+    } = offerData.data
+
+    // Input Validation
+    if (!nostrEventId || typeof nostrEventId !== 'string') {
+      throw new Error("Property 'nostrEventId' must be a string.")
+    }
+    // Next validations are optional, to allow old counter offers without the data.
+    if (takerAddr && typeof takerAddr !== 'string') {
+      throw new Error("Property 'takerAddr' must be a string.")
+    }
+    if (takerNpub && typeof takerNpub !== 'string') {
+      throw new Error("Property 'takerNpub' must be a string.")
+    }
+    if (counterOfferAddr && typeof counterOfferAddr !== 'string') {
+      throw new Error("Property 'counterOfferAddr' must be a string.")
+    }
+    if (counterOfferUtxo && typeof counterOfferUtxo !== 'string') {
+      throw new Error("Property 'counterOfferUtxo' must be a string.")
+    }
+
+    const validatedCounterOfferData = {
+      nostrEventId,
+      takerAddr,
+      takerNpub,
+      counterOfferAddr,
+      counterOfferUtxo
+    }
+
+    return validatedCounterOfferData
+  }
+}
+
+export default CounterOfferEntity

src/entities/deletedChat.js

@@ -0,0 +1,17 @@
+/*
+  DeletedChat Entity
+*/
+
+class DeletedChat {
+  validate (data = {}) {
+    const { eventId } = data
+    // Input Validation
+    if (!eventId || typeof eventId !== 'string') {
+      throw new Error("Property 'eventId' must be a string!")
+    }
+
+    return data
+  }
+}
+
+export default DeletedChat

src/entities/deletedPost.js

@@ -0,0 +1,17 @@
+/*
+  DeletedPost Entity
+*/
+
+class DeletedPost {
+  validate (data = {}) {
+    const { eventId } = data
+    // Input Validation
+    if (!eventId || typeof eventId !== 'string') {
+      throw new Error("Property 'eventId' must be a string!")
+    }
+
+    return data
+  }
+}
+
+export default DeletedPost

src/entities/entry.js

@@ -1,6 +1,9 @@
 /*
   Entry Entity
+
+  TODO: Explain what an entry is and how it works.
 */
+
 class Entry {
   validate ({
     entry,

src/entities/offer.js

@@ -1,6 +1,6 @@
 /*
   Offer Entity
-  An ffer is created when a new Signal is detected via the P2WDB webhook.
+  An offer is created when a new Signal is detected via the P2WDB webhook.
   It's destroyed when the UTXO described in the Signal has been detected as spent.
 */
 
@@ -31,9 +31,12 @@ class OfferEntity {
       utxoVout,
       offerStatus,
       makerAddr,
+      makerNpub,
       ticker,
       tokenType,
-      nostrEventId
+      nostrEventId,
+      operatorAddress,
+      operatorPercentage
     } = offerData.data
 
     // Input Validation
@@ -80,6 +83,18 @@ class OfferEntity {
       throw new Error("Property 'nostrEventId' must be a string.")
     }
 
+    // Add the operator address and percentage to the offer.
+    if (!operatorAddress || typeof operatorAddress !== 'string') {
+      throw new Error("Property 'operatorAddress' must be a string.")
+    }
+    if (!operatorPercentage || typeof operatorPercentage !== 'number') {
+      throw new Error("Property 'operatorPercentage' must be a number.")
+    }
+    // Validate npub type if it exist
+    if (makerNpub && typeof makerNpub !== 'string') {
+      throw new Error("Property 'makerNpub' must be a string.")
+    }
+
     // Convert the timestamp to a number.
     let timestamp = new Date(offerData.timestamp)
     timestamp = timestamp.getTime()
@@ -103,7 +118,8 @@ class OfferEntity {
       makerAddr,
       ticker,
       tokenType,
-      nostrEventId
+      nostrEventId,
+      makerNpub
     }
     // console.log('offer entity validatedOfferData: ', validatedOfferData)
 

src/use-cases/entry.js

@@ -1,3 +1,8 @@
+/*
+  Entry use-case library.
+
+  TODO: Explain what an entry is and how it works.
+*/
 
 // local libraries
 import wlogger from '../adapters/wlogger.js'
@@ -30,11 +35,12 @@ class EntryLib {
       if (!isValidSignature) {
         throw new Error('Invalid signature')
       }
-
       // Verify psf tokens balance
       // const psfBalance = await this.bch.getPSFTokenBalance(
       //   entryEntity.slpAddress
       // )
+      // NOTE: this.bch.getPSFTokenBalance , does not exist , should be created?
+
       const psfBalance = 1
 
       if (psfBalance < 10) {

src/use-cases/index.js

@@ -11,6 +11,7 @@ import OfferUseCases from './offer/index.js'
 import OrderUseCases from './order.js'
 import { UsageUseCases } from './usage-use-cases.js'
 import SmAccountUseCases from './smAccount-use-cases.js'
+import NostrUseCases from './nostr-use-cases.js'
 
 class UseCases {
   constructor (localConfig = {}) {
@@ -29,6 +30,7 @@ class UseCases {
     this.offer = new OfferUseCases(localConfig)
     this.usage = new UsageUseCases(localConfig)
     this.smAccount = new SmAccountUseCases(localConfig)
+    this.nostr = new NostrUseCases(localConfig)
   }
 
   // Run any startup Use Cases at the start of the app.

src/use-cases/nostr-use-cases.js

@@ -0,0 +1,130 @@
+/*
+  This library contains business-logic for dealing with deleted chats. Most of these
+  functions are called by the /nostr REST API endpoints.
+*/
+
+import wlogger from '../adapters/wlogger.js'
+import DeletedChatEntity from '../entities/deletedChat.js'
+import DeletedPostEntity from '../entities/deletedPost.js'
+
+class NostrUseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of adapters must be passed in when instantiating Nostr Use Cases library.'
+      )
+    }
+    // Encapsulate dependencies
+    this.DeletedChatEntity = new DeletedChatEntity()
+    this.DeletedPostEntity = new DeletedPostEntity()
+    this.DeletedChatModel = this.adapters.localdb.DeletedChat
+    this.DeletedPostModel = this.adapters.localdb.DeletedPost
+
+    this.createDeletedChat = this.createDeletedChat.bind(this)
+    this.getDeletedChats = this.getDeletedChats.bind(this)
+    this.createDeletedPost = this.createDeletedPost.bind(this)
+    this.getDeletedPosts = this.getDeletedPosts.bind(this)
+    this.removeOlderDeletedChats = this.removeOlderDeletedChats.bind(this)
+    this.removeOlderDeletedPosts = this.removeOlderDeletedPosts.bind(this)
+  }
+
+  // Create a new deleted chat model and add it to the Mongo database.
+  async createDeletedChat (deletedChatObj) {
+    try {
+      // Input Validation
+
+      const deletedChatEntity = this.DeletedChatEntity.validate(deletedChatObj)
+      const deletedChat = new this.DeletedChatModel(deletedChatEntity)
+
+      // Save the new model to the database.
+      await deletedChat.save()
+      return deletedChat
+    } catch (err) {
+      // console.log('createDeletedChat() error: ', err)
+      wlogger.error('Error in lib/nostr.js/createDeletedChat()')
+      throw err
+    }
+  }
+
+  // Returns an array of all deleted chats models in the Mongo database.
+  async getDeletedChats () {
+    try {
+      // Get deleted chats models.
+      const deletedChats = await this.DeletedChatModel.find({})
+
+      return deletedChats
+    } catch (err) {
+      wlogger.error('Error in lib/users.js/getAllDeletedChat()')
+      throw err
+    }
+  }
+
+  // Create a new deleted post model and add it to the Mongo database.
+  async createDeletedPost (deletedPostObj) {
+    try {
+      // Input Validation
+
+      const deletedPostEntity = this.DeletedPostEntity.validate(deletedPostObj)
+      const deletedPost = new this.DeletedPostModel(deletedPostEntity)
+
+      // Save the new model to the database.
+      await deletedPost.save()
+      return deletedPost
+    } catch (err) {
+      wlogger.error('Error in lib/users.js/createDeletedPost()')
+      throw err
+    }
+  }
+
+  // Returns an array of all deleted posts models in the Mongo database.
+  async getDeletedPosts () {
+    try {
+      // Get deleted posts models.
+      const deletedPosts = await this.DeletedPostModel.find({})
+
+      return deletedPosts
+    } catch (err) {
+      wlogger.error('Error in lib/users.js/getDeletedPosts()')
+      throw err
+    }
+  }
+
+  // Remove deleted chats that are older than 3 months.
+  async removeOlderDeletedChats () {
+    try {
+      const deletedChats = await this.DeletedChatModel.find({})
+      const threeMonthsAgo = new Date()
+      threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3)
+      for (let i = 0; i < deletedChats.length; i++) {
+        const deletedChat = deletedChats[i]
+        if (deletedChat.createdAt.getTime() < threeMonthsAgo.getTime()) {
+          await deletedChat.remove()
+        }
+      }
+    } catch (err) {
+      wlogger.error('Error in lib/users.js/removeOlderDeletedChats()')
+      throw err
+    }
+  }
+
+  // Remove deleted posts that are older than 3 months.
+  async removeOlderDeletedPosts () {
+    try {
+      const deletedPosts = await this.DeletedPostModel.find({})
+      const threeMonthsAgo = new Date()
+      threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3)
+      for (let i = 0; i < deletedPosts.length; i++) {
+        const deletedPost = deletedPosts[i]
+        if (deletedPost.createdAt.getTime() < threeMonthsAgo.getTime()) {
+          await deletedPost.remove()
+        }
+      }
+    } catch (err) {
+      wlogger.error('Error in lib/users.js/removeOlderDeletedPosts()')
+      throw err
+    }
+  }
+}
+
+export default NostrUseCases

src/use-cases/offer/index.js

@@ -19,6 +19,7 @@ import RetryQueue from '@chris.troutner/retry-queue'
 
 // Local libraries
 import OfferEntity from '../../entities/offer.js'
+import CounterOfferEntity from '../../entities/counterOffer.js'
 import config from '../../../config/index.js'
 
 const DEFAULT_ENTRIES_PER_PAGE = 20
@@ -45,7 +46,9 @@ class OfferUseCases {
     this.config = config
     this.axios = axios
     this.offerEntity = new OfferEntity()
+    this.counterOfferEntity = new CounterOfferEntity()
     this.OfferModel = this.adapters.localdb.Offer
+    this.CounterOfferModel = this.adapters.localdb.CounterOffer
     this.retryQueue = new RetryQueue({ retryPeriod: 1000, attempts: 3 })
 
     // Bind 'this' object to functions
@@ -65,6 +68,8 @@ class OfferUseCases {
     this.flagOffer = this.flagOffer.bind(this)
     this.loadOffers = this.loadOffers.bind(this)
     this.listOffersByAddress = this.listOffersByAddress.bind(this)
+    this.syncOfferMutableData = this.syncOfferMutableData.bind(this)
+    this.listCounterOffersByAddress = this.listCounterOffersByAddress.bind(this)
 
     // State
     this.seenOffers = []
@@ -111,7 +116,10 @@ class OfferUseCases {
       const utxoStatus = await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.utxoIsValid, utxo)
       // console.log('utxoStatus: ', utxoStatus)
       // if (utxoStatus === null) return false
-      if (!utxoStatus) return false
+      if (!utxoStatus) {
+        console.log(`UTXO txid: ${offerObj.data.utxoTxid}, vout: ${offerObj.data.utxoVout} has been spent. Skipping.`)
+        return false
+      }
 
       // A new offer gets a status of 'posted'
       offerObj.data.offerStatus = 'posted'
@@ -126,20 +134,57 @@ class OfferUseCases {
 
       // Get data about the token.
       const tokenId = offerEntity.tokenId
-      // const tokenData = await this.adapters.wallet.bchWallet.getTokenData(tokenId)
-      const tokenData = await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.getTokenData, tokenId)
-      // console.log(`tokenData: ${JSON.stringify(tokenData, null, 2)}`)
+      let tokenData = null
+      try {
+        tokenData = await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.getTokenData, tokenId)
+      } catch (err) {
+        console.error('Error in OfferUseCases/createOffer() getting token data: ', err.message)
+      }
 
-      // Generate a 'display category' for the token. This will allow the
-      // front end UI to figure out how to display the token.
-      const displayCategory = this.categorizeToken(offerEntity, tokenData)
-      console.log('displayCategory: ', displayCategory)
-      offerEntity.displayCategory = displayCategory
+      // Do additional data analysis if the token data was successfully retrieved.
+      if (tokenData) {
+        // Store the mutable and immutable data cids.
+        const mutableDataCid = tokenData.mutableData
+        const immutableDataCid = tokenData.immutableData
+        offerEntity.mutableDataCid = mutableDataCid
+        offerEntity.immutableDataCid = immutableDataCid
 
-      // Detect if user set the NSFW flag.
-      // const nsfw = false
-      // nsfw = await this.retryQueue.addToQueue(this.detectNsfw, tokenData)
-      // offerEntity.nsfw = nsfw
+        // Get the mutable data from the cid if it exists.
+        if (mutableDataCid && typeof mutableDataCid === 'string') {
+          let mutableData = null
+          try {
+            mutableData = await this.retryQueue.addToQueue(this.adapters.wallet.cid2json, mutableDataCid)
+          } catch (err) {
+            console.error('Error in OfferUseCases/createOffer() getting mutable data: ', err.message)
+          }
+          console.log('mutableData: ', mutableData)
+
+          if (mutableData) {
+            try {
+              offerEntity.tokenIconUrl = mutableData.tokenIcon
+              offerEntity.tokenCategories = mutableData.category
+              offerEntity.tokenTags = mutableData.tags
+              offerEntity.lastUpdatedTokenData = new Date().getTime()
+
+              offerEntity.userDataStr = JSON.stringify(mutableData.userData)
+            } catch (error) {
+              // skip error
+            }
+          }
+        }
+        console.log('offerEntity: ', offerEntity)
+
+        // Generate a 'display category' for the token. This will allow the
+        // front end UI to figure out how to display the token.
+        const displayCategory = this.categorizeToken(offerEntity, tokenData)
+        console.log('displayCategory: ', displayCategory)
+        offerEntity.displayCategory = displayCategory
+
+        // Detect if user set the NSFW flag.
+        // const nsfw = false
+        // nsfw = await this.retryQueue.addToQueue(this.detectNsfw, tokenData)
+        // offerEntity.nsfw = nsfw
+      }
 
       // Add offer to the local database.
       const offerModel = new this.OfferModel(offerEntity)
@@ -147,7 +192,7 @@ class OfferUseCases {
 
       return true
     } catch (err) {
-      console.error('Error in createOffer()', err.message)
+      console.error('\n\nError in createOffer()', err.message, '\n\n', err)
       throw err
     }
   }
@@ -264,7 +309,7 @@ class OfferUseCases {
     }
   }
 
-  async listNftOffers (page = 0, nsfw = false) {
+  /*   async listNftOffers (page = 0, nsfw = false) {
     try {
       const data = await this.OfferModel.find({
         displayCategory: { $ne: 'fungible' },
@@ -284,6 +329,42 @@ class OfferUseCases {
       console.error('Error in use-cases/offer/listNftOffers()')
       throw error
     }
+  } */
+
+  async listNftOffers (page = 0, nsfw = false) {
+    try {
+      const query = {
+        displayCategory: { $ne: 'fungible' },
+        nsfw
+      }
+      // Total query offers
+      const totalOffers = await this.OfferModel.countDocuments(query)
+      // Total pages
+      const totalPages = Math.ceil(totalOffers / NFT_ENTRIES_PER_PAGE)
+
+      const data = await this.OfferModel.find(query)
+        // Sort entries so newest entries show first.
+        .sort('-timestamp')
+        // Skip to the start of the selected page.
+        .skip(page * NFT_ENTRIES_PER_PAGE)
+        // Only return 20 results.
+        .limit(NFT_ENTRIES_PER_PAGE)
+
+      // console.log('listNftOffers() returning this data: ', data)
+
+      return {
+        data,
+        pagination: {
+          currentPage: page,
+          totalPages,
+          totalOffers,
+          pageSize: NFT_ENTRIES_PER_PAGE
+        }
+      }
+    } catch (error) {
+      console.error('Error in use-cases/offer/listNftOffers()')
+      throw error
+    }
   }
 
   async listFungibleOffers (page = 0) {
@@ -513,21 +594,33 @@ class OfferUseCases {
     // }
   }
 
-  // This function is called by the P2WDB webhook REST API handler. When a
-  // Counter Offer is passed to bch-dex by the P2WDB, the data is then passed
-  // to this function. It does due diligence on the Counter Offer, then signs
+  // This function is called by loadOffers().
+  // It does due diligence on the Counter Offer, then signs
   // and broadcasts the transaction to accept the Counter Offer.
   async acceptCounterOffer (offerData) {
     try {
+      console.log('offerData', offerData)
       // console.log(`acceptCounterOffer() offerData: ${JSON.stringify(offerData, null, 2)}`)
 
       // Quickly skip over offers that have already been processed.
       const eventId = offerData.data.nostrEventId
+
+      // Create counter offer entity for nostr event id if it not exist
+      const existingCounterOffer = await this.CounterOfferModel.findOne(({ nostrEventId: eventId }))
+      if (!existingCounterOffer) {
+        const counterOEntity = this.counterOfferEntity.validate(offerData)
+        // Create new counter offfer model and save it.
+        const counterOffer = new this.CounterOfferModel(counterOEntity)
+        await counterOffer.save()
+      }
+
       if (this.seenOffers.includes(eventId)) {
         // console.log(`Offer with event ID ${eventId} already processed. Skipping.`)
         return false
       }
 
+      console.log(`New counter offer detected: https://astral.psfoundation.info/${this.adapters.nostr.eventId2note(offerData.data.nostrEventId)}`)
+
       // See if this instance of bch-dex is managing the Order associated with
       // the incoming Counter Offer.
 
@@ -594,20 +687,57 @@ class OfferUseCases {
         throw new Error('Could not calculate the amount of BCH offered in the Counter Offer')
       }
       const satsOut = this.adapters.wallet.bchWallet.bchjs.BitcoinCash.toSatoshi(txObj.vout[2].value)
+
       const hasRequiredAmount = satsOut === satsToReceive
+
       if (!hasRequiredAmount) {
         throw new Error(`The Counter Offer has an output of ${satsOut}, which does not match the required ${satsToReceive} in the Offer.`)
       }
 
+      // Ensure the Counter Offer has an output for the Operator of bch-dex.
+      if (!txObj.vout[3]) {
+        console.log('The Counter Offer does not have an output for the Operator.')
+
+        // Add order to list of seen orders, so that we don't spent time trying to validate it again.
+        this.seenOffers.push(eventId)
+
+        return 'N/A'
+      }
+
       // Ensure the 3rd output (vout=2) is going to the maker address specified
       // in the Offer.
+
       const addrInCounterOffer = txObj.vout[2].scriptPubKey.addresses[0]
       const makerAddr = orderData.makerAddr
       const hasCorrectAddr = makerAddr === addrInCounterOffer
+
       if (!hasCorrectAddr) {
         throw new Error(`The Counter Offer has an output address of ${addrInCounterOffer}, which does not match the Maker address of ${makerAddr} in the Offer.`)
       }
 
+      // Ensure the 4th output (vout=3) is going to the operator address specified in the Offer.
+      // NOTE: This is the operator of the bch-dex intance, NOT the seller of the token.
+      const operatorAddr = orderData.operatorAddress
+
+      const hasCorrectOperatorAddr = operatorAddr === txObj.vout[3].scriptPubKey.addresses[0]
+      if (!hasCorrectOperatorAddr) {
+        throw new Error(`The Counter Offer has an output address of ${txObj.vout[3].scriptPubKey.addresses[0]}, which does not match the Operator address of ${operatorAddr} in the Offer.`)
+      }
+
+      // Ensure the 4th output (vout=3) contains the required amount of BCH.
+      const operatorSatsOut = this.adapters.wallet.bchWallet.bchjs.BitcoinCash.toSatoshi(txObj.vout[3].value)
+      let estimatedOperatorFee = Math.floor(txObj.vout[3].value * orderData.operatorPercentage / 100)
+      if (estimatedOperatorFee < 546) estimatedOperatorFee = 546
+      console.log('operatorSatsOut: ', operatorSatsOut, 'estimatedOperatorFee: ', estimatedOperatorFee)
+      if (operatorSatsOut < estimatedOperatorFee) {
+        console.log(`Skipping: The Counter Offer has an output of ${operatorSatsOut}, which is less than the estimated operator fee of ${estimatedOperatorFee}.`)
+
+        // Add order to list of seen orders, so that we don't spent time trying to validate it again.
+        this.seenOffers.push(eventId)
+
+        return 'N/A'
+      }
+
       // Get the User ID from the Order model.
       const userId = orderData.userId
 
@@ -718,7 +848,8 @@ class OfferUseCases {
           await thisOffer.remove()
         }
 
-        // If the Offer is older than 7 days, delete it.
+        // TODO: Instead of deleting the offer, send the token back to the Makers wallet.
+        // If the Offer is older than a threshold, delete it.
         const nowMs = now.getTime()
         const eightWeeks = 1000 * 60 * 60 * 24 * 7 * 8
         const eightWeeksAgo = nowMs - eightWeeks
@@ -795,7 +926,7 @@ class OfferUseCases {
           if (offerObj.data.dataType === 'counter-offer') {
             // console.log('Counter offer detected: ', offerObj)
             // console.log('Counter offer detected: ', offerObj.data.nostrEventId)
-            console.log(`Counter offer detected: https://astral.psfoundation.info/${this.adapters.nostr.eventId2note(offerObj.data.nostrEventId)}`)
+            // console.log(`Counter offer detected: https://astral.psfoundation.info/${this.adapters.nostr.eventId2note(offerObj.data.nostrEventId)}`)
             await this.acceptCounterOffer(offerObj)
           }
 
@@ -820,6 +951,104 @@ class OfferUseCases {
       throw err
     }
   }
+
+  // update offer model  mutable data
+  async syncOfferMutableData (tokenId) {
+    try {
+      // validate input
+      if (!tokenId || typeof tokenId !== 'string') {
+        throw new Error('tokenId must be a string!')
+      }
+
+      // validate existing offer with the associated tokenId
+      const offer = await this.OfferModel.findOne({ tokenId })
+      if (!offer) throw new Error('Associated offer not found!')
+
+      // Verify last update timestamp. This prevents users from spamming the API with requests.
+      // It only updates the mutable data if it has been more than 5 minutes since the last update.
+      const lastUpdateTs = Number(offer.lastUpdatedTokenData)
+      const now = new Date().getTime()
+      const period = 5
+      if (lastUpdateTs) {
+        // add 5 minutes to the last update
+        const lastUpdate = new Date(lastUpdateTs)
+        console.log('lastUpdate', lastUpdate)
+        lastUpdate.setMinutes(lastUpdate.getMinutes() + period)
+
+        console.log(new Date().getMinutes() + ' ' + lastUpdate.getMinutes())
+        // if now is less than the lastUpdate + 5 minutos , them skip.
+        if (now < lastUpdate.getTime()) {
+          console.log('Skipping , token lastUpdate is less than 5 minutes.')
+          return offer
+        }
+      }
+
+      let tokenData = null
+      try {
+        tokenData = await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.getTokenData, tokenId)
+      } catch (err) {
+        // Dev Note: If getTokenData() fails, the code below will
+        console.error('Error in OfferUseCases/createOffer() getting token data: ', err.message)
+      }
+
+      // Do additional data analysis if the token data was successfully retrieved.
+      if (tokenData) {
+        // Store the mutable and immutable data cids.
+        const mutableDataCid = tokenData.mutableData
+        const immutableDataCid = tokenData.immutableData
+        offer.mutableDataCid = mutableDataCid
+        offer.immutableDataCid = immutableDataCid
+
+        // Get the mutable data from the cid if it exists.
+        if (mutableDataCid && typeof mutableDataCid === 'string') {
+          let mutableData = null
+          try {
+            mutableData = await this.retryQueue.addToQueue(this.adapters.wallet.cid2json, mutableDataCid)
+          } catch (err) {
+            console.error('Error in OfferUseCases/createOffer() getting mutable data: ', err.message)
+          }
+          console.log('mutableData: ', mutableData)
+
+          if (mutableData) {
+            try {
+              offer.tokenIconUrl = mutableData.tokenIcon
+              offer.tokenCategories = mutableData.category
+              offer.tokenTags = mutableData.tags
+
+              offer.userDataStr = JSON.stringify(mutableData.userData)
+            } catch (error) {
+              // skip error
+            }
+          }
+        }
+        // Save update time stamp
+        offer.lastUpdatedTokenData = new Date().getTime()
+      }
+
+      // Save the updated offer data to the database.
+      await offer.save()
+
+      // Return the updated offer data.
+      return offer
+    } catch (err) {
+      console.error('Error in syncOfferMutableData(): ', err)
+      throw err
+    }
+  }
+
+  async listCounterOffersByAddress (takerAddr) {
+    try {
+      if (!takerAddr || typeof takerAddr !== 'string') {
+        throw new Error('takerAddr must be a string')
+      }
+
+      const counterOffers = await this.CounterOfferModel.find({ takerAddr })
+      return counterOffers
+    } catch (err) {
+      console.error('Error in listCounterOffersByAddress(): ', err)
+      throw err
+    }
+  }
 }
 
 export default OfferUseCases

src/use-cases/order.js

@@ -44,6 +44,7 @@ class OrderLib {
 
       if (!entryObj.tokenId) throw new Error('entry does not contain required properties')
 
+      // Get the user data from the database, for the user creating the new Order.
       const user = await this.UserModel.findById(entryObj.userId)
       if (!user) throw new Error('user not found')
 
@@ -81,13 +82,7 @@ class OrderLib {
       // await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.optimize, {})
       await userWallet.optimize()
 
-      // Ensure sufficient tokens exist to create the order.
-      // await this.ensureFunds(orderEntity)
-      // await this.retryQueue.addToQueue(this.ensureFunds, orderEntity)
-
       // Get Ticker for token ID.
-      // const tokenData = await this.adapters.wallet.bchWallet.getTxData([entryObj.tokenId])
-      // const tokenData = await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.getTxData, [entryObj.tokenId])
       const tokenData = await userWallet.getTxData([entryObj.tokenId])
       // console.log(`tokenData: ${JSON.stringify(tokenData, null, 2)}`)
       orderEntity.ticker = tokenData[0].tokenTicker
@@ -107,15 +102,23 @@ class OrderLib {
       // await this.adapters.wallet.bchWallet.getUtxos()
       // await this.retryQueue.addToQueue(this.adapters.wallet.bchWallet.initialize, {})
       await userWallet.initialize()
+
       // Update the order with the new UTXO information.
       orderEntity.utxoTxid = utxoInfo.txid
       orderEntity.utxoVout = utxoInfo.vout
       orderEntity.tokenType = utxoInfo.tokenType
 
-      // Add P2WDB specific flag for signaling that this is a new offer.
+      // Add flag to signal that this is a new offer.
       orderEntity.dataType = 'offer'
       orderEntity.userId = user._id
 
+      // Add the operator address and percentage to the order.
+      orderEntity.operatorAddress = this.config.operatorAddress
+      orderEntity.operatorPercentage = this.config.operatorPercentage
+
+      // Convert the Seller's BCH private key to a Nostr npub. This is used to identify the seller in Nostr.
+      orderEntity.makerNpub = this.adapters.nostr.privKeyToNpub(userWallet.walletInfo.privateKey)
+
       // Post the new Order information to Nostr under the topic set in the
       // config file.
       const postObj = {

src/use-cases/smAccount-use-cases.js

@@ -10,7 +10,7 @@ class smAccountUseCases {
     this.adapters = localConfig.adapters
     if (!this.adapters) {
       throw new Error(
-        'Instance of adapters must be passed in when instantiating Order Use Cases library.'
+        'Instance of adapters must be passed in when instantiating SM Account Use Cases library.'
       )
     }
 
@@ -28,6 +28,7 @@ class smAccountUseCases {
       console.log('Checking for new Social Media Accounts...')
 
       const messages = await this.adapters.nostr.readGlobalFeed()
+      console.log('messages: ', messages)
       for (let i = 0; i < messages.length; i++) {
         const msg = messages[i]
         // const { content, id, tags, npub, pubkey } = msg
@@ -122,6 +123,7 @@ class smAccountUseCases {
         const followerCnt = followList.length
         await SmAccount.updateOne({ _id: account._id }, { $set: { followerCnt } })
       }
+      return true
     } catch (err) {
       console.error('Error in smAccount-use-cases.js/updateSmAccounts(): ', err)
       throw err

test/e2e/automated/a12-nostr.rest-e2e.js

@@ -0,0 +1,188 @@
+import testUtils from '../../utils/test-utils.js'
+import { assert } from 'chai'
+import config from '../../../config/index.js'
+import axios from 'axios'
+import sinon from 'sinon'
+import util from 'util'
+
+util.inspect.defaultOptions = { depth: 1 }
+
+const LOCALHOST = `http://localhost:${config.port}`
+
+const context = {}
+let sandbox
+
+// const mockContext = require('../../unit/mocks/ctx-mock').context
+
+if (!config.noMongo) {
+  describe('Nostr', () => {
+    before(async () => {
+      // console.log(`config: ${JSON.stringify(config, null, 2)}`)
+
+      // Create a second test user.
+      const userObj = {
+        email: 'test2@test.com',
+        password: 'pass2',
+        name: 'test2'
+      }
+      const testUser = await testUtils.createUser(userObj)
+      // console.log(`testUser2: ${JSON.stringify(testUser, null, 2)}`)
+
+      context.user2 = testUser.user
+      context.token2 = testUser.token
+      context.id2 = testUser.user._id
+
+      // Get the JWT used to log in as the admin 'system' user.
+      const adminJWT = await testUtils.getAdminJWT()
+      console.log(`adminJWT: ${adminJWT}`)
+      context.adminJWT = adminJWT
+
+      // const admin = await testUtils.loginAdminUser()
+      // context.adminJWT = admin.token
+
+      // const admin = await adminLib.loginAdmin()
+      // console.log(`admin: ${JSON.stringify(admin, null, 2)}`)
+    })
+
+    beforeEach(() => {
+      // const useCases = new UseCases({ adapters })
+      // uut = new UserController({ adapters, useCases })
+
+      sandbox = sinon.createSandbox()
+    })
+
+    afterEach(() => sandbox.restore())
+
+    describe('POST /nostr/deletedChat - Create Deleted Chat', () => {
+      it('should not create deleted chat if the authorization header is missing', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedChat`
+          }
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+      it('should not create deleted chat if the authorization header is invalid scheme', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedChat`,
+            headers: {
+              Authorization: 'Bearer invalid'
+            }
+          }
+
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+      it('should not create deleted chat if the authorization header is invalid token', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedChat`,
+            headers: {
+              Authorization: `Bearer ${context.token}`
+            }
+          }
+
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+      it('should not create deleted chat if token is not admin', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedChat`,
+            headers: {
+              Authorization: `Bearer ${context.token}`
+            }
+          }
+
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+    })
+
+    describe('POST /nostr/deletedPost - Create Deleted Post', () => {
+      it('should not create deleted post if the authorization header is missing', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedPost`
+          }
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+
+      it('should not create deleted post if the authorization header is invalid scheme', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedPost`,
+            headers: {
+              Authorization: 'Bearer invalid'
+            }
+          }
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+      it('should not create deleted post if the authorization header is invalid token', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedPost`,
+            headers: {
+              Authorization: `Bearer ${context.token}`
+            }
+          }
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+      it('should not create deleted post if token is not admin', async () => {
+        try {
+          const options = {
+            method: 'POST',
+            url: `${LOCALHOST}/nostr/deletedPost`,
+            headers: {
+              Authorization: `Bearer ${context.token}`
+            }
+          }
+          await axios(options)
+
+          assert.equal(true, false, 'Unexpected behavior')
+        } catch (err) {
+          assert.equal(err.response.status, 401)
+        }
+      })
+    })
+  })
+}

test/unit/adapters/adapters-index-unit.js

@@ -24,19 +24,18 @@ describe('#adapters', () => {
   })
 
   describe('#start', () => {
-    // it('should start the async adapters', async () => {
-    //   // Mock dependencies
-    //   uut.config.getJwtAtStartup = true
-    //   uut.config.useIpfs = true
-    //   uut.config.env = 'not-a-test'
-    //   sandbox.stub(uut.fullStackJwt, 'getJWT').resolves()
-    //   sandbox.stub(uut.fullStackJwt, 'instanceBchjs').resolves()
-    //   sandbox.stub(uut.ipfs, 'start').resolves()
+    it('should start the async adapters', async () => {
+      // Mock dependencies
+      uut.config.getJwtAtStartup = true
+      uut.config.useIpfs = true
+      uut.config.env = 'not-a-test'
+      sandbox.stub(uut.wallet, 'instanceWallet').resolves()
+      sandbox.stub(uut.ipfs, 'start').resolves()
 
-    //   const result = await uut.start()
+      const result = await uut.start()
 
-    //   assert.equal(result, true)
-    // })
+      assert.equal(result, true)
+    })
 
     it('should not start ipfs on test enviroment', async () => {
       // Mock dependencies

test/unit/adapters/bch.adapter.unit.js

@@ -135,18 +135,19 @@ describe('bch', () => {
       }
     })
 
-    // it('should return the merit ', async () => {
-    //   try {
-    //     // Mock live network calls.
-    //     sandbox.stub(uut.msgLib.merit, 'agMerit').resolves(100)
-    //
-    //     const slpAddr =
-    //       'simpleledger:qqgnksc6zr4nzxrye69fq625wu2myxey6uh9kzjy96'
-    //     const merit = await uut.getMerit(slpAddr)
-    //     assert.isNumber(merit)
-    //   } catch (err) {
-    //     assert.fail('Unexpected result')
-    //   }
-    // })
+    /*     it('should return the merit ', async () => {
+      try {
+        // Mock live network calls.
+        sandbox.stub(uut.msgLib.merit, 'agMerit').resolves(100)
+
+        const slpAddr =
+          'simpleledger:qqgnksc6zr4nzxrye69fq625wu2myxey6uh9kzjy96'
+        const merit = await uut.getMerit(slpAddr)
+        assert.isNumber(merit)
+      } catch (err) {
+        console.log('err: ', err)
+        assert.fail('Unexpected result')
+      }
+    }) */
   })
 })

test/unit/adapters/nostr.adapter.unit.js

@@ -128,4 +128,129 @@ describe('#nostr.js', () => {
       assert.equal(result.length, 1)
     })
   })
+  describe('#eventId2note', () => {
+    it('should handle encode error', async () => {
+      try {
+        await uut.eventId2note('invalid format')
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Invalid byte sequence')
+      }
+    })
+
+    it('should handle valid eventId', async () => {
+      const result = await uut.eventId2note('b1e4a3d5e40b6d0b3f1e2c234b6c9dbf4d6a80e9b3e8a2d765c7f9ed84c9a5ef')
+      assert.isString(result)
+      assert.include(result, 'note')
+    })
+  })
+  describe('#pubkey2npub', () => {
+    it('should handle encode error', async () => {
+      try {
+        await uut.pubkey2npub('invalid format')
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Invalid byte sequence')
+      }
+    })
+
+    it('should handle valid pubkey', async () => {
+      const result = await uut.pubkey2npub('f5a1b39d2cfae8e10e93b9b4d7ec8248eaf45fbe4a73409d8d4c67015e9729a3')
+      assert.isString(result)
+      assert.include(result, 'npub')
+    })
+  })
+  describe('#npub2pubkey', () => {
+    it('should handle decode error', async () => {
+      try {
+        await uut.npub2pubkey('npub17ksm88fvlt5wzr5nhx6d0myzfr40g')
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Invalid checksum')
+      }
+    })
+
+    it('should handle valid pubkey', async () => {
+      const result = await uut.npub2pubkey('npub17ksm88fvlt5wzr5nhx6d0myzfr40gha7ffe5p8vdf3nszh5h9x3sdwl7u2')
+      assert.isObject(result)
+      assert.property(result, 'type')
+      assert.property(result, 'data')
+      assert.equal(result.type, 'npub')
+      assert.equal(result.data.length, 64)
+    })
+  })
+  describe('#readGlobalFeed', () => {
+    it('should throw an error if provided limit is wrong', async () => {
+      try {
+        await uut.readGlobalFeed({ limit: -5 })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Limit must be greater than 0')
+      }
+    })
+
+    it('should read message', async () => {
+      const result = await uut.readGlobalFeed()
+      assert.isArray(result)
+    })
+
+    it('should read message with custom limit', async () => {
+      const result = await uut.readGlobalFeed({ limit: 1 })
+      assert.isArray(result)
+    })
+  })
+  describe('#getFollowers', () => {
+    it('should throw an error if no pubkey is provided', async () => {
+      try {
+        await uut.getFollowers()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'pubkey must be a string!')
+      }
+    })
+
+    it('should get followers', async () => {
+      const result = await uut.getFollowers({ pubkey: 'f5a1b39d2cfae8e10e93b9b4d7ec8248eaf45fbe4a73409d8d4c67015e9729a3' })
+      assert.isArray(result)
+    })
+  })
+  describe('#privKeyToNpub', () => {
+    it('should handle  error if providedprivKey is not a string', async () => {
+      try {
+        uut.privKeyToNpub()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'privKey must be a string!')
+      }
+    })
+
+    it('should return npub if privKey is valid', async () => {
+      const result = uut.privKeyToNpub('L2kh34VinQNRq1ad8nnXnGoFrb9pT7j8GJXiT6Scsg18KMxsUVDr')
+      // console.log('result: ', result)
+      assert.isString(result)
+      assert.include(result, 'npub')
+    })
+    it('should handle unexpected error', async () => {
+      try {
+        uut.privKeyToNpub('invalid format')
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Invalid base58 character')
+      }
+    })
+  })
 })

test/unit/adapters/order-pagination.unit.js

@@ -52,6 +52,7 @@ describe('#OrderPagination', () => {
       nostrEventId: 'nostrEventId',
       dataType: 'dataType',
       makerAddr: 'makerAddr',
+      makerNpub: 'makerNpub',
       rateInBaseUnit: 'rateInBaseUnit',
       minUnitsToExchange: 'minUnitsToExchange',
       ticker: 'ticker',

test/unit/adapters/wallet.unit.js

@@ -9,24 +9,56 @@ import sinon from 'sinon'
 
 import WalletAdapter from '../../../src/adapters/wallet.js'
 import { MockBchWallet } from '../mocks/adapters/wallet.js'
+import { BchTokenSweepMock } from '../mocks/bch-token-sweep-mock.js'
+import offerMockData from '../mocks/use-cases/offer-mock-data.js'
+import fs from 'fs'
+import * as url from 'url'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+const testWalletFile = `${__dirname.toString()}/../../../test-wallet.json`
 
 describe('#wallet', () => {
   let uut
   let sandbox
+  let testWalletData
+
+  before(() => {
+    // try to remove the test wallet file
+    try {
+      fs.unlinkSync(testWalletFile)
+    } catch (error) {
+      console.log('error fsUnlinkSync: ', error)
+
+      // silently fail
+    }
+  })
+  after(() => {
+    // try to remove the test wallet file
+    try {
+      fs.unlinkSync(testWalletFile)
+    } catch (error) {
+      console.log('error fsUnlinkSync: ', error)
+      // silently fail
+    }
+  })
 
   beforeEach(() => {
     uut = new WalletAdapter()
+    uut.BchWallet = MockBchWallet
     uut.bchWallet = new MockBchWallet()
+    uut.BchTokenSweep = BchTokenSweepMock
+    uut.WALLET_FILE = testWalletFile
     uut.bitcoinJs = {
       Transaction: {
-        fromHex: () => { return { } },
-        SIGHASH_ALL: () => { return { } }
+        fromHex: () => { return {} },
+        SIGHASH_ALL: () => { return {} }
       },
       TransactionBuilder: {
-        fromTransaction: () => { return { sign: () => { return { } }, build: () => { return { toHex: () => { return 'hex' } } } } }
+        fromTransaction: () => { return { sign: () => { return {} }, build: () => { return { toHex: () => { return 'hex' } } } } }
       },
       ECPair: {
-        fromWIF: () => { return { } }
+        fromWIF: () => { return {} }
       }
     }
     sandbox = sinon.createSandbox()
@@ -34,6 +66,278 @@ describe('#wallet', () => {
 
   afterEach(() => sandbox.restore())
 
+  describe('#openWallet', () => {
+    it('should create a new wallet when wallet file does not exist', async () => {
+      // Ensure we open the test file, not the production wallet file.
+      const result = await uut.openWallet()
+      testWalletData = result
+      // console.log('result: ', result)
+      assert.property(result, 'mnemonic')
+      assert.property(result, 'privateKey')
+      assert.property(result, 'publicKey')
+      assert.property(result, 'cashAddress')
+      assert.property(result, 'address')
+      assert.property(result, 'slpAddress')
+      assert.property(result, 'legacyAddress')
+      assert.property(result, 'hdPath')
+    })
+
+    it('should open existing wallet file', async () => {
+      // This test case uses the file created in the previous test case.
+      // Ensure we open the test file, not the production wallet file.
+      const result = await uut.openWallet()
+      // console.log('result: ', result)
+      assert.property(result, 'mnemonic')
+      assert.property(result, 'privateKey')
+      assert.property(result, 'publicKey')
+      assert.property(result, 'cashAddress')
+      assert.property(result, 'address')
+      assert.property(result, 'slpAddress')
+      assert.property(result, 'legacyAddress')
+      assert.property(result, 'hdPath')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        uut.WALLET_FILE = ''
+        // Force an error
+        uut.BchWallet = () => {
+        }
+        await uut.openWallet()
+        // console.log('result: ', result)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'this.BchWallet is not a constructor')
+      }
+    })
+  })
+  describe('#instanceWallet', () => {
+    it('should create an instance of BchWallet with rest-api', async () => {
+      uut.config.useFullStackCash = true
+      const result = await uut.instanceWallet(testWalletData)
+      assert.equal(result.advancedOptions.interface, 'rest-api')
+    })
+
+    it('should create an instance of BchWallet with consumer-api', async () => {
+      uut.config.useFullStackCash = false
+      const result = await uut.instanceWallet(testWalletData)
+      assert.equal(result.advancedOptions.interface, 'consumer-api')
+    })
+    it('should catch and throw an error if no mnemonic is provided', async () => {
+      try {
+        // Force an error
+        await uut.instanceWallet({})
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Wallet data is not formatted correctly. Can not read mnemonic in wallet file!')
+      }
+    })
+  })
+  describe('#incrementNextAddress', () => {
+    it('should increment the nextAddress property', async () => {
+      const result = await uut.incrementNextAddress()
+      assert.equal(result, 2)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox.stub(uut, 'openWallet').rejects(new Error('test error'))
+        await uut.incrementNextAddress()
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#getKeyPair', () => {
+    it('should return an object with a key pair', async () => {
+      // Ensure we open the test file, not the production wallet file.
+      // uut.WALLET_FILE = testWalletFile
+      uut.config.walletFile = testWalletFile
+
+      const result = await uut.getKeyPair()
+      // console.log('result: ', result)
+
+      assert.property(result, 'cashAddress')
+      assert.property(result, 'wif')
+      assert.property(result, 'hdIndex')
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut, 'incrementNextAddress')
+          .rejects(new Error('test error'))
+        await uut.getKeyPair()
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+  describe('#generateSignature', () => {
+    it('should sign message', async () => {
+      const result = await uut.generateSignature('unit test message')
+      // console.log('result: ', result)
+
+      assert.isString(result)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        await uut.generateSignature()
+      } catch (err) {
+        assert.include(err.message, 'message is required!')
+      }
+    })
+  })
+  describe('#generatePartialTx', () => {
+    it('should generate tx for fungible token', async () => {
+      const utxoInfo = {
+        txid: '241c06bf61384b8623477e419bf4779edbcc7e3bc862f0f179a9ed2967069b87',
+        vout: 0,
+        sats: 1000,
+        wif: 'L2fzmF5hCeTZRVnr7Cyu66ucJAAKhkhkfinGVuUAKDtvAfwEx8a3'
+      }
+
+      sandbox.stub(uut.bchWallet, 'getTxData').resolves([offerMockData.fungibleTokenData01.genesisData])
+      const result = await uut.generatePartialTx(offerMockData.fungibleOffer01, utxoInfo)
+
+      assert.isString(result)
+    })
+    it('should generate tx for nft', async () => {
+      const utxoInfo = {
+        txid: '241c06bf61384b8623477e419bf4779edbcc7e3bc862f0f179a9ed2967069b87',
+        vout: 0,
+        sats: 1000,
+        wif: 'L2fzmF5hCeTZRVnr7Cyu66ucJAAKhkhkfinGVuUAKDtvAfwEx8a3'
+      }
+
+      sandbox.stub(uut.bchWallet, 'getTxData').resolves([offerMockData.nftTokenData01.genesisData])
+      const result = await uut.generatePartialTx(offerMockData.nftOffer01, utxoInfo)
+      // console.log('result: ', result)
+
+      assert.isString(result)
+    })
+
+    it('should handle unknown token type', async () => {
+      try {
+        const utxoInfo = {
+          txid: '241c06bf61384b8623477e419bf4779edbcc7e3bc862f0f179a9ed2967069b87',
+          vout: 0,
+          sats: 1000,
+          wif: 'L2fzmF5hCeTZRVnr7Cyu66ucJAAKhkhkfinGVuUAKDtvAfwEx8a3'
+        }
+
+        const offerMock = Object.assign({}, offerMockData.nftOffer01)
+        offerMock.tokenType = 100
+        await uut.generatePartialTx(offerMock, utxoInfo)
+      } catch (err) {
+        assert.include(err.message, 'Unknown token type')
+      }
+    })
+    it('should handle multiple outputs', async () => {
+      const utxoInfo = {
+        txid: '241c06bf61384b8623477e419bf4779edbcc7e3bc862f0f179a9ed2967069b87',
+        vout: 0,
+        sats: 1000,
+        wif: 'L2fzmF5hCeTZRVnr7Cyu66ucJAAKhkhkfinGVuUAKDtvAfwEx8a3'
+      }
+
+      sandbox.stub(uut.bchWallet, 'getTxData').resolves([offerMockData.nftTokenData01.genesisData])
+      sandbox.stub(uut.bchWallet.bchjs.SLP.NFT1, 'generateNFTChildSendOpReturn').returns({ outputs: 5 })
+      const res = await uut.generatePartialTx(offerMockData.nftOffer01, utxoInfo)
+      assert.isUndefined(res)
+    })
+  })
+
+  describe('#moveTokens', () => {
+    it('should move tokens', async () => {
+      sandbox.stub(uut, 'getKeyPair').resolves({
+        cashAddress: 'cashAddress',
+        wif: 'wif',
+        hdIndex: 11
+      })
+      const input = {
+        tokenId: uut.bchWallet.utxos.utxoStore.slpUtxos.type1.tokens[0].tokenId,
+        qty: 1
+      }
+      const res = await uut.moveTokens(input)
+      assert.isObject(res)
+    })
+
+    it('should throw an error if the tokenId is not found', async () => {
+      try {
+        sandbox.stub(uut, 'getKeyPair').resolves({
+          cashAddress: 'cashAddress',
+          wif: 'wif',
+          hdIndex: 11
+        })
+        const input = {
+          tokenId: '241c06bf61384b8623477e419bf4779edbcc7e3bc862f0f179a9ed2967069b87',
+          qty: 1
+        }
+        await uut.moveTokens(input)
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'tokenId not found!')
+      }
+    })
+
+    it('should throw an error if the tokenId is not provided', async () => {
+      try {
+        await uut.moveTokens({
+          qty: 1
+        })
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'tokenId must be a string!')
+      }
+    })
+    it('should throw an error if the qty is not provided', async () => {
+      try {
+        await uut.moveTokens({
+          tokenId: 'tokenId'
+        })
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'qty must be a number!')
+      }
+    })
+  })
+
+  describe('#moveBch', () => {
+    it('should move bch', async () => {
+      sandbox.stub(uut, 'getKeyPair').resolves({
+        cashAddress: 'cashAddress',
+        wif: 'wif',
+        hdIndex: 11
+      })
+
+      const res = await uut.moveBch(100)
+      assert.isObject(res)
+    })
+
+    it('should throw an error if the amountSat is not provided', async () => {
+      try {
+        sandbox.stub(uut, 'getKeyPair').resolves({
+          cashAddress: 'cashAddress',
+          wif: 'wif',
+          hdIndex: 11
+        })
+
+        await uut.moveBch()
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'amountSat is required!')
+      }
+    })
+  })
   describe('#moveTokensFromCustomWallet', () => {
     it('should move tokens from a custom wallet', async () => {
       sandbox.stub(uut, 'getKeyPair').resolves({
@@ -100,28 +404,27 @@ describe('#wallet', () => {
       }
     })
   })
+  describe('#deseralizeTx', () => {
+    it('should throw an error if the hex is not provided', async () => {
+      try {
+        await uut.deseralizeTx()
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'hex must be a string!')
+      }
+    })
+    it('should decode hex', async () => {
+      try {
+        sandbox.stub(uut.bchWallet.bchjs.RawTransactions, 'decodeRawTransaction').resolves({})
+        const hex = '020000000286b2959cccdb80163b68bb1360abac8e0228ba7b70c779443168cc65c7c42d820100000000ffffffff879b066729eda979f1f062c83b7eccdb9e77f49b417e4723864b3861bf061c24000000006b483045022100b99c6161e18e4e34c1e438b6b03e808703695f217b30da42c3f787798a9f40cc02206d26b4f6799735779d4fac823bc60d276fbb3cea91c66dbfa136cf5b1bd0d8324121028dcd38a58c8295dbd105ef524014f77af4cddfa19b26c50926b4aaeebd95c7ceffffffff030000000000000000376a04534c500001010453454e4420a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b208000000000000006422020000000000001976a914bef6c5180648165704f22e71a1b011ba56336aee88acf81d0000000000001976a914c1f16a3876f8fbe3701a66d3cb3b9c7abb07a06c88ac00000000'
+        const result = await uut.deseralizeTx(hex)
+        assert.isObject(result)
+      } catch (error) {
+        assert.fail('Unexpected code path')
+      }
+    })
+  })
   describe('#completeTx', () => {
-    // TODO: This test needs to be refactored to use the new instanceWallet() method for loading the user wallet.
-
-    // it('should complete a transaction', async () => {
-    //   sandbox.stub(uut, 'getKeyPair').resolves({
-    //     cashAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
-    //     wif: 'L5D2UAam8tvo3uii5kpgaGyjvVMimdrXu8nWGQSQjuuAix6ji1YQ',
-    //     hdIndex: 11
-    //   })
-    //   sandbox.stub(uut, 'deseralizeTx').resolves({
-    //     txid: 'complete tx id result'
-    //   })
-    //   sandbox.stub(uut.retryQueue, 'addToQueue').resolves('complete tx id result')
-
-    //   const hex = 'hex'
-    //   const hdIndex = 11
-    //   const mnemonic = 'course abstract aerobic deer try switch turtle diet fence affair butter top'
-
-    //   const txid = await uut.completeTx(hex, hdIndex, mnemonic)
-    //   assert.equal(txid, 'complete tx id result')
-    // })
-
     it('should throw an error if the hex is not provided', async () => {
       try {
         const hdIndex = 11
@@ -134,11 +437,91 @@ describe('#wallet', () => {
     it('should throw an error if the hdIndex is not provided', async () => {
       try {
         const hex = 'hex'
-        await uut.completeTx(hex, null)
+        await uut.completeTx(hex)
         assert.fail('Unexpected code path')
       } catch (error) {
         assert.equal(error.message, 'hdIndex must be a non-negative number!')
       }
     })
+    it('should throw an error if the mnemonic is not provided', async () => {
+      try {
+        const hex = 'hex'
+        const hdIndex = 11
+        await uut.completeTx(hex, hdIndex)
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'mnemonic must be a string!')
+      }
+    })
+    it('should complete a transaction', async () => {
+      sandbox.stub(uut, 'getKeyPair').resolves({
+        cashAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+        wif: 'L5D2UAam8tvo3uii5kpgaGyjvVMimdrXu8nWGQSQjuuAix6ji1YQ',
+        hdIndex: 11
+      })
+      sandbox.stub(uut, 'deseralizeTx').resolves({
+        txid: 'complete tx id result'
+      })
+      sandbox.stub(uut.retryQueue, 'addToQueue').resolves('complete tx id result')
+
+      const hex = 'hex'
+      const hdIndex = 11
+      const mnemonic = 'course abstract aerobic deer try switch turtle diet fence affair butter top'
+
+      const txid = await uut.completeTx(hex, hdIndex, mnemonic)
+      assert.equal(txid, 'complete tx id result')
+    })
+  })
+
+  describe('#reClaimTokens', () => {
+    it('should re-claim tokens', async () => {
+      const orderData = {
+        hdIndex: 11,
+        tokenId: 'tokenId',
+        numTokens: 1
+      }
+      const res = await uut.reclaimTokens(orderData)
+      assert.equal(res, 'fakeTxid')
+    })
+    it('should handle error if order hd index is not provided', async () => {
+      try {
+        const orderData = {}
+        await uut.reclaimTokens(orderData)
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'orderData.hdIndex is required!')
+      }
+    })
+  })
+  describe('#cid2json', () => {
+    it('should throw error if cid is not provided', async () => {
+      try {
+        await uut.cid2json()
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.equal(error.message, 'urlOrCid must be a string!')
+      }
+    })
+
+    it('should convert cid to json', async () => {
+      try {
+        sandbox.stub(uut.bchWallet, 'cid2json').resolves({ json: offerMockData.mutableDataMock })
+        const cid = 'bafkreidr6wfd6mcmwpea7abm5uk5rrprc2wfbcvo5wdcmtlolrpjab5oqm'
+        const result = await uut.cid2json(cid)
+        assert.isObject(result)
+      } catch (error) {
+        assert.fail('Unexpected code path')
+      }
+    })
+    it('should convert ipfs url to json', async () => {
+      try {
+        sandbox.stub(uut.bchWallet, 'cid2json').resolves({ json: offerMockData.mutableDataMock })
+        const url = 'https://ipfs.io/ipfs/bafkreidr6wfd6mcmwpea7abm5uk5rrprc2wfbcvo5wdcmtlolrpjab5oqm'
+        const result = await uut.cid2json(url)
+        assert.isObject(result)
+      } catch (error) {
+        assert.fail('Unexpected code path')
+      }
+    })
   })
 })

test/unit/adapters/webhook.adapter.unit.js

@@ -65,4 +65,51 @@ describe('#Webhook-Adapter', () => {
       assert.isString(result.id)
     })
   })
+  describe('#deleteWebhook', () => {
+    it('should throw error if input is not provided', async () => {
+      try {
+        await uut.deleteWebhook()
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'url must be a string')
+      }
+    })
+    it('should delete webhook', async () => {
+      sandbox.stub(uut.axios, 'delete').resolves({ data: { success: true } })
+      const url = 'https://test.com/my-webhook'
+      const result = await uut.deleteWebhook(url)
+      assert.isObject(result)
+      assert.property(result, 'success')
+    })
+  })
+  describe('#waitUntilSuccess', () => {
+    it('should handle error', async () => {
+      try {
+        sandbox.stub(uut, 'sleep').throws(new Error('test error'))
+        sandbox.stub(uut, 'deleteWebhook')
+          .onCall(0).throws(new Error('test error'))
+
+        sandbox.stub(uut, 'createWebhook')
+          .onCall(0).throws(new Error('test error'))
+          .onCall(1).resolves({ data: { success: true } })
+        await uut.waitUntilSuccess()
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should wait until success', async () => {
+      uut.sleepTime = 100
+
+      sandbox.stub(uut, 'deleteWebhook')
+        .onCall(0).throws(new Error('test error'))
+
+      sandbox.stub(uut, 'createWebhook')
+        .onCall(0).throws(new Error('test error'))
+        .onCall(1).resolves({ data: { success: true } })
+
+      const result = await uut.waitUntilSuccess()
+      assert.isTrue(result)
+    })
+  })
 })

test/unit/controllers/rest-api/nostr/nostr.rest.controller.unit.js

@@ -0,0 +1,201 @@
+/*
+  Unit tests for the REST API handler for the /nostr endpoints.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local support libraries
+import adapters from '../../../mocks/adapters/index.js'
+import UseCasesMock from '../../../mocks/use-cases/index.js'
+import NostrController from '../../../../../src/controllers/rest-api/nostr/controller.js'
+
+import { context as mockContext } from '../../../../unit/mocks/ctx-mock.js'
+let uut
+let sandbox
+let ctx
+
+describe('#Nostr-REST-Controller', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new NostrController({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    ctx = mockContext()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new NostrController()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating /nostr REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new NostrController({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating /nostr REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#POST /nostr/deletedChat', () => {
+    it('should return 422 status on biz logic error', async () => {
+      try {
+        sandbox.stub(uut.useCases.nostr, 'createDeletedChat').rejects(new Error('test error'))
+        await uut.createDeletedChat(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        // console.log(err)
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should return 200 status on success', async () => {
+      ctx.request.body = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+        npub: 'npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8',
+        bchAddr: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a',
+        pubkey: '6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1'
+      }
+
+      await uut.createDeletedChat(ctx)
+
+      // Assert the expected HTTP response
+      assert.equal(ctx.status, 200)
+
+      assert.isObject(ctx.response.body)
+    })
+  })
+
+  describe('#GET /nostr/deletedChat', () => {
+    it('should return 422 status on arbitrary biz logic error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.useCases.nostr, 'getDeletedChats')
+          .rejects(new Error('test error'))
+
+        await uut.getDeletedChats(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should return 200 status on success', async () => {
+      await uut.getDeletedChats(ctx)
+
+      // Assert the expected HTTP response
+      assert.equal(ctx.status, 200)
+
+      // Assert that expected properties exist in the returned data.
+      assert.isObject(ctx.response.body)
+      assert.property(ctx.response.body, 'deletedChats')
+      assert.isArray(ctx.response.body.deletedChats)
+    })
+  })
+  describe('#POST /nostr/deletedPost', () => {
+    it('should return 422 status on biz logic error', async () => {
+      try {
+        sandbox.stub(uut.useCases.nostr, 'createDeletedPost').rejects(new Error('test error'))
+        await uut.createDeletedPost(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should return 200 status on success', async () => {
+      ctx.request.body = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+        npub: 'npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8',
+        bchAddr: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a',
+        pubkey: '6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1'
+      }
+
+      await uut.createDeletedPost(ctx)
+
+      assert.equal(ctx.status, 200)
+
+      assert.isObject(ctx.response.body)
+      assert.property(ctx.response.body, 'deletedPost')
+      assert.isObject(ctx.response.body.deletedPost)
+    })
+  })
+  describe('#GET /nostr/deletedPost', () => {
+    it('should return 422 status on biz logic error', async () => {
+      try {
+        sandbox.stub(uut.useCases.nostr, 'getDeletedPosts').rejects(new Error('test error'))
+        await uut.getDeletedPosts(ctx)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 422)
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should return 200 status on success', async () => {
+      await uut.getDeletedPosts(ctx)
+
+      // Assert the expected HTTP response
+      assert.equal(ctx.status, 200)
+
+      assert.isObject(ctx.response.body)
+      assert.property(ctx.response.body, 'deletedPosts')
+      assert.isArray(ctx.response.body.deletedPosts)
+    })
+  })
+
+  describe('#handleError', () => {
+    it('should still throw error if there is no message', () => {
+      try {
+        const err = {
+          status: 404
+        }
+
+        uut.handleError(ctx, err)
+      } catch (err) {
+        assert.include(err.message, 'Not Found')
+      }
+    })
+
+    it('should throw error with message', () => {
+      try {
+        const err = {
+          status: 422,
+          message: 'test error'
+        }
+
+        uut.handleError(ctx, err)
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+})

test/unit/controllers/rest-api/nostr/nostr.rest.router.unit.js

@@ -0,0 +1,108 @@
+/*
+  Unit tests for the REST API handler for the /nostr endpoints.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+
+import sinon from 'sinon'
+
+// Local support libraries
+import adapters from '../../../mocks/adapters/index.js'
+
+import UseCasesMock from '../../../mocks/use-cases/index.js'
+
+// const app = require('../../../mocks/app-mock')
+
+import NostrRouter from '../../../../../src/controllers/rest-api/nostr/index.js'
+
+let uut
+let sandbox
+// let ctx
+
+// const mockContext = require('../../../../unit/mocks/ctx-mock').context
+
+describe('#Nostr-REST-Router', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new NostrRouter({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    // ctx = mockContext()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new NostrRouter()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating NostrRouter REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new NostrRouter({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating NostrRouter REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#attach', () => {
+    it('should throw an error if app is not passed in.', () => {
+      try {
+        uut.attach()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must pass app object when attaching REST API controllers.'
+        )
+      }
+    })
+  })
+
+  describe('#createDeletedChat', () => {
+    it('should route to the createDeletedChat function', async () => {
+      // Stub functions
+      const validationSpy = sandbox.stub(uut.validators, 'ensureAdmin').resolves(true)
+      sandbox.stub(uut.nostrRESTController, 'createDeletedChat').resolves(true)
+
+      // Call function
+      const res = await uut.createDeletedChat()
+      assert.isTrue(validationSpy.calledOnce, 'Admin validator should be called')
+      assert.isTrue(res)
+    })
+  })
+
+  describe('#createDeletedPost', () => {
+    it('should route to the createDeletedPost function', async () => {
+      // Stub functions
+      const validationSpy = sandbox.stub(uut.validators, 'ensureAdmin').resolves(true)
+      sandbox.stub(uut.nostrRESTController, 'createDeletedPost').resolves(true)
+
+      // Call function
+      const res = await uut.createDeletedPost()
+      assert.isTrue(validationSpy.calledOnce, 'Admin validator should be called')
+      assert.isTrue(res)
+    })
+  })
+})

test/unit/controllers/rest-api/offer/offer.rest.controller.unit.js

@@ -91,25 +91,186 @@ describe('#Offer-REST-Router', () => {
       // assert.equal(ctx.body.hash, 'testHash')
     })
 
-    // it('should catch and throw an error', async () => {
-    //   try {
-    //     ctx.request.body = {
-    //       offer: {}
-    //     }
-    //
-    //     // Force an error
-    //     sandbox
-    //       .stub(uut.useCases.offer, 'createOffer')
-    //       .rejects(new Error('test error'))
-    //
-    //     await uut.createOffer(ctx)
-    //
-    //     assert.fail('Unexpected code path')
-    //   } catch (err) {
-    //     // console.log('err: ', err)
-    //     assert.include(err.message, 'test error')
-    //   }
-    // })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.request.body = {
+          offer: {}
+        }
+
+        // Force an error
+        sandbox
+          .stub(uut.useCases.offer, 'createOffer')
+          .rejects(new Error('test error'))
+
+        await uut.createOffer(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#listOffers', () => {
+    it('should list offers', async () => {
+      ctx.params = { page: 0 }
+      sandbox.stub(uut.useCases.offer, 'listOffers').resolves([])
+      await uut.listOffers(ctx)
+      assert.isArray(ctx.body)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params = { }
+        sandbox
+          .stub(uut.useCases.offer, 'listOffers')
+          .throws(new Error('test error'))
+
+        await uut.listOffers(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#listNftOffers', () => {
+    it('should list nft offers', async () => {
+      ctx.params = { page: 0 }
+      sandbox.stub(uut.useCases.offer, 'listNftOffers').resolves([])
+      await uut.listNftOffers(ctx)
+      assert.isArray(ctx.body)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params = { page: 0 }
+        sandbox
+          .stub(uut.useCases.offer, 'listNftOffers')
+          .throws(new Error('test error'))
+
+        await uut.listNftOffers(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#listFungibleOffers', () => {
+    it('should list fungible offers', async () => {
+      ctx.params = { page: 0 }
+      sandbox.stub(uut.useCases.offer, 'listFungibleOffers').resolves([])
+      await uut.listFungibleOffers(ctx)
+      assert.isArray(ctx.body)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params = { page: 0 }
+        sandbox
+          .stub(uut.useCases.offer, 'listFungibleOffers')
+          .throws(new Error('test error'))
+
+        await uut.listFungibleOffers(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#takeOffer', () => {
+    it('should take an offer', async () => {
+      ctx.request.body = {
+        nostrEventId: 'testEventId'
+      }
+
+      sandbox.stub(uut.useCases.offer, 'takeOffer').resolves({ eventId: 'testEventId', noteId: 'testNoteId' })
+      await uut.takeOffer(ctx)
+      assert.isObject(ctx.body)
+      assert.property(ctx.body, 'eventId')
+      assert.property(ctx.body, 'noteId')
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.request.body = {
+          nostrEventId: 'testEventId'
+        }
+
+        sandbox
+          .stub(uut.useCases.offer, 'takeOffer')
+          .throws(new Error('test error'))
+
+        await uut.takeOffer(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#listOffersByAddress', () => {
+    it('should list offers by address', async () => {
+      ctx.params = { addr: 'testAddress' }
+      sandbox.stub(uut.useCases.offer, 'listOffersByAddress').resolves([])
+      await uut.listOffersByAddress(ctx)
+      assert.isArray(ctx.body)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params = { addr: 'testAddress' }
+        sandbox
+          .stub(uut.useCases.offer, 'listOffersByAddress')
+          .throws(new Error('test error'))
+
+        await uut.listOffersByAddress(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+  describe('#syncOfferMutableData', () => {
+    it('should sync mutable data', async () => {
+      ctx.request.body = { tokenId: 'tokenId' }
+      sandbox.stub(uut.useCases.offer, 'syncOfferMutableData').resolves({})
+      await uut.syncOfferMutableData(ctx)
+      assert.isObject(ctx.body)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.request.body = { tokenId: 'tokenId' }
+        sandbox
+          .stub(uut.useCases.offer, 'syncOfferMutableData')
+          .throws(new Error('test error'))
+
+        await uut.syncOfferMutableData(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#listCounterOffersByAddress', () => {
+    it('should list counter offers by address', async () => {
+      ctx.params = { addr: 'testAddress' }
+      sandbox.stub(uut.useCases.offer, 'listCounterOffersByAddress').resolves([])
+      await uut.listCounterOffersByAddress(ctx)
+      assert.isArray(ctx.body.counterOffers)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params = { addr: 'testAddress' }
+        sandbox
+          .stub(uut.useCases.offer, 'listCounterOffersByAddress')
+          .throws(new Error('test error'))
+
+        await uut.listCounterOffersByAddress(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
   })
 
   describe('#handleError', () => {

test/unit/controllers/rest-api/order/order.rest.controller.unit.js

@@ -101,7 +101,47 @@ describe('#Order-REST-Router', () => {
       }
     })
   })
+  describe('#listOrders', () => {
+    it('should list orders', async () => {
+      ctx.params = { page: 0 }
+      sandbox.stub(uut.useCases.order, 'listOrders').resolves([])
+      await uut.listOrders(ctx)
+      assert.isArray(ctx.body)
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params = { page: 0 }
+        sandbox.stub(uut.useCases.order, 'listOrders').throws(new Error('test error'))
+        await uut.listOrders(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
 
+  describe('#deleteOrder', () => {
+    it('should delete an order', async () => {
+      ctx.request.body = {
+        nostrEventId: 'testEventId'
+      }
+      sandbox.stub(uut.useCases.order, 'deleteOrder').resolves('testTxid')
+      await uut.deleteOrder(ctx)
+      assert.equal(ctx.body.txid, 'testTxid')
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.request.body = {
+          nostrEventId: 'testEventId'
+        }
+        sandbox.stub(uut.useCases.order, 'deleteOrder').throws(new Error('test error'))
+        await uut.deleteOrder(ctx)
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
   describe('#handleError', () => {
     it('should still throw error if there is no message', () => {
       try {

test/unit/controllers/rest-api/order/order.rest.router.unit.js

@@ -74,4 +74,22 @@ describe('#Order-REST-Router', () => {
       }
     })
   })
+  describe('#createOrder', () => {
+    it('should route to controller', async () => {
+      sandbox.stub(uut.validators, 'ensureUser').resolves(true)
+      const spy = sandbox.stub(uut.orderRESTController, 'createOrder').resolves(true)
+
+      await uut.createOrder()
+      assert.isTrue(spy.calledOnce)
+    })
+  })
+  describe('#deleteOrder', () => {
+    it('should route to controller', async () => {
+      sandbox.stub(uut.validators, 'ensureUser').resolves(true)
+      const spy = sandbox.stub(uut.orderRESTController, 'deleteOrder').resolves(true)
+
+      await uut.deleteOrder()
+      assert.isTrue(spy.calledOnce)
+    })
+  })
 })

test/unit/controllers/rest-api/p2wdb/p2wdb.rest.controller.unit.js

@@ -0,0 +1,160 @@
+/*
+  Unit tests for the REST API handler for the /sm endpoints.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local support libraries
+import adapters from '../../../mocks/adapters/index.js'
+import UseCasesMock from '../../../mocks/use-cases/index.js'
+import P2WDBRESTController from '../../../../../src/controllers/rest-api/p2wdb/controller.js'
+
+import { context as mockContext } from '../../../../unit/mocks/ctx-mock.js'
+
+let uut
+let sandbox
+let ctx
+
+describe('#P2WDB-REST-Router', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new P2WDBRESTController({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    ctx = mockContext()
+    ctx.params = { }
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new P2WDBRESTController()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating /p2wdb REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new P2WDBRESTController({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating /p2wdb REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#routeWebhook', () => {
+    it('should route the webhook for a new counter offer', async () => {
+      ctx.request = {
+        body: {
+          data: {
+            dataType: 'counter-offer'
+          }
+        }
+      }
+      sandbox.stub(uut.useCases.offer, 'acceptCounterOffer').resolves()
+
+      await uut.routeWebhook(ctx)
+
+      assert.isTrue(true)
+    })
+    it('should route the webhook for a new  offer', async () => {
+      ctx.request = {
+        body: {
+          data: {
+            dataType: 'offer'
+          }
+        }
+      }
+      sandbox.stub(uut.useCases.offer, 'createOffer').resolves()
+
+      await uut.routeWebhook(ctx)
+
+      assert.isTrue(true)
+    })
+    it('should route the webhook flag', async () => {
+      ctx.request = {
+        body: {
+          data: {
+            dataType: 'flag'
+          }
+        }
+      }
+      sandbox.stub(uut.useCases.offer, 'flagOffer').resolves()
+
+      await uut.routeWebhook(ctx)
+
+      assert.isTrue(true)
+    })
+    it('should handle unknown data type', async () => {
+      ctx.request = {
+        body: {
+          data: {
+            dataType: 'unknown'
+          }
+        }
+      }
+      sandbox.stub(uut.useCases.offer, 'flagOffer').resolves()
+
+      await uut.routeWebhook(ctx)
+
+      assert.isTrue(true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.request.body = {}
+
+        await uut.routeWebhook(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'Cannot read properties of undefined')
+      }
+    })
+    describe('#handleError', () => {
+      it('should still throw error if there is no message', () => {
+        try {
+          const err = {
+            status: 404
+          }
+
+          uut.handleError(ctx, err)
+        } catch (err) {
+          assert.include(err.message, 'Not Found')
+        }
+      })
+      it('should catch error if message is provided', () => {
+        try {
+          const err = {
+            status: 422,
+            message: 'Unprocessable Entity'
+          }
+
+          uut.handleError(ctx, err)
+        } catch (err) {
+          assert.include(err.message, 'Unprocessable Entity')
+        }
+      })
+    })
+  })
+})

test/unit/controllers/rest-api/p2wdb/p2wdb.rest.router.unit.js

@@ -0,0 +1,77 @@
+/*
+  Unit tests for the REST API handler for the /p2wdb endpoints.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local support libraries
+import adapters from '../../../mocks/adapters/index.js'
+import UseCasesMock from '../../../mocks/use-cases/index.js'
+import P2WDBRouter from '../../../../../src/controllers/rest-api/p2wdb/index.js'
+
+let uut
+let sandbox
+// let ctx
+
+// const mockContext = require('../../../../unit/mocks/ctx-mock').context
+
+describe('#P2WDB-REST-Router', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new P2WDBRouter({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    // ctx = mockContext()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new P2WDBRouter()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating /p2wdb REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new P2WDBRouter({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating /p2wdb REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#attach', () => {
+    it('should throw an error if app is not passed in.', () => {
+      try {
+        uut.attach()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must pass app object when attached REST API controllers.'
+        )
+      }
+    })
+  })
+})

test/unit/controllers/rest-api/smAccount/smAccount.rest.controller.unit.js

@@ -0,0 +1,203 @@
+/*
+  Unit tests for the REST API handler for the /sm endpoints.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local support libraries
+import adapters from '../../../mocks/adapters/index.js'
+import UseCasesMock from '../../../mocks/use-cases/index.js'
+import SmAccountRESTController from '../../../../../src/controllers/rest-api/smAccount/controller.js'
+
+import { context as mockContext } from '../../../../unit/mocks/ctx-mock.js'
+
+let uut
+let sandbox
+let ctx
+
+describe('#SmAccount-REST-Router', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new SmAccountRESTController({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    ctx = mockContext()
+    ctx.params = { }
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new SmAccountRESTController()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating /sm REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new SmAccountRESTController({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating /sm REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#listAccounts', () => {
+    it('should list all social media accounts', async () => {
+      ctx.params.page = 0
+
+      // Mock dependencies
+      sandbox.stub(uut.useCases.smAccount, 'listAccounts').resolves([])
+
+      await uut.listAccounts(ctx)
+
+      assert.isArray(ctx.body)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        ctx.params.page = 0
+
+        // Force an error
+        sandbox.stub(uut.useCases.smAccount, 'listAccounts')
+          .throws(new Error('test error'))
+
+        await uut.listAccounts(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#getAccountByNpub', () => {
+    it('should get a social media account by npub', async () => {
+      sandbox.stub(uut.useCases.smAccount, 'getAccountByNpub').resolves({ npub: 'testNpub' })
+      ctx.params.npub = 'testNpub'
+
+      await uut.getAccountByNpub(ctx)
+    })
+    it('should throw 400 if npub is not provided', async () => {
+      try {
+        await uut.getAccountByNpub(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Npub is required')
+      }
+    })
+    it('should throw 400 if npub is not found', async () => {
+      try {
+        sandbox.stub(uut.useCases.smAccount, 'getAccountByNpub').resolves(null)
+        ctx.params.npub = 'testNpub'
+        await uut.getAccountByNpub(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Account not found')
+      }
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        sandbox.stub(uut.useCases.smAccount, 'getAccountByNpub').throws(new Error('test error'))
+        ctx.params.npub = 'testNpub'
+
+        await uut.getAccountByNpub(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#getAccountByBchAddr', () => {
+    it('should get a social media account by npub', async () => {
+      sandbox.stub(uut.useCases.smAccount, 'getAccountByBchAddr').resolves({ bchAddr: 'testBchAddr' })
+      ctx.params.bchAddr = 'testBchAddr'
+
+      await uut.getAccountByBchAddr(ctx)
+    })
+
+    it('should throw 400 if bchAddr is not provided', async () => {
+      try {
+        await uut.getAccountByBchAddr(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'BCH address is required')
+      }
+    })
+
+    it('should throw 400 if bchAddr is not found', async () => {
+      try {
+        sandbox.stub(uut.useCases.smAccount, 'getAccountByBchAddr').resolves(null)
+        ctx.params.bchAddr = 'testBchAddr'
+        await uut.getAccountByBchAddr(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Account not found')
+      }
+    })
+    it('should catch and throw an error', async () => {
+      try {
+        sandbox.stub(uut.useCases.smAccount, 'getAccountByBchAddr').throws(new Error('test error'))
+        ctx.params.bchAddr = 'testBchAddr'
+
+        await uut.getAccountByBchAddr(ctx)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#handleError', () => {
+    it('should still throw error if there is no message', () => {
+      try {
+        const err = {
+          status: 404
+        }
+
+        uut.handleError(ctx, err)
+      } catch (err) {
+        assert.include(err.message, 'Not Found')
+      }
+    })
+    it('should catch error if message is provided', () => {
+      try {
+        const err = {
+          status: 422,
+          message: 'Unprocessable Entity'
+        }
+
+        uut.handleError(ctx, err)
+      } catch (err) {
+        assert.include(err.message, 'Unprocessable Entity')
+      }
+    })
+  })
+})

test/unit/controllers/rest-api/smAccount/smAccount.rest.router.unit.js

@@ -0,0 +1,77 @@
+/*
+  Unit tests for the REST API handler for the /sm endpoints.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Local support libraries
+import adapters from '../../../mocks/adapters/index.js'
+import UseCasesMock from '../../../mocks/use-cases/index.js'
+import SmAccountRouter from '../../../../../src/controllers/rest-api/smAccount/index.js'
+
+let uut
+let sandbox
+// let ctx
+
+// const mockContext = require('../../../../unit/mocks/ctx-mock').context
+
+describe('#SmAccount-REST-Router', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new SmAccountRouter({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    // ctx = mockContext()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new SmAccountRouter()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating /sm REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new SmAccountRouter({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating /sm REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#attach', () => {
+    it('should throw an error if app is not passed in.', () => {
+      try {
+        uut.attach()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Must pass app object when attached REST API controllers.'
+        )
+      }
+    })
+  })
+})

test/unit/controllers/rest-api/users/users.rest.router.unit.js

@@ -108,25 +108,25 @@ describe('#Users-REST-Router', () => {
     })
   })
 
-  // describe('#getAll', () => {
-  //   it('should route to controller', async () => {
-  //     sandbox.stub(uut.validators, 'ensureUser').resolves(true)
-  //     const spy = sandbox.stub(uut.userRESTController, 'getUsers').resolves(true)
+  describe('#getAll', () => {
+    it('should route to controller', async () => {
+      sandbox.stub(uut.validators, 'ensureAdmin').resolves(true)
+      const spy = sandbox.stub(uut.userRESTController, 'getUsers').resolves(true)
 
-  //     await uut.getAll()
-  //     assert.isTrue(spy.calledOnce)
-  //   })
-  // })
+      await uut.getAll()
+      assert.isTrue(spy.calledOnce)
+    })
+  })
 
-  // describe('#getById', () => {
-  //   it('should route to controller', async () => {
-  //     sandbox.stub(uut.validators, 'ensureUser').resolves(true)
-  //     const spy = sandbox.stub(uut.userRESTController, 'getUser').resolves(true)
+  describe('#getById', () => {
+    it('should route to controller', async () => {
+      sandbox.stub(uut.validators, 'ensureTargetUserOrAdmin').resolves(true)
+      const spy = sandbox.stub(uut.userRESTController, 'getUser').resolves(true)
 
-  //     await uut.getById()
-  //     assert.isTrue(spy.calledOnce)
-  //   })
-  // })
+      await uut.getById()
+      assert.isTrue(spy.calledOnce)
+    })
+  })
 
   describe('#updateUser', () => {
     it('should route to controller', async () => {

test/unit/controllers/timer-controllers.unit.js

@@ -130,12 +130,12 @@ describe('#Timer-Controllers', () => {
       assert.equal(result, true)
     })
 
-    // it('should return false on error', async () => {
-    //   sandbox.stub(uut.useCases.usage, 'cleanUsage').throws(new Error('test error'))
-    //   const result = await uut.cleanUsage()
+    it('should return false on error', async () => {
+      sandbox.stub(uut.useCases.usage, 'cleanUsage').throws(new Error('test error'))
+      const result = await uut.cleanUsage()
 
-    //   assert.equal(result, false)
-    // })
+      assert.equal(result, false)
+    })
   })
 
   describe('#backupUsage', () => {
@@ -154,4 +154,53 @@ describe('#Timer-Controllers', () => {
       assert.equal(result, false)
     })
   })
+
+  describe('#newSmAccounts', () => {
+    it('should kick off the Use Case', async () => {
+      const result = await uut.newSmAccounts()
+
+      assert.equal(result, true)
+    })
+
+    it('should return false on error', async () => {
+      sandbox.stub(uut.useCases.smAccount, 'checkForNewSmAccounts').throws(new Error('test error'))
+      // sandbox.stub(uut.useCases.usage, 'saveUsage').throws(new Error('test error'))
+
+      const result = await uut.newSmAccounts()
+
+      assert.equal(result, false)
+    })
+  })
+  describe('#updateSmAccounts', () => {
+    it('should kick off the Use Case', async () => {
+      const result = await uut.updateSmAccounts()
+
+      assert.equal(result, true)
+    })
+
+    it('should return false on error', async () => {
+      sandbox.stub(uut.useCases.smAccount, 'updateSmAccounts').throws(new Error('test error'))
+      // sandbox.stub(uut.useCases.usage, 'saveUsage').throws(new Error('test error'))
+
+      const result = await uut.updateSmAccounts()
+
+      assert.equal(result, false)
+    })
+  })
+  describe('#removeOlderDeletedChatsAndPosts', () => {
+    it('should kick off the Use Cases and return true', async () => {
+      sandbox.stub(uut.useCases.nostr, 'removeOlderDeletedChats').resolves()
+      sandbox.stub(uut.useCases.nostr, 'removeOlderDeletedPosts').resolves()
+      const result = await uut.removeOlderDeletedChatsAndPosts()
+
+      assert.equal(result, true)
+    })
+  })
+  it('should kick off the Use Cases and return false on error', async () => {
+    sandbox.stub(uut.useCases.nostr, 'removeOlderDeletedChats').throws(new Error('test error'))
+    sandbox.stub(uut.useCases.nostr, 'removeOlderDeletedPosts').throws(new Error('test error'))
+    const result = await uut.removeOlderDeletedChatsAndPosts()
+
+    assert.equal(result, false)
+  })
 })

test/unit/entities/counterOffer.entity.unit.js

@@ -0,0 +1,116 @@
+/*
+  Unit tests for the CounterOffer entity library.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import CounterOfferEntity from '../../../src/entities/counterOffer.js'
+
+let sandbox
+let uut
+
+describe('#CounterOffer-Entity', () => {
+  before(async () => {})
+
+  beforeEach(() => {
+    uut = new CounterOfferEntity()
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#validate', () => {
+    it('should throw an error if data is not provided', () => {
+      try {
+        uut.validate({ })
+      } catch (err) {
+        assert.include(err.message, 'Input to counterOffer.validate() must be an object with a data property.')
+      }
+    })
+    it('should throw an error if nostrEventId is not provided', () => {
+      try {
+        uut.validate({ data: {} })
+      } catch (err) {
+        assert.include(err.message, "Property 'nostrEventId' must be a string")
+      }
+    })
+    it('should throw an error if provided takerAddr is not string', () => {
+      try {
+        const inObj = {
+          nostrEventId: 'nostr event id',
+          takerAddr: 1234
+        }
+        uut.validate({ data: inObj })
+      } catch (err) {
+        assert.include(err.message, "Property 'takerAddr' must be a string")
+      }
+    })
+    it('should throw an error if provided takerNpub is not string', () => {
+      try {
+        const inObj = {
+          nostrEventId: 'nostr event id',
+          takerAddr: 'taker address',
+          takerNpub: 1234
+        }
+        uut.validate({ data: inObj })
+      } catch (err) {
+        assert.include(err.message, "Property 'takerNpub' must be a string")
+      }
+    })
+    it('should throw an error if provided counterOfferAddr is not string', () => {
+      try {
+        const inObj = {
+          nostrEventId: 'nostr event id',
+          takerAddr: 'taker address',
+          takerNpub: 'npub',
+          counterOfferAddr: 1234
+        }
+        uut.validate({ data: inObj })
+      } catch (err) {
+        assert.include(err.message, "Property 'counterOfferAddr' must be a string")
+      }
+    })
+    it('should throw an error if provided counterOfferUtxo is not string', () => {
+      try {
+        const inObj = {
+          nostrEventId: 'nostr event id',
+          takerAddr: 'taker address',
+          takerNpub: 'npub',
+          counterOfferAddr: 'counter offer address',
+          counterOfferUtxo: 1234
+        }
+        uut.validate({ data: inObj })
+      } catch (err) {
+        assert.include(err.message, "Property 'counterOfferUtxo' must be a string")
+      }
+    })
+    it('should return a counter offer object', () => {
+      const inObj = {
+        nostrEventId: 'nostr event id',
+        takerAddr: 'taker address',
+        takerNpub: 'npub',
+        counterOfferAddr: 'counter offer address',
+        counterOfferUtxo: 'utxo txid'
+      }
+
+      const counterOfferEntity = uut.validate({ data: inObj })
+
+      assert.property(counterOfferEntity, 'nostrEventId')
+      assert.equal(counterOfferEntity.nostrEventId, inObj.nostrEventId)
+
+      assert.property(counterOfferEntity, 'takerAddr')
+      assert.equal(counterOfferEntity.takerAddr, inObj.takerAddr)
+
+      assert.property(counterOfferEntity, 'takerNpub')
+      assert.equal(counterOfferEntity.takerNpub, inObj.takerNpub)
+
+      assert.property(counterOfferEntity, 'counterOfferAddr')
+      assert.equal(counterOfferEntity.counterOfferAddr, inObj.counterOfferAddr)
+
+      assert.property(counterOfferEntity, 'counterOfferUtxo')
+      assert.equal(counterOfferEntity.counterOfferUtxo, inObj.counterOfferUtxo)
+    })
+  })
+})

test/unit/entities/deletedChat.entity.unit.js

@@ -0,0 +1,57 @@
+/*
+  Unit tests for the DeletedChat entity library.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import DeletedChat from '../../../src/entities/deletedChat.js'
+
+let sandbox
+let uut
+
+describe('#DeletedChat-Entity', () => {
+  before(async () => {})
+
+  beforeEach(() => {
+    uut = new DeletedChat()
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#validate', () => {
+    it('should throw an error if eventId is not provided', () => {
+      try {
+        uut.validate()
+      } catch (err) {
+        assert.include(err.message, "Property 'eventId' must be a string!")
+      }
+    })
+
+    it('should return a DeletedChat object', () => {
+      const inputData = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+        npub: 'npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8',
+        bchAddr: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a',
+        pubkey: '6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1'
+      }
+
+      const deletedChat = uut.validate(inputData)
+      // console.log('entry: ', entry)
+
+      assert.property(deletedChat, 'eventId')
+      assert.equal(deletedChat.eventId, inputData.eventId)
+
+      assert.property(deletedChat, 'npub')
+      assert.equal(deletedChat.npub, inputData.npub)
+
+      assert.property(deletedChat, 'bchAddr')
+      assert.equal(deletedChat.bchAddr, inputData.bchAddr)
+
+      assert.property(deletedChat, 'pubkey')
+      assert.equal(deletedChat.pubkey, inputData.pubkey)
+    })
+  })
+})

test/unit/entities/deletedPost.entity.unit.js

@@ -0,0 +1,57 @@
+/*
+  Unit tests for the DeletedPost entity library.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import DeletedPost from '../../../src/entities/deletedPost.js'
+
+let sandbox
+let uut
+
+describe('#DeletedPost-Entity', () => {
+  before(async () => { })
+
+  beforeEach(() => {
+    uut = new DeletedPost()
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#validate', () => {
+    it('should throw an error if eventId is not provided', () => {
+      try {
+        uut.validate()
+      } catch (err) {
+        assert.include(err.message, "Property 'eventId' must be a string!")
+      }
+    })
+
+    it('should return a DeletedPost object', () => {
+      const inputData = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+        npub: 'npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8',
+        bchAddr: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a',
+        pubkey: '6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1'
+      }
+
+      const deletedPost = uut.validate(inputData)
+      // console.log('entry: ', entry)
+
+      assert.property(deletedPost, 'eventId')
+      assert.equal(deletedPost.eventId, inputData.eventId)
+
+      assert.property(deletedPost, 'npub')
+      assert.equal(deletedPost.npub, inputData.npub)
+
+      assert.property(deletedPost, 'bchAddr')
+      assert.equal(deletedPost.bchAddr, inputData.bchAddr)
+
+      assert.property(deletedPost, 'pubkey')
+      assert.equal(deletedPost.pubkey, inputData.pubkey)
+    })
+  })
+})

test/unit/entities/offer.entity.unit.js

@@ -237,6 +237,113 @@ describe('#Offer-Entity', () => {
       }
     })
 
+    it('should throw an error if makerAddr is not included', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            operatorAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            operatorPercentage: 10
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'makerAddr' must be a string.")
+      }
+    })
+    it('should throw an error if makerAddr is not a string', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 1234567890
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'makerAddr' must be a string.")
+      }
+    })
+
+    it('should throw an error if tokenType is not included', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            operatorAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            operatorPercentage: 10
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'tokenType' must be a number.")
+      }
+    })
+
+    it('should throw an error if tokenType is not a number', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            tokenType: 'notANumber'
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'tokenType' must be a number.")
+      }
+    })
+
     it('should throw an error if nostrEventId is not included', () => {
       try {
         const offerData = {
@@ -267,6 +374,154 @@ describe('#Offer-Entity', () => {
       }
     })
 
+    it('should throw an error if operatorAddress is not included', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            tokenType: 1,
+            nostrEventId: 'test',
+            operatorPercentage: 10
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'operatorAddress' must be a string.")
+      }
+    })
+
+    it('should throw an error if operatorAddress is not a string', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            tokenType: 1,
+            nostrEventId: 'test',
+            operatorAddress: 1234567890,
+            operatorPercentage: 10
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'operatorAddress' must be a string.")
+      }
+    })
+
+    it('should throw an error if operatorPercentage is not included', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            tokenType: 1,
+            nostrEventId: 'test',
+            operatorAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00'
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'operatorPercentage' must be a number.")
+      }
+    })
+
+    it('should throw an error if operatorPercentage is not a number', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            tokenType: 1,
+            nostrEventId: 'test',
+            operatorAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            operatorPercentage: 'notANumber'
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'operatorPercentage' must be a number.")
+      }
+    })
+    it('should throw an error if makerNpub is not a string', () => {
+      try {
+        const offerData = {
+          data: {
+            messageType: 1,
+            messageClass: 1,
+            tokenId: 'fakeId',
+            buyOrSell: 'buy',
+            rateInBaseUnit: 1000,
+            minUnitsToExchange: 350,
+            numTokens: 1,
+            utxoTxid: 'fakeTxid',
+            utxoVout: 0,
+            offerStatus: 'posted',
+            makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            tokenType: 1,
+            nostrEventId: 'test',
+            operatorAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+            operatorPercentage: 10,
+            makerNpub: 1234
+          }
+        }
+        uut.validate(offerData)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'makerNpub' must be a string.")
+      }
+    })
+
     it('should validate a new offer', () => {
       const offerObj = {
         appId: 'swapTest555',
@@ -286,7 +541,10 @@ describe('#Offer-Entity', () => {
           makerAddr: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
           ticker: 'TROUT',
           tokenType: 1,
-          nostrEventId: 'test'
+          nostrEventId: 'test',
+          operatorAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+          operatorPercentage: 10,
+          makerNpub: 'npub1dtkf954h5k2yuv04xp44g5hnmk5k0ppv8mekxafm2gc0vveaxh6s0297qg'
         },
         timestamp: '2021-09-20T17:54:26.395Z',
         localTimeStamp: '9/20/2021, 10:54:26 AM',
@@ -312,6 +570,8 @@ describe('#Offer-Entity', () => {
       assert.property(result, 'txid')
       assert.property(result, 'p2wdbHash')
       assert.property(result, 'tokenType')
+      assert.property(result, 'makerAddr')
+      assert.property(result, 'makerNpub')
     })
   })
 })

test/unit/entities/order.entity.unit.js

@@ -130,5 +130,71 @@ describe('#Order-Entity', () => {
         assert.include(err.message, "Property 'numTokens' must be a number.")
       }
     })
+    it('should throw an error if numTokens is not a number', () => {
+      try {
+        const data = {
+          messageType: 1,
+          messageClass: 1,
+          tokenId: 'fakeId',
+          buyOrSell: 'buy',
+          rateInBaseUnit: 1000,
+          minUnitsToExchange: 350,
+          numTokens: 'notANumber'
+        }
+        uut.inputValidate(data)
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'numTokens' must be a number.")
+      }
+    })
+    it('should throw an error if makerAddress is not included', () => {
+      try {
+        const data = {
+          messageType: 1,
+          messageClass: 1,
+          tokenId: 'fakeId',
+          buyOrSell: 'buy',
+          rateInBaseUnit: 1000,
+          minUnitsToExchange: 350,
+          numTokens: 1000
+        }
+        uut.inputValidate(data)
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'makerAddr' must be a string.")
+      }
+    })
+    it('should throw an error if makerAddress is not a string', () => {
+      try {
+        const data = {
+          messageType: 1,
+          messageClass: 1,
+          tokenId: 'fakeId',
+          buyOrSell: 'buy',
+          rateInBaseUnit: 1000,
+          minUnitsToExchange: 350,
+          numTokens: 1000,
+          makerAddr: 1234567890
+        }
+        uut.inputValidate(data)
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, "Property 'makerAddr' must be a string.")
+      }
+    })
+    it('should return the correct data', () => {
+      const data = {
+        messageType: 1,
+        messageClass: 1,
+        tokenId: 'fakeId',
+        buyOrSell: 'buy',
+        rateInBaseUnit: 1000,
+        minUnitsToExchange: 350,
+        numTokens: 1000,
+        makerAddr: 'fakeAddr'
+      }
+      const result = uut.inputValidate(data)
+      assert.deepEqual(result, data)
+    })
   })
 })

test/unit/mocks/adapters/index.js

@@ -149,11 +149,58 @@ const localdb = {
     static findById () {}
     static find () {}
     static findOne () {}
+    static countDocuments(){}
+    async save () {
+      return {}
+    }
+  },
+  CounterOffer: class CounterOffer {
+    constructor (obj) {}
+
+    static findById () {}
+    static find () {}
+    static findOne () {}
+    static countDocuments(){}
+    async save () {
+      return {}
+    }
+  },
+  SmAccount: class SmAccount {
+    constructor (obj) {}
+
+    static findById () {}
+    static find () {}
+    static findOne () {}
+    static updateOne () {}  
 
     async save () {
       return {}
     }
-  }
+  },
+  DeletedChat: class DeletedChat {
+    constructor (obj) {}
+
+    static findById () {}
+    static find () {}
+    static findOne () {}
+    static updateOne () {}  
+
+    async save () {
+      return {}
+    }
+  },
+  DeletedPost: class DeletedPost {
+    constructor (obj) {}
+
+    static findById () {}
+    static find () {}
+    static findOne () {}
+    static updateOne () {}  
+
+    async save () {
+      return {}
+    }
+  } 
 }
 
 const bch = {
@@ -202,7 +249,10 @@ const p2wdb = {
 const nostr = {
   post: async () => {return true },
   read: async () => { return true },
-  eventId2note: () => { return 'testNoteId' }
+  eventId2note: () => { return 'testNoteId' },
+  readGlobalFeed: async () => { return [] },
+  getFollowers: async () => { return [] },
+  privKeyToNpub: async () => { return 'fakeNpub' }
 }
 
 export default { ipfs, localdb, bch, wallet, p2wdb, bchjs, nostr}

test/unit/mocks/adapters/wallet.js

@@ -12,8 +12,18 @@ const mockWallet = {
     nextAddress: 1
 };
 
-class MockBchWallet {
+
+class AdapterRoute {
     constructor() {
+        this.sendTx = async () => {
+            return 'fakeTxid';
+        }
+    }
+}
+
+class MockBchWallet {
+    constructor(mnemonic, advancedOptions) {
+        this.advancedOptions = advancedOptions
         this.walletInfoPromise = true;
         this.walletInfo = mockWallet;
         this.initialize = async () => {}
@@ -24,6 +34,9 @@ class MockBchWallet {
         this.sendTokens = async () => {
             return 'fakeTxid';
         };
+        this.send = async () => {
+            return 'fakeTxid';
+        };
         this.utxoIsValid =async ()=>{}
         this.getUtxos = async () => { };
         this.getBalance = async () => { };
@@ -33,7 +46,16 @@ class MockBchWallet {
                     tokenTicker: 'TROUT'
                 }];
         };
+        this.getKeyPair = async () => {
+            return {
+                cashAddress: 'bitcoincash:qzl0d3gcqeypv4cy7gh8rgdszxa9vvm2acv7fqtd00',
+                wif: 'L5D2UAam8tvo3uii5kpgaGyjvVMimdrXu8nWGQSQjuuAix6ji1YQ',
+                hdIndex: 11
+            }
+        };
         this.optimize = async () => { };
+        this.cid2json = async () => {};
+        this.ar = new AdapterRoute()
         // Environment variable is used by wallet-balance.unit.js to force an error.
         if (process.env.NO_UTXO) {
             this.utxos = {};

test/unit/mocks/bch-token-sweep-mock.js

@@ -0,0 +1,27 @@
+class BchTokenSweepMock {
+    constructor(wif, privateKey, bchWallet, fee, cashAddress) {
+        this.wif = wif
+        this.privateKey = privateKey
+        this.bchWallet = bchWallet
+        this.fee = fee
+        this.cashAddress = cashAddress
+    }
+    populateObjectFromNetwork() {
+        return {
+            success: true,
+            txid: 'txid'
+        }
+    }
+    sweepTo() {
+        return {
+            success: true,
+            txid: 'txid'
+        }
+    }
+}
+
+export { BchTokenSweepMock }
+
+export default {
+  BchTokenSweepMock
+}

test/unit/mocks/social-media-mocks.js

@@ -0,0 +1,42 @@
+
+
+const messagesMock = [
+  {
+    content: JSON.stringify("I'm testing so hard!!!"),
+    id: '1',
+    tags: [['u', 'bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7477']],
+    npub: 'npub1234567890',
+    pubkey: '1234567890',
+  }
+]
+const smAccountsMock = [
+  {
+    npub: 'npub1234567890',
+    bchAddr: 'bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7477',
+    pubkey: '1234567890',
+    pfp: '',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    followerCnt: 0,
+    followingCnt: 0,
+    posts: 0,
+    likes: 0,
+    comments: 0,
+    reposts: 0
+  },
+  {
+    npub: 'npub1234567891',
+    bchAddr: 'bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478',
+    pubkey: '1234567891',
+    pfp: '',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    followerCnt: 0,
+    followingCnt: 0,
+    posts: 0,
+    likes: 0,
+    comments: 0,
+    reposts: 0
+  }
+]
+export default {  messagesMock, smAccountsMock }

test/unit/mocks/use-cases/index.js

@@ -50,6 +50,33 @@ class Offer {
   async loadOffers(){
     
   }
+  async listOffers() {
+    return []
+  }
+  async listNftOffers() {
+    return []
+  }
+  async listFungibleOffers() {
+    return []
+  }
+  async takeOffer() {
+    return []
+  }
+  async listOffersByAddress() {
+    return []
+  }
+  async flagOffer() {
+    return {}
+  }
+  async acceptCounterOffer() {
+    return {}
+  }
+  async syncOfferMutableData(){
+    return {}
+  }
+  async listCounterOffersByAddress() {
+    return []
+  }
 }
 
 class Order {
@@ -59,6 +86,12 @@ class Order {
   async removeStaleOrders(){
     return {}
   }
+  async listOrders() {
+    return []
+  }
+  async deleteOrder() {
+    return 'testTxid'
+  }
 }
 
 class UsageUseCaseMock {
@@ -87,6 +120,45 @@ class UsageUseCaseMock {
   }
 }
 
+class SmAccountUseCaseMock {
+  async listAccounts() {
+    return []
+  }
+  async getAccountByNpub() {
+    return {}
+  }
+  async getAccountByBchAddr() {
+    return {}
+  }
+  async checkForNewSmAccounts() {
+    return true
+  }
+  async updateSmAccounts() {
+    return true
+  }
+}
+
+class NostrUseCasesMock {
+  async createDeletedChat() {
+    return {}
+  }
+  async getDeletedChats() {
+    return []
+  }
+  async createDeletedPost() {
+    return {}
+  }
+  async getDeletedPosts() {
+    return []
+  }
+  async removeOlderDeletedChats() {
+    return true
+  }
+  async removeOlderDeletedPosts() {
+    return true
+  }
+}
+
 class UseCasesMock {
   constuctor(localConfig = {}) {
     // this.user = new UserUseCaseMock(localConfig)
@@ -97,6 +169,8 @@ class UseCasesMock {
   offer = new Offer()
   order = new Order()
   usage = new UsageUseCaseMock()
+  smAccount = new SmAccountUseCaseMock()
+  nostr = new NostrUseCasesMock()
 }
 
 export default UseCasesMock;

test/unit/mocks/use-cases/offer-mock-data.js

@@ -115,6 +115,7 @@ const fungibleTokenData01 = {
     "documentUri": "troutsblog.com",
     "documentHash": "",
     "decimals": 2,
+    "tokenDecimals": 2,
     "mintBatonIsActive": true,
     "tokensInCirculationBN": "100097954686",
     "tokensInCirculationStr": "100097954686",
@@ -125,6 +126,20 @@ const fungibleTokenData01 = {
   "immutableData": "troutsblog.com",
   "mutableData": ""
 }
+const mutableDataMock = {
+  schema: 'ps007-v1.0.3',
+  schemaDocs: 'https://github.com/Permissionless-Software-Foundation/specifications/blob/master/ps007-token-data-schema.md',
+  tokenIcon: 'https://files.tokentiger.com/ipfs/view/bafkreidr6wfd6mcmwpea7abm5uk5rrprc2wfbcvo5wdcmtlolrpjab5oqm',
+  fullSizedUrl: '',
+  nsfw: false,
+  userData: { currentUrl: 'https://tokentiger.com' },
+  jsonLd: {},
+  about: 'This is AI generated art.',
+  category: '',
+  tags: [],
+  mediaType: 'image',
+  currentOwner: {},
+}
 
 const offerMockData = {
   data: {
@@ -141,10 +156,38 @@ const offerMockData = {
     utxoVout: 0,
     makerAddr: 'address',
     tokenType: 1,
-    nostrEventId: 'test'
+    nostrEventId: 'test',
+    operatorAddress: 'bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478',
+    operatorPercentage: 10
   }
 }
 
+const deserealizeTxMockNoOperatorOut = {
+  //...
+  vout: [
+    {
+      value: 0,
+      scriptPubKey: {
+        addresses: ['bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478']
+      }
+    },
+    {
+      value: 0,
+      scriptPubKey: {
+        addresses: ['bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478']
+      }
+    },
+    {
+      value: 0,
+      scriptPubKey: {
+        addresses: ['bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478']
+      }
+    },
+    
+    //...
+  ]
+}
+
 const deserealizeTxMock = {
   //...
   vout: [
@@ -166,6 +209,12 @@ const deserealizeTxMock = {
         addresses: ['bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478']
       }
     },
+    {
+      value: 0,
+      scriptPubKey: {
+        addresses: ['bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478']
+      }
+    },
     //...
   ]
 }
@@ -178,5 +227,7 @@ export default {
   fungibleOffer01,
   fungibleTokenData01,
   offerMockData,
-  deserealizeTxMock
+  deserealizeTxMockNoOperatorOut,
+  deserealizeTxMock,
+  mutableDataMock
 };

test/unit/use-cases/nostr.use-case.unit.js

@@ -0,0 +1,287 @@
+/*
+  Unit tests for the Nostr Use Case library.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Unit under test (uut)
+import NostrUseCases from '../../../src/use-cases/nostr-use-cases.js'
+// Local support libraries
+import adapters from '../mocks/adapters/index.js'
+
+describe('#nostr-use-cases', () => {
+  let uut
+  let sandbox
+
+  before(async () => {
+    // Delete all previous users in the database.
+    // await testUtils.deleteAllUsers()
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+
+    uut = new NostrUseCases({ adapters })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new NostrUseCases()
+
+        assert.fail('Unexpected code path')
+        console.log(uut) // linter
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of adapters must be passed in when instantiating Nostr Use Cases library.'
+        )
+      }
+    })
+  })
+
+  describe('#createDeletedChat', () => {
+    it('should throw an error if no input is given', async () => {
+      try {
+        await uut.createDeletedChat()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        // assert.equal(err.status, 422)
+        assert.include(err.message, "Property 'eventId' must be a string!")
+      }
+    })
+
+    it('should throw an error if eventId is not provided', async () => {
+      try {
+        await uut.createDeletedChat({})
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, "Property 'eventId' must be a string!")
+      }
+    })
+
+    it('should catch and throw DB errors', async () => {
+      try {
+        // Force an error with the database.
+        sandbox.stub(uut, 'DeletedChatModel').throws(new Error('test error'))
+
+        const inObj = {
+          eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q'
+        }
+
+        await uut.createDeletedChat(inObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should create a new deleted chat model with minimum inputs', async () => {
+      const inObj = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q'
+      }
+
+      const res = await uut.createDeletedChat(inObj)
+
+      assert.isObject(res)
+    })
+    it('should create a new deleted chat model with maximum inputs', async () => {
+      const inObj = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+        npub: 'npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8',
+        bchAddr: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a',
+        pubkey: '6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1'
+      }
+
+      const res = await uut.createDeletedChat(inObj)
+
+      assert.isObject(res)
+    })
+  })
+
+  describe('#getDeletedChats', () => {
+    it('should return all deleted chats from the database', async () => {
+      sandbox.stub(uut.DeletedChatModel, 'find').resolves([])
+      const res = await uut.getDeletedChats()
+
+      assert.isArray(res)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error.
+        sandbox.stub(uut.DeletedChatModel, 'find').rejects(new Error('test error'))
+
+        await uut.getDeletedChats()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#createDeletedPost', () => {
+    it('should throw an error if no input is given', async () => {
+      try {
+        await uut.createDeletedPost()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, "Property 'eventId' must be a string!")
+      }
+    })
+
+    it('should throw an error if eventId is not provided', async () => {
+      try {
+        await uut.createDeletedPost({})
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, "Property 'eventId' must be a string!")
+      }
+    })
+
+    it('should catch and throw DB errors', async () => {
+      try {
+        // Force an error with the database.
+        sandbox.stub(uut, 'DeletedPostModel').throws(new Error('test error'))
+
+        const inObj = {
+          eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q'
+        }
+
+        await uut.createDeletedPost(inObj)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should create a new deleted post model with minimum inputs', async () => {
+      const inObj = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q'
+      }
+
+      const res = await uut.createDeletedPost(inObj)
+
+      assert.isObject(res)
+    })
+    it('should create a new deleted post model with maximum inputs', async () => {
+      const inObj = {
+        eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+        npub: 'npub1d4ed5x49d7p24xn63flj4985dc4gpfngdhtqcxpth0ywhm6czxcscfpcq8',
+        bchAddr: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a',
+        pubkey: '6d72da1aa56f82aa9a7a8a7f2a94f46e2a80a6686dd60c182bbbc8ebef5811b1'
+      }
+
+      const res = await uut.createDeletedPost(inObj)
+
+      assert.isObject(res)
+    })
+  })
+
+  describe('#getDeletedPosts', () => {
+    it('should return all deleted posts from the database', async () => {
+      sandbox.stub(uut.DeletedPostModel, 'find').resolves([])
+      const res = await uut.getDeletedPosts()
+
+      assert.isArray(res)
+    })
+  })
+
+  it('should catch and throw an error', async () => {
+    try {
+      // Force an error.
+      sandbox.stub(uut.DeletedPostModel, 'find').rejects(new Error('test error'))
+
+      await uut.getDeletedPosts()
+
+      assert.fail('Unexpected code path')
+    } catch (err) {
+      assert.include(err.message, 'test error')
+    }
+  })
+  describe('#removeOlderDeletedChats', () => {
+    it('should remove older deleted chats from the database', async () => {
+      const threeMonthsAgo = new Date()
+      threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3) // 3 months ago
+      threeMonthsAgo.setDate(threeMonthsAgo.getDate() - 1) // 1 day ago
+      const spy = sinon.spy()
+      const deletedChatsMock = [
+        // Newer deleted chat
+        {
+          eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+          createdAt: new Date(),
+          remove: spy
+        },
+        // Older deleted chat
+        {
+          eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+          createdAt: threeMonthsAgo,
+          remove: spy
+        }
+      ]
+      sandbox.stub(uut.DeletedChatModel, 'find').resolves(deletedChatsMock)
+      await uut.removeOlderDeletedChats()
+      assert.equal(spy.callCount, 1, 'Expected to be called once.')
+    })
+    it('should handle error', async () => {
+      try {
+        // Force an error.
+        sandbox.stub(uut.DeletedChatModel, 'find').throws(new Error('test error'))
+
+        await uut.removeOlderDeletedChats()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+  describe('#removeOlderDeletedPosts', () => {
+    it('should remove older deleted posts from the database', async () => {
+      const threeMonthsAgo = new Date()
+      threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3) // 3 months ago
+      threeMonthsAgo.setDate(threeMonthsAgo.getDate() - 1) // 1 day ago
+      const spy = sinon.spy()
+      const deletedPostsMock = [
+        // Newer deleted post
+        {
+          eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+          createdAt: new Date(),
+          remove: spy
+        },
+        // Older deleted post
+        {
+          eventId: 'note19e93faw4ffqepsqsrwrnstd3ee00nmzakwwuyfjm43dankgummfqms4p6q',
+          createdAt: threeMonthsAgo,
+          remove: spy
+        }
+      ]
+      sandbox.stub(uut.DeletedPostModel, 'find').resolves(deletedPostsMock)
+      await uut.removeOlderDeletedPosts()
+      assert.equal(spy.callCount, 1, 'Expected to be called once.')
+    })
+    it('should handle error', async () => {
+      try {
+        // Force an error.
+        sandbox.stub(uut.DeletedPostModel, 'find').throws(new Error('test error'))
+
+        await uut.removeOlderDeletedPosts()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+})

test/unit/use-cases/offer.use-case.unit.js

@@ -5,6 +5,7 @@
 // Public npm libraries
 import { assert } from 'chai'
 import sinon from 'sinon'
+import RetryQueue from '@chris.troutner/retry-queue'
 
 // Local support libraries
 // const testUtils = require('../../utils/test-utils')
@@ -30,6 +31,7 @@ describe('#offer-use-case', () => {
 
     const order = new OrderUseCase({ adapters })
     uut = new OfferLib({ adapters, order })
+    uut.retryQueue = new RetryQueue({ retryPeriod: 1000, attempts: 1 })
   })
 
   afterEach(() => sandbox.restore())
@@ -85,6 +87,15 @@ describe('#offer-use-case', () => {
       assert.isFalse(result)
     })
 
+    it('should return false if offer already processed', async () => {
+      const offerObj = mockData.offerMockData
+      uut.seenOffers.push(offerObj.data.nostrEventId)
+      // Mock dependencies
+
+      const result = await uut.createOffer(offerObj)
+      assert.isFalse(result)
+    })
+
     it('should return false for invalid utxo', async () => {
       const offerObj = mockData.offerMockData
 
@@ -97,6 +108,73 @@ describe('#offer-use-case', () => {
       assert.isFalse(result)
     })
 
+    it('should create offer with mutable data', async () => {
+      const tokenDataMock = mockData.nftTokenData01
+      const offerObj = mockData.offerMockData
+      const mutableDataMock = mockData.mutableDataMock
+
+      // Mock dependencies
+      // sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').resolves(false)
+      sandbox.stub(uut, 'findOfferByTxid').throws(new Error('offer not found'))
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves({}) // Utxo Status call
+        .onCall(1).resolves(tokenDataMock) // Token Data call
+        .onCall(2).resolves(mutableDataMock)
+
+      const result = await uut.createOffer(offerObj)
+      assert.isTrue(result)
+    })
+
+    it('should skip userData stringify error', async () => {
+      const tokenDataMock = mockData.nftTokenData01
+      const offerObj = mockData.offerMockData
+      const mutableDataMock = mockData.mutableDataMock
+      mutableDataMock.userData = { n: 10n }
+      // Mock dependencies
+      // sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').resolves(false)
+      sandbox.stub(uut, 'findOfferByTxid').throws(new Error('offer not found'))
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves({}) // Utxo Status call
+        .onCall(1).resolves(tokenDataMock) // Token Data call
+        .onCall(2).resolves(mutableDataMock)
+
+      const result = await uut.createOffer(offerObj)
+      assert.isTrue(result)
+    })
+
+    it('should handle error getting token data', async () => {
+      // const tokenDataMock = mockData.nftTokenData01
+      const offerObj = mockData.offerMockData
+      const mutableDataMock = mockData.mutableDataMock
+      mutableDataMock.userData = { n: 10n }
+      // Mock dependencies
+      // sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').resolves(false)
+      sandbox.stub(uut, 'findOfferByTxid').throws(new Error('offer not found'))
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves({}) // Utxo Status call
+        .onCall(1).throws(new Error('test error'))
+
+      const result = await uut.createOffer(offerObj)
+      assert.isTrue(result)
+    })
+
+    it('should handle error getting mutable data', async () => {
+      const tokenDataMock = mockData.nftTokenData01
+      const offerObj = mockData.offerMockData
+      const mutableDataMock = mockData.mutableDataMock
+      mutableDataMock.userData = { n: 10n }
+      // Mock dependencies
+      // sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').resolves(false)
+      sandbox.stub(uut, 'findOfferByTxid').throws(new Error('offer not found'))
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves({}) // Utxo Status call
+        .onCall(1).resolves(tokenDataMock) // Token Data call
+        .onCall(2).throws(new Error('test error')) // cid2json call
+
+      const result = await uut.createOffer(offerObj)
+      assert.isTrue(result)
+    })
+
     it('should create offer', async () => {
       const tokenDataMock = mockData.simpleNftTokenData01
       const offerObj = mockData.offerMockData
@@ -334,6 +412,14 @@ describe('#offer-use-case', () => {
       const result = await uut.detectNsfw({ mutableData: 'ipfs://bafybeibqnsmmh6bkf2wwextetki4tly65z4r4qkrrpl5xwgvzdzjley6wm' })
       assert.isFalse(result)
     })
+    it('should fetch alternative url', async () => {
+      // Mock dependencies and force desired code path.
+      sandbox.stub(uut.axios, 'get').onCall(0).throws(new Error())
+        .onCall(1).resolves({ data: { nsfw: true } })
+
+      const result = await uut.detectNsfw({ mutableData: 'ipfs://bafybeibqnsmmh6bkf2wwextetki4tly65z4r4qkrrpl5xwgvzdzjley6wm' })
+      assert.isTrue(result)
+    })
   })
 
   describe('#listOffers', () => {
@@ -381,7 +467,7 @@ describe('#offer-use-case', () => {
       }
     })
 
-    it('should list orders', async () => {
+    it('should list offers', async () => {
       const queryMock = {
         sort () {
           return this
@@ -395,7 +481,11 @@ describe('#offer-use-case', () => {
       sandbox.stub(uut.OfferModel, 'find').returns(queryMock)
 
       const result = await uut.listNftOffers(1, true)
-      assert.isArray(result)
+      assert.isObject(result)
+      assert.property(result, 'data')
+      assert.property(result, 'pagination')
+      assert.isArray(result.data)
+      assert.isObject(result.pagination)
     })
   })
 
@@ -597,7 +687,7 @@ describe('#offer-use-case', () => {
     })
   })
 
-  describe('#findOrderByEvent', () => {
+  describe('#findOfferByEvent', () => {
     it('should throw an error if hash is not provided', async () => {
       try {
         await uut.findOfferByEvent()
@@ -629,6 +719,29 @@ describe('#offer-use-case', () => {
     })
   })
 
+  describe('#listOffersByAddress', () => {
+    it('should throw an error if order is not found!', async () => {
+      try {
+        // Mock dependencies
+        sandbox.stub(uut.OfferModel, 'find').throws(new Error('test error'))
+
+        await uut.listOffersByAddress('eventId')
+
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should return offer by eventId', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.OfferModel, 'find').resolves([])
+
+      const result = await uut.listOffersByAddress()
+      assert.isArray(result)
+    })
+  })
+
   describe('#flagOffer', () => {
     it('should throw an error if input is not provided', async () => {
       try {
@@ -687,30 +800,122 @@ describe('#offer-use-case', () => {
 
     it('should skip internal function errors ', async () => {
       // Mock dependencies
-      sandbox.stub(uut.adapters.nostr, 'read').resolves([mockData.offerMockData])
+      const nostrReadMock = [{ content: JSON.stringify(mockData.offerMockData) }]
+      sandbox.stub(uut.adapters.nostr, 'read').resolves(nostrReadMock)
 
       await uut.loadOffers()
     })
-
-    it('should review and load offers', async () => {
+    it('should createOffer ', async () => {
+      mockData.offerMockData.data.dataType = 'offer'
       // Mock dependencies
-      sandbox.stub(uut.adapters.nostr, 'read').resolves([JSON.stringify(mockData.offerMockData)])
+      const nostrReadMock = [{ content: JSON.stringify(mockData.offerMockData) }]
+      sandbox.stub(uut.adapters.nostr, 'read').resolves(nostrReadMock)
+      const spy = sandbox.stub(uut, 'createOffer').resolves(true)
 
       await uut.loadOffers()
+      assert.isTrue(spy.calledOnce)
+    })
+    it('should accept counter Offer ', async () => {
+      mockData.offerMockData.data.dataType = 'counter-offer'
+      // Mock dependencies
+      const nostrReadMock = [{ content: JSON.stringify(mockData.offerMockData) }]
+      sandbox.stub(uut.adapters.nostr, 'read').resolves(nostrReadMock)
+      const spy = sandbox.stub(uut, 'acceptCounterOffer').resolves(true)
+
+      await uut.loadOffers()
+      assert.isTrue(spy.calledOnce)
+    })
+
+    it('should skip error inside loop', async () => {
+      // Mock dependencies
+      const nostrReadMock = [{ content: '' }]
+      sandbox.stub(uut.adapters.nostr, 'read').resolves(nostrReadMock)
+      await uut.loadOffers()
     })
   })
 
   describe('#acceptCounterOffer', () => {
+    it('should capture counter offer if does not exist', async () => {
+      const offerObj = mockData.offerMockData
+      sandbox.stub(uut.CounterOfferModel, 'findOne').resolves(null)
+      const spy = sandbox.stub(uut.CounterOfferModel.prototype, 'save')
+      // Mock dependencies
+
+      await uut.acceptCounterOffer(offerObj)
+      assert.isTrue(spy.calledOnce)
+    })
+    it('should not save counter offer if already exist', async () => {
+      const offerObj = mockData.offerMockData
+      sandbox.stub(uut.CounterOfferModel, 'findOne').resolves(offerObj.data)
+      const spy = sandbox.stub(uut.CounterOfferModel.prototype, 'save')
+      // Mock dependencies
+
+      await uut.acceptCounterOffer(offerObj)
+      assert.isFalse(spy.calledOnce)
+    })
+
+    it('should return false if order already processed', async () => {
+      const offerObj = mockData.offerMockData
+      uut.seenOffers.push(offerObj.data.nostrEventId)
+      // Mock dependencies
+
+      const result = await uut.acceptCounterOffer(offerObj)
+      assert.isFalse(result)
+    })
+
     it('should return if order is not found!', async () => {
       // Mock dependencies
-      sandbox.stub(uut.orderUseCase, 'findOrderByEvent').throws(new Error('test error'))
+      const offerObj = mockData.offerMockData
 
-      const result = await uut.acceptCounterOffer({ data: { /** .... */ } })
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').throws(new Error('test error'))
+
+      const result = await uut.acceptCounterOffer(offerObj)
+      assert.equal(result, 'N/A')
+    })
+
+    it('should return N/A on axios error', async () => {
+      // Mock dependencies
+      const offerObj = mockData.offerMockData
+
+      const mock = Object.assign({}, mockData.offerMockData.data)
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
+      // sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').throws(new Error('test error'))
+      const axiosErr = new Error('axios err')
+      axiosErr.isAxiosError = true
+      sandbox.stub(uut.retryQueue, 'addToQueue').throws(axiosErr)
+
+      const result = await uut.acceptCounterOffer(offerObj)
+      assert.equal(result, 'N/A')
+    })
+    it('should return if utxo can not be validated', async () => {
+      // Mock dependencies
+      const offerObj = mockData.offerMockData
+
+      const mock = Object.assign({}, mockData.offerMockData.data)
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
+      // sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').throws(new Error('test error'))
+      sandbox.stub(uut.retryQueue, 'addToQueue').throws(new Error('test error'))
+
+      const result = await uut.acceptCounterOffer(offerObj)
+      assert.equal(result, 'N/A')
+    })
+
+    it('should return if utxo is invalid', async () => {
+      // Mock dependencies
+      const offerObj = mockData.offerMockData
+
+      const mock = Object.assign({}, mockData.offerMockData.data)
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
+      sandbox.stub(uut.adapters.wallet.bchWallet, 'utxoIsValid').resolves(false)
+
+      const result = await uut.acceptCounterOffer(offerObj)
       assert.equal(result, 'N/A')
     })
 
     it('should handle error if counter offer cant be calculated', async () => {
       try {
+        const offerObj = mockData.offerMockData
+
         // Mock Data
         const mock = Object.assign({}, mockData.offerMockData.data)
         mock.rateInBaseUnit = null
@@ -719,8 +924,7 @@ describe('#offer-use-case', () => {
         sandbox.stub(uut.orderUseCase, 'findOrderByEvent').resolves(mock)
         sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
 
-        const result = await uut.acceptCounterOffer({ data: { /** .... */ } })
-        console.log('result: ', result)
+        await uut.acceptCounterOffer(offerObj)
         assert.fail('unexpected code path')
       } catch (err) {
         assert.include(err.message, 'Could not calculate the amount of BCH offered in the Counter Offer')
@@ -730,11 +934,11 @@ describe('#offer-use-case', () => {
     it('should handle error for wrong transaction output', async () => {
       try {
         // Mock Data
+
         const mock = Object.assign({}, mockData.offerMockData.data)
 
         // Mock dependencies
         sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
-        sandbox.stub(uut.orderUseCase, 'findOrderByEvent').resolves(mockData.offerMockData.data)
         sandbox.stub(uut.adapters.wallet.bchWallet.bchjs.BitcoinCash, 'toSatoshi').returns(0)
         sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMock)
 
@@ -746,6 +950,45 @@ describe('#offer-use-case', () => {
       }
     })
 
+    it('should skip transactions that do not have an output for the operator', async () => {
+      // Mock data
+
+      const mock = Object.assign({}, mockData.offerMockData.data)
+      mock.makerAddr = 'bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7477' // Unknow Adress
+      mock.rateInBaseUnit = 0
+      mock.numTokens = 0
+
+      // Mock dependencies
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
+      sandbox.stub(uut.adapters.wallet.bchWallet.bchjs.BitcoinCash, 'toSatoshi').returns(0)
+
+      sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMockNoOperatorOut)
+
+      const result = await uut.acceptCounterOffer({ data: mock })
+      assert.equal(result, 'N/A')
+    })
+    it('should skip transactions if operator address does not match', async () => {
+      try {
+        // Mock data
+        const mock = Object.assign({}, mockData.offerMockData.data)
+        mock.makerAddr = mockData.deserealizeTxMockNoOperatorOut.vout[2].scriptPubKey.addresses[0]
+        mock.operatorAddress = 'bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7477'
+        mock.rateInBaseUnit = 0
+        mock.numTokens = 0
+
+        // Mock dependencies
+        sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
+        sandbox.stub(uut.adapters.wallet.bchWallet.bchjs.BitcoinCash, 'toSatoshi').returns(0)
+
+        sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMock)
+
+        await uut.acceptCounterOffer({ data: mock })
+        assert.fail('unexpected code path')
+      } catch (error) {
+        assert.include(error.message, 'The Counter Offer has an output address of')
+      }
+    })
+
     it('should handle error for wrong transaction output address', async () => {
       try {
         // Mock data
@@ -761,7 +1004,7 @@ describe('#offer-use-case', () => {
 
         sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMock)
 
-        await uut.acceptCounterOffer({ data: { /** .... */ } })
+        await uut.acceptCounterOffer({ data: mock })
         assert.fail('unexpected code path')
       } catch (err) {
         assert.include(err.message, 'The Counter Offer has an output address of')
@@ -769,21 +1012,171 @@ describe('#offer-use-case', () => {
       }
     })
 
-    it('should return tx id', async () => {
+    it('should handle error if operator sats to receive cant be calculated', async () => {
       // Mock data
       const mock = Object.assign({}, mockData.offerMockData.data)
-      mock.makerAddr = mockData.deserealizeTxMock.vout[2].scriptPubKey.addresses[0] // Maker Address
+      mock.makerAddr = mockData.deserealizeTxMock.vout[2].scriptPubKey.addresses[0]
+      mock.operatorAddress = mockData.deserealizeTxMock.vout[3].scriptPubKey.addresses[0]
       mock.rateInBaseUnit = 0
       mock.numTokens = 0
 
       // Mock dependencies
       sandbox.stub(uut.orderUseCase, 'findOrderByEvent').resolves(mock)
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
       sandbox.stub(uut.adapters.wallet.bchWallet.bchjs.BitcoinCash, 'toSatoshi').returns(0)
+
+      sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMock)
+
+      const result = await uut.acceptCounterOffer({ data: mock })
+      assert.equal(result, 'N/A')
+    })
+
+    it('should return tx id', async () => {
+      // Mock data
+      const mock = Object.assign({}, mockData.offerMockData.data)
+      mock.makerAddr = mockData.deserealizeTxMock.vout[2].scriptPubKey.addresses[0]
+      mock.operatorAddress = mockData.deserealizeTxMock.vout[3].scriptPubKey.addresses[0]
+      mock.rateInBaseUnit = 0
+      mock.numTokens = 0
+
+      // Mock dependencies
+      sandbox.stub(uut.orderUseCase, 'findOrderByEvent').resolves(mock)
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').resolves(mock)
+      sandbox.stub(uut.adapters.wallet.bchWallet.bchjs.BitcoinCash, 'toSatoshi').onCall(0).returns(0).onCall(1).returns(1000)
+      sandbox.stub(uut.adapters.localdb.Users, 'findById').resolves({ mnemonic: 'test' })
       sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMock)
 
       //
-      const result = await uut.acceptCounterOffer({ data: { /** .... */ } })
+      const result = await uut.acceptCounterOffer({ data: mock })
       assert.isString(result)
+      assert.notEqual('N/A')
+    })
+  })
+
+  describe('#syncOfferMutableData', () => {
+    it('should throw error if tokenId is not provided!', async () => {
+      try {
+        await uut.syncOfferMutableData()
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'tokenId must be a string!')
+      }
+    })
+
+    it('should throw error if tokenId is not found!', async () => {
+      try {
+        // Mock dependencies
+        sandbox.stub(uut.OfferModel, 'findOne').resolves(null)
+
+        await uut.syncOfferMutableData('tokenId')
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Associated offer not found!')
+      }
+    })
+
+    it('should return current data if lastUpdatedTokenData is less than 5 minutes', async () => {
+      // Mock dependencies
+      const lastUpdatedTokenData = new Date().getTime()
+      const offerMock = Object.assign({}, mockData.offerMockData)
+      offerMock.lastUpdatedTokenData = lastUpdatedTokenData
+      // stub
+      sandbox.stub(uut.OfferModel, 'findOne').returns(offerMock)
+      const spy = sandbox.stub(uut.retryQueue, 'addToQueue').resolves(true)
+
+      const offer = await uut.syncOfferMutableData('tokenId')
+
+      assert.isObject(offer)
+      assert.isTrue(spy.notCalled, 'it should not call retryQueue functions.')
+    })
+
+    it('should sync offer', async () => {
+      // create a timestamp 6 minutes in the past
+
+      // Create offer mock
+      const offerMock = Object.assign({}, mockData.offerMockData)
+      offerMock.save = () => { }
+
+      // Stub functions
+      sandbox.stub(uut.OfferModel, 'findOne').returns(offerMock)
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves(mockData.simpleNftTokenData01) // Token Data call
+        .onCall(1).resolves(mockData.mutableDataMock)
+
+      const offer = await uut.syncOfferMutableData('tokenId')
+      assert.isObject(offer)
+      assert.isNumber(offer.lastUpdatedTokenData)
+    })
+
+    it('should skip userData stringify error', async () => {
+      // create mutable data mock
+      const mutableDataMock = mockData.mutableDataMock
+      mutableDataMock.userData = { n: 10n }
+
+      // create offer mock
+      const offerMock = Object.assign({}, mockData.offerMockData)
+      offerMock.save = () => { }
+
+      // Stub functions
+      sandbox.stub(uut.OfferModel, 'findOne').returns(offerMock)
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves(mockData.simpleNftTokenData01) // Token Data call
+        .onCall(1).resolves(mutableDataMock)
+
+      const offer = await uut.syncOfferMutableData('tokenId')
+
+      assert.isObject(offer)
+      assert.isNumber(offer.lastUpdatedTokenData)
+    })
+
+    it('should handle error getting token data', async () => {
+      // create offer mock
+      const offerMock = Object.assign({}, mockData.offerMockData)
+      offerMock.save = () => { }
+
+      // Stub functions
+      sandbox.stub(uut.OfferModel, 'findOne').returns(offerMock)
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).throws(new Error('tokendata error')) // Token Data call
+        .onCall(1).resolves(mockData.mutableDataMock)
+
+      const offer = await uut.syncOfferMutableData('tokenId')
+      assert.isObject(offer)
+    })
+
+    it('should handle error getting mutable data', async () => {
+      // create offer mock
+      const offerMock = Object.assign({}, mockData.offerMockData)
+      offerMock.save = () => { }
+
+      // Stub functions
+      sandbox.stub(uut.OfferModel, 'findOne').returns(offerMock)
+      sandbox.stub(uut.retryQueue, 'addToQueue')
+        .onCall(0).resolves(mockData.simpleNftTokenData01) // Token Data call
+        .onCall(1).throws(new Error('mutable data error'))
+
+      const offer = await uut.syncOfferMutableData('tokenId')
+      assert.isObject(offer)
+      assert.isNumber(offer.lastUpdatedTokenData)
+    })
+  })
+  describe('#listCounterOffersByAddress', () => {
+    it('should throw an error if takerAddr is not provided!', async () => {
+      try {
+        await uut.listCounterOffersByAddress()
+
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'takerAddr must be a string')
+      }
+    })
+
+    it('should return counter offers by address', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.CounterOfferModel, 'find').resolves([])
+
+      const result = await uut.listCounterOffersByAddress('bitcoincash:qzltx40ldxr53edchprppj5lpg4q7vl20usx25ga44')
+      assert.isArray(result)
     })
   })
 })

test/unit/use-cases/order.use-case.unit.js

@@ -158,6 +158,7 @@ describe('#order-use-case', () => {
 
   describe('#createOrder', () => {
     it('should create an order and return the hash', async () => {
+      uut.config.useFullStackCash = true
       const entryObj = {
         lokadId: 'SWP',
         messageType: 1,
@@ -185,6 +186,7 @@ describe('#order-use-case', () => {
       assert.property(result, 'eventId')
       assert.property(result, 'noteId')
     })
+
     it('should create an order with consumer-api', async () => {
       uut.config.useFullStackCash = false
       const entryObj = {
@@ -214,6 +216,7 @@ describe('#order-use-case', () => {
       assert.property(result, 'eventId')
       assert.property(result, 'noteId')
     })
+
     it('should throw error if user is not found', async () => {
       try {
         const entryObj = {
@@ -384,4 +387,55 @@ describe('#order-use-case', () => {
       assert.isString(result)
     })
   })
+
+  describe('#findOrderByUtxo', () => {
+    it('should throw an error if data is not provided', async () => {
+      try {
+        await uut.findOrderByUtxo({})
+      } catch (err) {
+        assert.include(err.message, 'Cannot read properties of undefined')
+      }
+    })
+    it('should throw an error if order is not found', async () => {
+      try {
+        sandbox.stub(uut.OrderModel, 'findOne').resolves(null)
+        const offerData = {
+          data: {
+            utxoTxid: 'utxoTxid',
+            utxoVout: 'utxoVout'
+          }
+        }
+        await uut.findOrderByUtxo(offerData)
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'order not found')
+      }
+    })
+    it('should throw an error if order event id is not found', async () => {
+      try {
+        sandbox.stub(uut.OrderModel, 'findOne').resolves({ nostrEventId: null })
+        const offerData = {
+          data: {
+            utxoTxid: 'utxoTxid',
+            utxoVout: 'utxoVout'
+          }
+        }
+        await uut.findOrderByUtxo(offerData)
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'order not found')
+      }
+    })
+    it('should return order by utxo', async () => {
+      sandbox.stub(uut.OrderModel, 'findOne').resolves({ toObject: () => { return {} }, nostrEventId: 'nostrEventId' })
+      const offerData = {
+        data: {
+          utxoTxid: 'utxoTxid',
+          utxoVout: 'utxoVout'
+        }
+      }
+      const result = await uut.findOrderByUtxo(offerData)
+      assert.isObject(result)
+    })
+  })
 })

test/unit/use-cases/sm-account.unit.js

@@ -0,0 +1,166 @@
+/*
+  Unit tests for the SM Account Use Case library.
+*/
+
+// Public npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+// Unit under test (uut)
+import SMAccountLib from '../../../src/use-cases/smAccount-use-cases.js'
+import SMMock from '../mocks/social-media-mocks.js'
+// Local support libraries
+import adapters from '../mocks/adapters/index.js'
+
+describe('#sm-account-use-case', () => {
+  let uut
+  let sandbox
+
+  before(async () => {
+    // Delete all previous users in the database.
+    // await testUtils.deleteAllUsers()
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+
+    uut = new SMAccountLib({ adapters })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new SMAccountLib()
+
+        assert.fail('Unexpected code path')
+        console.log(uut) // linter
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of adapters must be passed in when instantiating SM Account Use Cases library.'
+        )
+      }
+    })
+  })
+
+  describe('#checkForNewSmAccounts', () => {
+    it('check for new SM accounts', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.nostr, 'readGlobalFeed').resolves(SMMock.messagesMock)
+
+      const result = await uut.checkForNewSmAccounts()
+      assert.isTrue(result)
+    })
+    it('should skip existing SM accounts', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'findOne').resolves({ npub: SMMock.messagesMock[0].npub })
+      sandbox.stub(uut.adapters.nostr, 'readGlobalFeed').resolves(SMMock.messagesMock)
+
+      const result = await uut.checkForNewSmAccounts()
+      assert.isTrue(result)
+    })
+    it('should throw an error if the readGlobalFeed fails', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.nostr, 'readGlobalFeed').rejects(new Error('Failed to read global feed'))
+
+      try {
+        await uut.checkForNewSmAccounts()
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Failed to read global feed')
+      }
+    })
+  })
+  describe('#listAccounts', () => {
+    it('should return a list of SM accounts', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'find').callsFake(() => {
+        return {
+          skip: () => {
+            return {
+              limit: () => {
+                return SMMock.messagesMock
+              }
+            }
+          }
+        }
+      })
+
+      const result = await uut.listAccounts()
+      assert.isArray(result)
+    })
+    it('should throw an error if the find fails', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'find').throws(new Error('Failed to find SM accounts'))
+
+      try {
+        await uut.listAccounts()
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Failed to find SM accounts')
+      }
+    })
+  })
+  describe('#getAccountByNpub', () => {
+    it('should return a SM account by npub', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'findOne').resolves(SMMock.messagesMock[0])
+
+      const result = await uut.getAccountByNpub(SMMock.messagesMock[0].npub)
+      assert.isObject(result)
+    })
+    it('should catch error', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'findOne').throws(new Error('Failed to find SM account by npub'))
+
+      try {
+        await uut.getAccountByNpub(SMMock.messagesMock[0].npub)
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Failed to find SM account by npub')
+      }
+    })
+  })
+  describe('#getAccountByBchAddr', () => {
+    it('should return a SM account by bch addr', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'findOne').resolves(SMMock.messagesMock[0])
+
+      const result = await uut.getAccountByBchAddr('bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7477')
+      assert.isObject(result)
+    })
+    it('should catch error', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'findOne').throws(new Error('Failed to find SM account by bch addr'))
+
+      try {
+        await uut.getAccountByBchAddr('bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7477')
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Failed to find SM account by bch addr')
+      }
+    })
+  })
+  describe('#updateSmAccounts', () => {
+    it('should update the SM accounts', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'find').resolves(SMMock.smAccountsMock)
+
+      const result = await uut.updateSmAccounts()
+      assert.isTrue(result)
+    })
+    it('should catch error', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.localdb.SmAccount, 'find').throws(new Error('Failed to find SM accounts'))
+
+      try {
+        await uut.updateSmAccounts()
+        assert.fail('unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Failed to find SM accounts')
+      }
+    })
+  })
+})

util/users/dev/updateUser.js

@@ -0,0 +1,31 @@
+import mongoose from 'mongoose'
+import config from '../../../config/index.js'
+import User from '../../../src/adapters/localdb/models/users.js'
+
+async function getUsers () {
+  // Connect to the Mongo Database.
+  mongoose.Promise = global.Promise
+  mongoose.set('useCreateIndex', true) // Stop deprecation warning.
+  await mongoose.connect(
+    config.database,
+    { useNewUrlParser: true, useUnifiedTopology: true }
+  )
+
+  // Find the user by email.
+  const user = await User.findOne({
+    email: 'test@test.com'
+  }, '-password')
+  // console.log('user: ', user)
+
+  // Update the users password
+  user.password = 'test'
+
+  // Change the user to an admin
+  // user.type = 'admin'
+
+  // Save the changes to the database.
+  await user.save()
+
+  mongoose.connection.close()
+}
+getUsers()

util/users/production/updateUser.js

@@ -0,0 +1,32 @@
+import mongoose from 'mongoose'
+// import config from '../../config/index.js'
+import User from '../../src/adapters/localdb/models/users.js'
+
+const mongooseConnectStr = 'mongodb://172.17.0.1:5666/bch-swap-service-prod'
+
+async function getUsers () {
+  // Connect to the Mongo Database.
+  mongoose.Promise = global.Promise
+  mongoose.set('useCreateIndex', true) // Stop deprecation warning.
+  await mongoose.connect(
+    mongooseConnectStr,
+    { useNewUrlParser: true, useUnifiedTopology: true }
+  )
+
+  // Find the user by email.
+  const user = await User.findOne({
+    email: 'test@test.com'
+  }, '-password')
+
+  // Update the users password
+  // user.password = 'newpassword'
+
+  // Change the user to an admin
+  // user.type = 'admin'
+
+  // Save the changes to the database.
+  await user.save()
+
+  mongoose.connection.close()
+}
+getUsers()