Merge pull request #113 from Permissionless-Software-Foundation/dh-user-data

feat(userdata): Store user data on the database

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.

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/localdb/models/offer.js

@@ -39,7 +39,16 @@ const Offer = new mongoose.Schema({
 
   // Operator fee and address
   operatorAddress: { type: String },
-  operatorPercentage: { type: Number }
+  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/wallet.js

@@ -56,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.
@@ -677,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/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/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/offer/controller.js

@@ -38,6 +38,7 @@ class OfferRESTControllerLib {
   }
 
   // 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 +57,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 +132,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 +207,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 +281,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 +319,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) {

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

@@ -105,6 +105,7 @@ class TimerControllers {
       console.error('Error in time-controller.js/cleanUsage(): ', err)
 
       this.cleanUsageHandle = setInterval(this.cleanUsage, this.cleanUsageInterval)
+      return false
     }
   }
 

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/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/offer/index.js

@@ -129,20 +129,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)
@@ -150,7 +187,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
     }
   }
@@ -267,7 +304,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' },
@@ -287,6 +324,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) {
@@ -598,7 +671,9 @@ 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.`)
       }
@@ -615,25 +690,25 @@ class OfferUseCases {
 
       // 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 operatorSatsToReceive = Math.ceil(orderData.numTokens * parseInt(orderData.rateInBaseUnit))
-      if (isNaN(operatorSatsToReceive)) {
-        throw new Error('Could not calculate the amount of BCH offered in the Counter Offer')
-      }
       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

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/unit/adapters/wallet.unit.js

@@ -493,4 +493,35 @@ describe('#wallet', () => {
       }
     })
   })
+  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/controllers/rest-api/offer/offer.rest.controller.unit.js

@@ -91,25 +91,143 @@ 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('#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,37 @@ 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)
+    })
+  })
 })

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,124 @@ 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 validate a new offer', () => {
       const offerObj = {
         appId: 'swapTest555',

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,6 +149,18 @@ const localdb = {
     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 {}
@@ -202,7 +214,9 @@ const p2wdb = {
 const nostr = {
   post: async () => {return true },
   read: async () => { return true },
-  eventId2note: () => { return 'testNoteId' }
+  eventId2note: () => { return 'testNoteId' },
+  readGlobalFeed: async () => { return [] },
+  getFollowers: async () => { return [] }
 }
 
 export default { ipfs, localdb, bch, wallet, p2wdb, bchjs, nostr}

test/unit/mocks/adapters/wallet.js

@@ -54,6 +54,7 @@ class MockBchWallet {
             }
         };
         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) {

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,27 @@ 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 {}
+  }
 }
 
 class Order {
@@ -59,6 +80,12 @@ class Order {
   async removeStaleOrders(){
     return {}
   }
+  async listOrders() {
+    return []
+  }
+  async deleteOrder() {
+    return 'testTxid'
+  }
 }
 
 class UsageUseCaseMock {
@@ -87,6 +114,24 @@ class UsageUseCaseMock {
   }
 }
 
+class SmAccountUseCaseMock {
+  async listAccounts() {
+    return []
+  }
+  async getAccountByNpub() {
+    return {}
+  }
+  async getAccountByBchAddr() {
+    return {}
+  }
+  async checkForNewSmAccounts() {
+    return true
+  }
+  async updateSmAccounts() {
+    return true
+  }
+}
+
 class UseCasesMock {
   constuctor(localConfig = {}) {
     // this.user = new UserUseCaseMock(localConfig)
@@ -97,6 +142,7 @@ class UseCasesMock {
   offer = new Offer()
   order = new Order()
   usage = new UsageUseCaseMock()
+  smAccount = new SmAccountUseCaseMock()
 }
 
 export default UseCasesMock;

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

@@ -126,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: {
@@ -169,6 +183,7 @@ const deserealizeTxMockNoOperatorOut = {
         addresses: ['bitcoincash:qzy97glp47ut7tstm5g0tlrmkhk742795gkmyc7478']
       }
     },
+    
     //...
   ]
 }
@@ -213,5 +228,6 @@ export default {
   fungibleTokenData01,
   offerMockData,
   deserealizeTxMockNoOperatorOut,
-  deserealizeTxMock
+  deserealizeTxMock,
+  mutableDataMock
 };

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,23 +800,74 @@ 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 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'))
+      sandbox.stub(uut.orderUseCase, 'findOrderByUtxo').throws(new Error('test error'))
+
+      const result = await uut.acceptCounterOffer({ data: { /** .... */ } })
+      assert.equal(result, 'N/A')
+    })
+
+    it('should return if utxo can not be validated', async () => {
+      // Mock dependencies
+      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({ data: { /** .... */ } })
+      assert.equal(result, 'N/A')
+    })
+
+    it('should return if utxo is invalid', async () => {
+      // Mock dependencies
+      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({ data: { /** .... */ } })
       assert.equal(result, 'N/A')
@@ -719,7 +883,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: { /** .... */ } })
+        const result = await uut.acceptCounterOffer({ data: {} })
         console.log('result: ', result)
         assert.fail('unexpected code path')
       } catch (err) {
@@ -734,7 +898,6 @@ describe('#offer-use-case', () => {
 
         // 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)
 
@@ -754,7 +917,6 @@ describe('#offer-use-case', () => {
       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)
 
@@ -763,6 +925,27 @@ describe('#offer-use-case', () => {
       const result = await uut.acceptCounterOffer({ data: { /** .... */ } })
       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: {} })
+        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 {
@@ -779,7 +962,7 @@ describe('#offer-use-case', () => {
 
         sandbox.stub(uut.adapters.wallet, 'deseralizeTx').resolves(mockData.deserealizeTxMock)
 
-        await uut.acceptCounterOffer({ data: { /** .... */ } })
+        await uut.acceptCounterOffer({ data: {} })
         assert.fail('unexpected code path')
       } catch (err) {
         assert.include(err.message, 'The Counter Offer has an output address of')
@@ -787,21 +970,44 @@ 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: {} })
+      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: {} })
       assert.isString(result)
+      assert.notEqual('N/A')
     })
   })
 })

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,
@@ -386,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')
+      }
+    })
+  })
+})