helia-coord 1.1.3 → 1.2.0

package/config/global-config.js

@@ -0,0 +1,13 @@
+/*
+  Config file for storing global configuration settings.
+*/
+
+const config = {
+  DEFAULT_COORDINATION_ROOM: 'psf-ipfs-coordination-002',
+  BCH_COINJOIN_ROOM: 'bch-coinjoin-001',
+
+  // Time between retrying private messages to a peer.
+  TIME_BETWEEN_RETRIES: 5000
+}
+
+export default config

package/dev-docs/theory-of-operation.md

@@ -0,0 +1,33 @@
+# Theory of Operation
+
+This document provides a high-level overview of what the helia-coord library does.
+Helia-coord is middleware that controls a Helia IPFS node. It is used to form an on-the-fly, self-healing mesh network of other IPFS nodes. The nodes communicate over *pubsub channels*, and state is managed by *interval timers*.
+
+## Pubsub Channels
+
+A series of pubsub channels are opened between the IPFS nodes on the network.
+
+### Coordination Channel
+The coordination channel is a public, unencrypted channel that each node subscribes to. Every two minutes, a node will broadcast an 'announcement object', which contains information about the node and how to connect to it. This includes:
+
+- The nodes IPFS ID
+- Multiaddrs that can be used for other nodes to connect to it directly.
+- The nodes public encryption key so that other nodes can send it e2ee messages.
+- The nodes BCH and SLP addresses so that other nodes can send it payments and tokens.
+- Metadata that describes what services the node offers and what versions it runs.
+
+### CoinJoin Channel
+This channel is not fully developed. It's another public, unencrypted channel that will be used for nodes to coordinate a CoinJoin transaction for achieving financial privacy. This channel can be ignored for now.
+
+### This Nodes Private Channel
+A pubsub channel is created using the nodes IPFS ID. Other nodes on the network will subscribe to this channel in order to send it encrypted messages. This channel is only used for receiving messages. The node never broadcasts messages on this channel.
+
+The helia-coord library is consumed by higher-level software like [the pay-to-write database (P2WDB)](https://p2wdb.com), and different software comprising [the Cash Stack](https://cashstack.info). Once RPC commands received on this channel are decrypted, they are passed up to the consuming software via the `privateLog` object.
+
+There are some low-level messages that are not passed up to the consuming software. These are ACK (acknowledge) and metric commands. The metrics commands are primarily used to measure and track latency between nodes and Circuit Relays. The helia-coord library will adjust its connection to achieve the lowest latency connections to other nodes on the network.
+
+### Other Nodes Private Channel
+When a new node is discovered via its announcement on the *Coordination Channel*, the node will subscribe to that nodes private channel. The node will use this channel to send encrypted RPC commands to other nodes. This channel is only used for broadcasting. It is never used for receiving messages.
+
+## Interval Timers
+A series of interval timers are defined in the `lib/controllser/timer-controller.js` file. These timers are periodically triggered in order to maintain the nodes state. They renew broken connections to other nodes, track latency between the node and Circuit Relays that it knows about, and other operations. These time-based function calls are what allow the node to create the mesh network on-the-fly and the self-heal the network as nodes come online or drop off the network.

package/lib/adapters/bch-adapter.js

@@ -23,15 +23,6 @@ class BchAdapter {
   // derivation path of 245 if a 12 word mnemonic is provided.
   async generateBchId () {
     try {
-      // Generate a 12-word mnemonic, if one isn't provided.
-      // if (!this.mnemonic) {
-      //   this.mnemonic = this.bchjs.Mnemonic.generate(
-      //     128,
-      //     this.bchjs.Mnemonic.wordLists().english
-      //   )
-      // }
-      // console.log(`mnemonic: ${mnemonic}`)
-
       // root seed buffer
       const rootSeed = await this.bchjs.Mnemonic.toSeed(this.mnemonic)
 
@@ -64,15 +55,6 @@ class BchAdapter {
 
   async generatePrivateKey () {
     try {
-      // Generate a 12-word mnemonic, if one isn't provided.
-      // if (!this.mnemonic) {
-      //   this.mnemonic = this.bchjs.Mnemonic.generate(
-      //     128,
-      //     this.bchjs.Mnemonic.wordLists().english
-      //   )
-      // }
-      // console.log(`mnemonic: ${mnemonic}`)
-
       // root seed buffer
       const rootSeed = await this.bchjs.Mnemonic.toSeed(this.mnemonic)
 

package/lib/adapters/encryption-adapter.js

@@ -3,7 +3,7 @@
   for existing encryption libraries.
 */
 
-import BchEncrypt from 'bch-encrypt-lib/index.js'
+import BchEncrypt from 'bch-encrypt-lib'
 
 class EncryptionAdapter {
   constructor (localConfig = {}) {
@@ -24,8 +24,6 @@ class EncryptionAdapter {
     // Encapsulate dependencies
     this.bchjs = this.bch.bchjs // Copy of bch-js
     this.bchEncrypt = new BchEncrypt({ bchjs: this.bchjs })
-    // this.ipfs = encryptConfig.ipfs
-    // this.orbitdb = encryptConfig.orbitdb
   }
 
   // Decrypt incoming messages on the pubsub channel for this node.
@@ -52,10 +50,6 @@ class EncryptionAdapter {
       // Exit quietly if the issue is a 'Bad MAC'. This seems to be a startup
       // issue.
       if (err.message.includes('Bad MAC')) {
-        // throw new Error(
-        //   'Bad MAC. Could not decrypt message. Peer may have stale encryption data for this node.'
-        // )
-
         this.log.statusLog(
           2,
           `Bad MAC. Could not decrypt message. Peer ${sender} may have stale encryption data for this node.`
@@ -92,44 +86,6 @@ class EncryptionAdapter {
       throw err
     }
   }
-
-  // Send an e2e encrypted message to a peer.
-  // async sendEncryptedMsg (peer, msg) {
-  //   try {
-  //     // console.log('sendEncryptedMsg peer: ', peer)
-  //     // console.log('sendEncryptedMsg msg: ', msg)
-  //
-  //     // const channel = peer.ipfsId.toString()
-  //     const pubKey = peer.encryptPubKey
-  //     // const orbitdbId = peer.orbitdb
-  //
-  //     const msgBuf = Buffer.from(msg, 'utf8').toString('hex')
-  //     // console.log(`msgBuf: ${msgBuf}`)
-  //
-  //     const encryptedHexStr = await this.bchEncrypt.encryption.encryptFile(
-  //       pubKey,
-  //       msgBuf
-  //     )
-  //     console.log(`encryptedHexStr: ${encryptedHexStr}`)
-  //
-  //     // const msgBuf2 = Buffer.from(encryptedHexStr, 'hex')
-  //
-  //     // Publish the message to the pubsub channel.
-  //     // TODO: This will be deprecated in the future in favor of publishing to
-  //     // the peers OrbitDB.
-  //     // await this.ipfs.pubsub.publish(channel, msgBuf2)
-  //
-  //     // if (orbitdbId) {
-  //     //   console.log(
-  //     //     `Ready to send encrypted message to peer ${channel} on orbitdb ID ${orbitdbId}`
-  //     //   )
-  //     //   await this.orbitdb.sendToDb(channel, encryptedHexStr, orbitdbId)
-  //     // }
-  //   } catch (err) {
-  //     console.error('Error in sendEncryptedMsg()')
-  //     throw err
-  //   }
-  // }
 }
 
 // module.exports = EncryptionAdapter

package/lib/adapters/index.js

@@ -4,8 +4,6 @@
 */
 
 // Public npm libraries
-// const EventEmitter = require('events')
-// EventEmitter.defaultMaxListeners = 200
 
 // Local libraries
 import LogsAdapter from './logs-adapter.js'
@@ -15,8 +13,6 @@ import EncryptionAdapter from './encryption-adapter.js'
 import PubsubAdapter from './pubsub-adapter/index.js'
 import Gist from './gist.js'
 
-// const Gist = require('./gist')
-
 class Adapters {
   constructor (localConfig = {}) {
     // Dependency injection

package/lib/adapters/ipfs-adapter.js

@@ -3,10 +3,6 @@
   know specifics about the IPFS API.
 */
 
-// The amount of time to wait to connect to a peer, in milliseconds.
-// Increasing the time makes the network slower but more resilient to latency.
-// Decreasing the time makes the network faster, but more smaller and more fragile.
-// import bootstapNodes from '../../config/bootstrap-circuit-relays.js'
 import { multiaddr } from '@multiformats/multiaddr'
 
 const CONNECTION_TIMEOUT = 10000
@@ -27,6 +23,12 @@ class IpfsAdapter {
       )
     }
 
+    // Bind 'this' object to all subfunctions
+    this.start = this.start.bind(this)
+    this.connectToPeer = this.connectToPeer.bind(this)
+    this.disconnectFromPeer = this.disconnectFromPeer.bind(this)
+    this.getPeers = this.getPeers.bind(this)
+
     // 'embedded' node type used as default, will use embedded js-ipfs.
     // Alternative is 'external' which will use ipfs-http-client to control an
     // external IPFS node.
@@ -59,93 +61,12 @@ class IpfsAdapter {
       this.ipfs = await this.ipfs
 
       // Get ID information about this IPFS node.
-      // const id2 = await this.ipfs.id()
-      // this.state.ipfsPeerId = id2.id
-      // this.ipfsPeerId = id2.id
       this.ipfsPeerId = this.ipfs.libp2p.peerId.toString()
 
       // Get multiaddrs that can be used to connect to this node.
-      // const addrs = id2.addresses.map(elem => elem.toString())
       let addrs = this.ipfs.libp2p.getMultiaddrs()
       addrs = addrs.map(elem => elem.toString())
-      // this.state.ipfsMultiaddrs = addrs
       this.ipfsMultiaddrs = addrs
-
-      // Remove bootstrap nodes, as we have our own bootstrap nodes, and the
-      // the default ones can spam our nodes with a ton of bandwidth.
-      // await this.ipfs.config.set('Bootstrap', [
-      //   bootstapNodes.node[0].multiaddr,
-      //   bootstapNodes.node[1].multiaddr
-      // ])
-
-      // Settings specific to embedded js-ipfs.
-      // if (this.nodeType === 'embedded') {
-      //   // Also remove default Delegates, as they are the same as the default
-      //   // Bootstrap nodes.
-      //   await this.ipfs.config.set('Addresses.Delegates', [])
-      // }
-
-      // Settings specific to external go-ipfs node.
-      // if (this.nodeType === 'external') {
-      //   // Enable RelayClient
-      //   // https://github.com/ipfs/go-ipfs/blob/master/docs/config.md#swarmrelayclient
-      //   // https://github.com/ipfs/go-ipfs/releases/tag/v0.11.0
-      //   await this.ipfs.config.set('Swarm.RelayClient.Enabled', true)
-
-      //   // Enable hole punching for better p2p interaction.
-      //   // https://github.com/ipfs/go-ipfs/blob/master/docs/config.md#swarmenableholepunching
-      //   await this.ipfs.config.set('Swarm.EnableHolePunching', true)
-
-      //   // Enable websocket connections
-      //   await this.ipfs.config.set('Addresses.Swarm', [
-      //     `/ip4/0.0.0.0/tcp/${this.tcpPort}`,
-      //     `/ip6/::/tcp/${this.tcpPort}`,
-      //     // `/ip4/0.0.0.0/udp/${this.tcpPort}/quic`,
-      //     // `/ip6/::/udp/${this.tcpPort}/quic`,
-      //     `/ip4/0.0.0.0/tcp/${this.wsPort}`, // Websockets
-      //     `/ip6/::/tcp/${this.wsPort}`
-      //   ])
-
-      //   // Disable scanning of IP ranges. This is largely driven by Hetzner
-      //   await this.ipfs.config.set('Swarm.AddrFilters', [
-      //     '/ip4/10.0.0.0/ipcidr/8',
-      //     '/ip4/100.0.0.0/ipcidr/8',
-      //     '/ip4/169.254.0.0/ipcidr/16',
-      //     '/ip4/172.16.0.0/ipcidr/12',
-      //     '/ip4/192.0.0.0/ipcidr/24',
-      //     '/ip4/192.0.2.0/ipcidr/24',
-      //     '/ip4/192.168.0.0/ipcidr/16',
-      //     '/ip4/198.18.0.0/ipcidr/15',
-      //     '/ip4/198.51.100.0/ipcidr/24',
-      //     '/ip4/203.0.113.0/ipcidr/24',
-      //     '/ip4/240.0.0.0/ipcidr/4',
-      //     '/ip6/100::/ipcidr/64',
-      //     '/ip6/2001:2::/ipcidr/48',
-      //     '/ip6/2001:db8::/ipcidr/32',
-      //     '/ip6/fc00::/ipcidr/7',
-      //     '/ip6/fe80::/ipcidr/10'
-      //   ])
-
-      //   // go-ipfs v0.10.0
-      //   // await this.ipfs.config.set('Swarm.EnableRelayHop', true)
-      //   // await this.ipfs.config.set('Swarm.EnableAutoRelay', true)
-
-      // // Disable peer discovery
-      // // await this.ipfs.config.set('Routing.Type', 'none')
-      // }
-
-      // Disable preloading
-      // await this.ipfs.config.set('preload.enabled', false)
-
-      // Reduce the default number of peers thisNode connects to at one time.
-      // await this.ipfs.config.set('Swarm.ConnMgr', {
-      //   LowWater: 10,
-      //   HighWater: 30,
-      //   GracePeriod: '2s'
-      // })
-
-      // Reduce the storage size, as this node should not be retaining much data.
-      // await this.ipfs.config.set('Datastore.StorageMax', '2GB')
     } catch (err) {
       console.error('Error in ipfs-adapter.js/start()')
       throw err
@@ -154,43 +75,34 @@ class IpfsAdapter {
 
   // Attempts to connect to an IPFS peer, given its IPFS multiaddr.
   // Returns true if the connection succeeded. Otherwise returns false.
-  async connectToPeer (ipfsAddr) {
+  async connectToPeer (inObj = {}) {
     try {
+      // console.log('connectToPeer() inObj: ', inObj)
+
       // TODO: Throw error if ipfs ID is passed, instead of a multiaddr.
-      console.log('ipfsAddr: ', ipfsAddr)
+      // console.log('ipfsAddr: ', ipfsAddr)
+
+      const { multiaddr } = inObj
 
       // await this.ipfs.swarm.connect(ipfsAddr, { timeout: CONNECTION_TIMEOUT })
-      await this.ipfs.libp2p.dial(this.multiaddr(ipfsAddr))
+      await this.ipfs.libp2p.dial(this.multiaddr(multiaddr))
+      // console.log('connectToPeer() result: ', result)
 
-      this.log.statusLog(1, `Successfully connected to peer node ${ipfsAddr}`)
+      this.log.statusLog(1, `Successfully connected to peer node ${multiaddr}`)
 
-      return true
+      return {
+        success: true,
+        details: null
+      }
     } catch (err) {
       /* exit quietly */
-      console.warn(
-        `Error trying to connect to peer node ${ipfsAddr}: ${err.message}`
-      )
-
-      // if (this.debugLevel === 1) {
-      //   this.statusLog(
-      //     `status: Error trying to connect to peer node ${ipfsAddr}`
-      //   )
-      // } else if (this.debugLevel === 2) {
-      //   this.statusLog(
-      //     `status: Error trying to connect to peer node ${ipfsAddr}: `,
-      //     err
-      //   )
-      // }
-      this.log.statusLog(2, `Error trying to connect to peer node ${ipfsAddr}`)
-      // console.log(`Error trying to connect to peer node ${ipfsAddr}: `, err)
-
-      // this.log.statusLog(
-      //   3,
-      //   `Error trying to connect to peer node ${ipfsAddr}: `,
-      //   err
-      // )
+      // console.log('connectToPeer() Error connecting to peer: ', err)
+      this.log.statusLog(2, 'Error trying to connect to peer node : ', err.message)
 
-      return false
+      return {
+        success: false,
+        details: err.message
+      }
     }
   }
 
@@ -241,16 +153,9 @@ class IpfsAdapter {
     try {
       // console.log('this.ipfs.libp2p: ', this.ipfs.libp2p)
 
-      // Get connected peers
-      // const connectedPeers = await this.ipfs.swarm.peers({
-      //   direction: true,
-      //   streams: true,
-      //   verbose: true,
-      //   latency: true
-      // })
       let connectedPeers = await this.ipfs.libp2p.getPeers()
       connectedPeers = connectedPeers.map(x => x.toString())
-      console.log('connectedPeers: ', connectedPeers)
+      this.log.statusLog(1, 'connectedPeers: ', connectedPeers)
 
       return connectedPeers
     } catch (err) {
@@ -260,5 +165,4 @@ class IpfsAdapter {
   }
 }
 
-// module.exports = IpfsAdapter
 export default IpfsAdapter

package/lib/adapters/pubsub-adapter/index.js

@@ -9,7 +9,6 @@ import { BroadcastRouter, PrivateChannelRouter } from './msg-router.js'
 
 // Libraries for working with default uint8Array Buffers that pubsub uses
 // for sending and receiving messages.
-// import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 
 class PubsubAdapter {
@@ -45,19 +44,20 @@ class PubsubAdapter {
     this.messaging = new Messaging(localConfig)
     this.about = new AboutAdapter(localConfig)
 
-    // 'embedded' node type used as default, will use embedded js-ipfs.
-    // Alternative is 'external' which will use ipfs-http-client to control an
-    // external IPFS node.
     this.nodeType = localConfig.nodeType
     if (!this.nodeType) {
-      // console.log('No node type specified. Assuming embedded js-ipfs.')
-      this.nodeType = 'embedded'
+      this.nodeType = 'node.js'
     }
-    // console.log(`PubsubAdapter contructor node type: ${this.nodeType}`)
 
     // Bind functions that are called by event handlers
     this.parsePubsubMessage = this.parsePubsubMessage.bind(this)
     this.handleNewMessage = this.handleNewMessage.bind(this)
+    this.checkForDuplicateMsg = this.checkForDuplicateMsg.bind(this)
+    this.manageMsgCache = this.manageMsgCache.bind(this)
+
+    // State
+    this.trackedMsgs = [] // Used reject repeated messages
+    this.TRACKED_MSG_SIZE = 100
   }
 
   // Subscribe to a pubsub channel. Any data received on that channel is passed
@@ -71,11 +71,6 @@ class PubsubAdapter {
       // for this node. This applies to general broadcast channels like
       // the coordination channel that all nodes use to annouce themselves.
       if (chanName !== thisNodeId) {
-        // console.log('this.ipfs: ', this.ipfs)
-        // await this.ipfs.ipfs.pubsub.subscribe(chanName.toString(), async (msg) => {
-        //   await this.parsePubsubMessage(msg, handler, thisNode)
-        // })
-
         // Instantiate the Broadcast message router library
         const bRouterOptions = {
           handler,
@@ -105,19 +100,10 @@ class PubsubAdapter {
 
         // Subscribe to the pubsbu channel. Route any incoming messages to the
         // this library.
-        // await this.ipfs.ipfs.pubsub.subscribe(chanName.toString(), privateRouter.route)
         this.ipfs.ipfs.libp2p.services.pubsub.subscribe(chanName.toString())
 
         // Route incoming message events.
         this.ipfs.ipfs.libp2p.services.pubsub.addEventListener('message', privateRouter.route)
-
-        // await this.ipfs.ipfs.pubsub.subscribe(chanName.toString(), async (msg) => {
-        //   const msgObj = await this.messaging.handleIncomingData(msg, thisNode)
-        //
-        //   // If msgObj is false, then ignore it. Typically indicates an already
-        //   // processed message.
-        //   if (msgObj) { await this.handleNewMessage(msgObj, thisNode) }
-        // })
       }
 
       this.log.statusLog(
@@ -150,7 +136,6 @@ class PubsubAdapter {
       // Pass the JSON RPC data to the private log to be handled by the app
       // consuming this library.
       if (!isAbout) {
-        // console.log('handleNewMessage() forwarding payload on to handler.')
         this.privateLog(msgObj.data.payload, msgObj.from)
 
         return true
@@ -172,16 +157,11 @@ class PubsubAdapter {
       // console.log('thisNode: ', thisNode)
 
       const data = JSON.parse(decryptedStr)
-      // console.log('data: ', data)
 
       // Handle /about JSON RPC queries.
       if (data.id.includes('metrics') && data.method === 'about') {
         // Request recieved, send response.
 
-        // console.log('/about JSON RPC captured. Sending back announce object.')
-
-        // console.log('thisNode.schema.state.announceJsonLd: ', thisNode.schema.state.announceJsonLd)
-
         const jsonResponse = `{"jsonrpc": "2.0", "id": "${data.id}", "result": {"method": "about", "receiver": "${from}", "value": ${JSON.stringify(thisNode.schema.state)}}}`
         // console.log(`Responding with this JSON RPC response: ${jsonResponse}`)
 
@@ -200,8 +180,6 @@ class PubsubAdapter {
       } else if (data.id.includes('metrics') && data.result && data.result.method === 'about') {
         // Response received.
 
-        // console.log('JSON RPC /about response aquired.')
-
         // This event is handled by the about-adapter.js. It measures the
         // latency between peers.
         this.about.relayMetricsReceived(decryptedStr)
@@ -221,19 +199,13 @@ class PubsubAdapter {
   // Attempts to parse data coming in from a pubsub channel. It is assumed that
   // the data is a string in JSON format. If it isn't, parsing will throw an
   // error and the message will be ignored.
-  async parsePubsubMessage (msg, handler, thisNode) {
+  async parsePubsubMessage (inObj = {}) {
     try {
-      // console.log('message data: ', msg.data)
-      // console.log('parsePubsubMessage msg: ', msg)
-      // console.log('thisNode: ', thisNode)
+      const { msg, handler, thisNode } = inObj
 
-      // let parsedData = uint8ArrayToString(msg.detail.data)
-      // parsedData = JSON.parse(JSON.parse(parsedData))
-      // console.log('parsedData: ', parsedData)
-      // console.log('typeof parsedData: ', typeof parsedData)
-      // console.log('msg.detail.data: ', JSON.stringify(parsedData, null, 2))
-      // console.log('msg.detail.topic: ', msg.detail.topic)
-      // console.log('msg.detail.from: ', msg.detail.from.toString())
+      // Skip any repeated messages
+      const shouldProcess = this.checkForDuplicateMsg(msg)
+      if (!shouldProcess) return false
 
       const thisNodeId = thisNode.ipfsId
 
@@ -250,16 +222,6 @@ class PubsubAdapter {
       // Ignore this message if it originated from this IPFS node.
       if (from === thisNodeId) return true
 
-      // The data on browsers comes through as a uint8array, and on node.js
-      // implementiong it comes through as a string. Browsers need to
-      // convert the message from a uint8array to a string.
-      // console.log('this.nodeType: ', this.nodeType)
-      // if (thisNode.type === 'browser' || this.nodeType === 'external') {
-      //   // console.log('Node type is browser or external')
-      //   msg.data = new TextDecoder('utf-8').decode(msg.data)
-      // }
-      // console.log('msg.data: ', JSON.parse(msg.data.toString()))
-
       let data
       try {
         // Parse the data into a JSON object. It starts as a Buffer that needs
@@ -269,38 +231,65 @@ class PubsubAdapter {
 
         data = uint8ArrayToString(msg.detail.data)
         data = JSON.parse(JSON.parse(data))
-        // console.log('data: ', data)
+        // console.log('parsePubsubMessage() 1 data: ', data)
 
-        // if(data.data) {
-        //   data.data = JSON.parse(data.data)
-        // }
-        // console.log('parsePubsubMessage() data: ', data)
+        // console.log('pubsub-adapter/index.js parsePubsubMessage() collect test data: ', msg.detail.data.toString('hex'))
       } catch (err) {
-        try {
-          data = uint8ArrayToString(msg.detail.data)
-          data = JSON.parse(data)
-          // console.log('parsePubsubMessage() data: ', data)
-        } catch (err) {
-          console.log('pubsub-adapter/index.js parsePubsubMessage() collect test data: ', msg.detail.data.toString('hex'))
-          throw new Error(`Failed to parse JSON in message from ${from} in pubsub channel ${channel}.`)
-        }
+        this.log.statusLog(
+          1,
+          `Failed to parse JSON in message from ${from} in pubsub channel ${channel}.`
+        )
+
+        return false
       }
 
       const retObj = { from, channel, data }
       // console.log(`new pubsub message received: ${JSON.stringify(retObj, null, 2)}`)
 
       // Hand retObj to the callback.
-      handler(retObj)
+      await handler(retObj)
 
       return true
     } catch (err) {
-      // console.error('Error in parsePubsubMessage(): ', err.message)
+      console.error('Error in parsePubsubMessage(): ', err.message)
       this.log.statusLog(2, `Error in parsePubsubMessage(): ${err.message}`)
       // Do not throw an error. This is a top-level function.
 
       return false
     }
   }
+
+  // Checks to see if a message has already been processed. This protects against
+  // redundent processing.
+  checkForDuplicateMsg (msg) {
+    const sn = msg.detail.sequenceNumber
+    // console.log('sn: ', sn)
+
+    const snExists = this.trackedMsgs.find((x) => x === sn)
+    // console.log('snExists: ', snExists)
+
+    // Maintain the tracked message cache.
+    this.manageMsgCache()
+
+    if (snExists) {
+      // console.log(`msg ${sn} already processed. Rejecting.`)
+      return false
+    }
+
+    // Add the sn to the array of tracked messages.
+    this.trackedMsgs.push(sn)
+
+    return true
+  }
+
+  // Keep the message queue to a resonable size.
+  manageMsgCache () {
+    // console.log(`trackedMsgs: `, this.trackedMsgs)
+
+    if (this.trackedMsgs.length > this.TRACKED_MSG_SIZE) {
+      this.trackedMsgs.shift()
+    }
+  }
 }
 
 // module.exports = PubsubAdapter