Whitelist positive score peer to accept messages

Author: twoeths

test/accept-from.spec.js

@@ -0,0 +1,79 @@
+const {expect} = require('chai')
+const sinon = require('sinon')
+const {PeerScore} = require('../src/score')
+const Gossipsub = require('../src')
+const {
+  createPeer,
+} = require('./utils')
+
+describe('Gossipsub acceptFrom', () => {
+  let gossipsub
+  const sandbox = sinon.createSandbox()
+  let scoreStub
+
+  beforeEach(async () => {
+    sandbox.useFakeTimers()
+    gossipsub = new Gossipsub(await createPeer({ started: false }), { emitSelf: true })
+    scoreStub = sandbox.createStubInstance(PeerScore)
+    gossipsub.score = scoreStub
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  it('should only white list peer with positive score', () => {
+    scoreStub.score.withArgs("peerA").returns(1000)
+    gossipsub._acceptFrom("peerA")
+    // 1st time, we have to compute score
+    expect(scoreStub.score.withArgs("peerA").calledOnce).to.be.true
+    // 2nd time, use a cached score since it's white listed
+    gossipsub._acceptFrom("peerA")
+    expect(scoreStub.score.withArgs("peerA").calledOnce).to.be.true
+  })
+
+  it('should recompute score after 1s', () => {
+    scoreStub.score.returns(1000)
+    gossipsub._acceptFrom("peerA")
+    // 1st time, we have to compute score
+    expect(scoreStub.score.withArgs("peerA").calledOnce).to.be.true
+    gossipsub._acceptFrom("peerA")
+    expect(scoreStub.score.withArgs("peerA").calledOnce).to.be.true
+
+    // after 1s
+    sandbox.clock.tick(1001)
+
+    gossipsub._acceptFrom("peerA")
+    expect(scoreStub.score.withArgs("peerA").calledTwice).to.be.true
+  })
+
+  it('should recompute score after max messages accepted', () => {
+    scoreStub.score.returns(1000)
+    gossipsub._acceptFrom("peerA")
+    // 1st time, we have to compute score
+    expect(scoreStub.score.withArgs("peerA").calledOnce).to.be.true
+
+    for (let i = 0; i < 128; i++) {
+      gossipsub._acceptFrom("peerA")
+    }
+    expect(scoreStub.score.withArgs("peerA").calledOnce).to.be.true
+
+    // max messages reached
+    gossipsub._acceptFrom("peerA")
+    expect(scoreStub.score.withArgs("peerA").calledTwice).to.be.true
+  })
+
+  it('should NOT white list peer with negative score', () => {
+    // peerB is not white listed since score is negative
+    scoreStub.score.withArgs("peerB").returns(-1)
+    gossipsub._acceptFrom("peerB")
+    // 1st time, we have to compute score
+    expect(scoreStub.score.withArgs("peerB").calledOnce).to.be.true
+    // 2nd time, still have to compute score since it's NOT white listed
+    gossipsub._acceptFrom("peerB")
+    expect(scoreStub.score.withArgs("peerB").calledTwice).to.be.true
+  })
+
+
+
+})

ts/index.ts

@@ -84,10 +84,22 @@ interface GossipOptions extends GossipInputOptions {
   scoreThresholds: PeerScoreThresholds
 }
 
+const ACCEPT_REQUEST_WHITE_LIST_THRESHOLD_SCORE = 0
+const ACCEPT_REQUEST_WHITE_LIST_MAX_MESSAGES = 128
+const ACCEPT_REQUEST_WHITE_LIST_DURATION_MS = 1000
+
+interface AcceptRequestWhiteListEntry {
+  /** max number of messages accepted after a score is calculated */
+  messagesAccepted: number
+  /** have to recompute score after this time */
+  whitelistedTill: number
+}
+
 class Gossipsub extends Pubsub {
   peers: Map<string, PeerStreams>
   direct: Set<string>
   seenCache: SimpleTimeCache
+  acceptRequestsWhitelist: Map<string, AcceptRequestWhiteListEntry>
   topics: Map<string, Set<string>>
   mesh: Map<string, Set<string>>
   fanout: Map<string, Set<string>>
@@ -182,6 +194,13 @@ class Gossipsub extends Pubsub {
      */
     this.direct = new Set(opts.directPeers.map(p => p.id.toB58String()))
 
+    /**
+     * Map of peer id and AcceptRequestWhileListEntry
+     *
+     * @type {Map<string, AcceptRequestWhiteListEntry}
+     */
+    this.acceptRequestsWhitelist = new Map()
+
     // set direct peer addresses in the address book
     opts.directPeers.forEach(p => {
       libp2p.peerStore.addressBook.add(p.id, p.addrs)
@@ -449,7 +468,33 @@ class Gossipsub extends Pubsub {
    * @returns {boolean}
    */
   _acceptFrom (id: string): boolean {
-    return this.direct.has(id) || this.score.score(id) >= this._options.scoreThresholds.graylistThreshold
+    if (this.direct.has(id)) {
+      return true
+    }
+
+    const now = Date.now()
+    const entry = this.acceptRequestsWhitelist.get(id)
+
+    if (entry &&
+      entry.messagesAccepted < ACCEPT_REQUEST_WHITE_LIST_MAX_MESSAGES &&
+      entry.whitelistedTill >= now) {
+      entry.messagesAccepted += 1
+      return true
+    }
+
+    const score = this.score.score(id)
+    if (score >= ACCEPT_REQUEST_WHITE_LIST_THRESHOLD_SCORE) {
+      // peer is unlikely to be able to drop its score to `graylistThreshold`
+      // after 128 messages or 1s
+      this.acceptRequestsWhitelist.set(id, {
+        messagesAccepted: 0,
+        whitelistedTill: now + ACCEPT_REQUEST_WHITE_LIST_DURATION_MS
+      })
+    } else {
+      this.acceptRequestsWhitelist.delete(id)
+    }
+
+    return score >= this._options.scoreThresholds.graylistThreshold
   }
 
   /**