fix: update deps to new versions (#363)

Author: achingbrain

package.json

@@ -140,7 +140,7 @@
     "@libp2p/components": "^2.0.0",
     "@libp2p/crypto": "^1.0.0",
     "@libp2p/interface-address-manager": "^1.0.1",
-    "@libp2p/interface-connection": "^2.0.0",
+    "@libp2p/interface-connection": "^3.0.1",
     "@libp2p/interface-connection-manager": "^1.0.0",
     "@libp2p/interface-dht": "^1.0.0",
     "@libp2p/interface-peer-discovery": "^1.0.0",
@@ -176,14 +176,14 @@
     "p-defer": "^4.0.0",
     "p-queue": "^7.2.0",
     "private-ip": "^2.3.3",
-    "protons-runtime": "^2.0.2",
+    "protons-runtime": "^3.0.1",
     "timeout-abort-controller": "^3.0.0",
     "uint8arraylist": "^2.0.0",
     "uint8arrays": "^3.0.0",
     "varint": "^6.0.0"
   },
   "devDependencies": {
-    "@libp2p/interface-mocks": "^3.0.1",
+    "@libp2p/interface-mocks": "^4.0.1",
     "@libp2p/peer-id-factory": "^1.0.9",
     "@libp2p/peer-store": "^3.0.0",
     "@types/lodash.random": "^3.2.6",
@@ -200,7 +200,7 @@
     "lodash.random": "^3.2.0",
     "lodash.range": "^3.2.0",
     "p-retry": "^5.0.0",
-    "protons": "^4.0.1",
+    "protons": "^5.0.0",
     "sinon": "^14.0.0",
     "ts-sinon": "^2.0.2",
     "which": "^2.0.2"

src/content-fetching/index.ts

@@ -106,7 +106,7 @@ export class ContentFetching implements Initializable {
         try {
           const dsKey = bufferToRecordKey(key)
           this.log(`Storing corrected record for key ${dsKey.toString()}`)
-          await this.components.getDatastore().put(dsKey, fixupRec)
+          await this.components.getDatastore().put(dsKey, fixupRec.subarray())
         } catch (err: any) {
           this.log.error('Failed error correcting self', err)
         }
@@ -147,7 +147,7 @@ export class ContentFetching implements Initializable {
     // store the record locally
     const dsKey = bufferToRecordKey(key)
     this.log(`storing record for key ${dsKey.toString()}`)
-    await this.components.getDatastore().put(dsKey, record)
+    await this.components.getDatastore().put(dsKey, record.subarray())
 
     // put record to the closest peers
     yield * pipe(

src/message/dht.ts

@@ -1,9 +1,9 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { encodeMessage, decodeMessage, message, bytes, string, enumeration, int32 } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
+import type { Codec } from 'protons-runtime'
 
 export interface Record {
   key?: Uint8Array
@@ -14,17 +14,81 @@ export interface Record {
 }
 
 export namespace Record {
+  let _codec: Codec<Record>
+
   export const codec = (): Codec<Record> => {
-    return message<Record>({
-      1: { name: 'key', codec: bytes, optional: true },
-      2: { name: 'value', codec: bytes, optional: true },
-      3: { name: 'author', codec: bytes, optional: true },
-      4: { name: 'signature', codec: bytes, optional: true },
-      5: { name: 'timeReceived', codec: string, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<Record>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.key != null) {
+          writer.uint32(10)
+          writer.bytes(obj.key)
+        }
+
+        if (obj.value != null) {
+          writer.uint32(18)
+          writer.bytes(obj.value)
+        }
+
+        if (obj.author != null) {
+          writer.uint32(26)
+          writer.bytes(obj.author)
+        }
+
+        if (obj.signature != null) {
+          writer.uint32(34)
+          writer.bytes(obj.signature)
+        }
+
+        if (obj.timeReceived != null) {
+          writer.uint32(42)
+          writer.string(obj.timeReceived)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.key = reader.bytes()
+              break
+            case 2:
+              obj.value = reader.bytes()
+              break
+            case 3:
+              obj.author = reader.bytes()
+              break
+            case 4:
+              obj.signature = reader.bytes()
+              break
+            case 5:
+              obj.timeReceived = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
-  export const encode = (obj: Record): Uint8ArrayList => {
+  export const encode = (obj: Record): Uint8Array => {
     return encodeMessage(obj, Record.codec())
   }
 
@@ -63,7 +127,7 @@ export namespace Message {
 
   export namespace MessageType {
     export const codec = () => {
-      return enumeration<typeof MessageType>(__MessageTypeValues)
+      return enumeration<MessageType>(__MessageTypeValues)
     }
   }
 
@@ -83,7 +147,7 @@ export namespace Message {
 
   export namespace ConnectionType {
     export const codec = () => {
-      return enumeration<typeof ConnectionType>(__ConnectionTypeValues)
+      return enumeration<ConnectionType>(__ConnectionTypeValues)
     }
   }
 
@@ -94,15 +158,76 @@ export namespace Message {
   }
 
   export namespace Peer {
+    let _codec: Codec<Peer>
+
     export const codec = (): Codec<Peer> => {
-      return message<Peer>({
-        1: { name: 'id', codec: bytes, optional: true },
-        2: { name: 'addrs', codec: bytes, repeats: true },
-        3: { name: 'connection', codec: Message.ConnectionType.codec(), optional: true }
-      })
+      if (_codec == null) {
+        _codec = message<Peer>((obj, writer, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            writer.fork()
+          }
+
+          if (obj.id != null) {
+            writer.uint32(10)
+            writer.bytes(obj.id)
+          }
+
+          if (obj.addrs != null) {
+            for (const value of obj.addrs) {
+              writer.uint32(18)
+              writer.bytes(value)
+            }
+          } else {
+            throw new Error('Protocol error: required field "addrs" was not found in object')
+          }
+
+          if (obj.connection != null) {
+            writer.uint32(24)
+            Message.ConnectionType.codec().encode(obj.connection, writer)
+          }
+
+          if (opts.lengthDelimited !== false) {
+            writer.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {}
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1:
+                obj.id = reader.bytes()
+                break
+              case 2:
+                obj.addrs = obj.addrs ?? []
+                obj.addrs.push(reader.bytes())
+                break
+              case 3:
+                obj.connection = Message.ConnectionType.codec().decode(reader)
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          obj.addrs = obj.addrs ?? []
+
+          if (obj.addrs == null) {
+            throw new Error('Protocol error: value for required field "addrs" was not found in protobuf')
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
     }
 
-    export const encode = (obj: Peer): Uint8ArrayList => {
+    export const encode = (obj: Peer): Uint8Array => {
       return encodeMessage(obj, Peer.codec())
     }
 
@@ -111,18 +236,110 @@ export namespace Message {
     }
   }
 
+  let _codec: Codec<Message>
+
   export const codec = (): Codec<Message> => {
-    return message<Message>({
-      1: { name: 'type', codec: Message.MessageType.codec(), optional: true },
-      10: { name: 'clusterLevelRaw', codec: int32, optional: true },
-      2: { name: 'key', codec: bytes, optional: true },
-      3: { name: 'record', codec: bytes, optional: true },
-      8: { name: 'closerPeers', codec: Message.Peer.codec(), repeats: true },
-      9: { name: 'providerPeers', codec: Message.Peer.codec(), repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<Message>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          Message.MessageType.codec().encode(obj.type, writer)
+        }
+
+        if (obj.clusterLevelRaw != null) {
+          writer.uint32(80)
+          writer.int32(obj.clusterLevelRaw)
+        }
+
+        if (obj.key != null) {
+          writer.uint32(18)
+          writer.bytes(obj.key)
+        }
+
+        if (obj.record != null) {
+          writer.uint32(26)
+          writer.bytes(obj.record)
+        }
+
+        if (obj.closerPeers != null) {
+          for (const value of obj.closerPeers) {
+            writer.uint32(66)
+            Message.Peer.codec().encode(value, writer)
+          }
+        } else {
+          throw new Error('Protocol error: required field "closerPeers" was not found in object')
+        }
+
+        if (obj.providerPeers != null) {
+          for (const value of obj.providerPeers) {
+            writer.uint32(74)
+            Message.Peer.codec().encode(value, writer)
+          }
+        } else {
+          throw new Error('Protocol error: required field "providerPeers" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = Message.MessageType.codec().decode(reader)
+              break
+            case 10:
+              obj.clusterLevelRaw = reader.int32()
+              break
+            case 2:
+              obj.key = reader.bytes()
+              break
+            case 3:
+              obj.record = reader.bytes()
+              break
+            case 8:
+              obj.closerPeers = obj.closerPeers ?? []
+              obj.closerPeers.push(Message.Peer.codec().decode(reader, reader.uint32()))
+              break
+            case 9:
+              obj.providerPeers = obj.providerPeers ?? []
+              obj.providerPeers.push(Message.Peer.codec().decode(reader, reader.uint32()))
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.closerPeers = obj.closerPeers ?? []
+        obj.providerPeers = obj.providerPeers ?? []
+
+        if (obj.closerPeers == null) {
+          throw new Error('Protocol error: value for required field "closerPeers" was not found in protobuf')
+        }
+
+        if (obj.providerPeers == null) {
+          throw new Error('Protocol error: value for required field "providerPeers" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
-  export const encode = (obj: Message): Uint8ArrayList => {
+  export const encode = (obj: Message): Uint8Array => {
     return encodeMessage(obj, Message.codec())
   }
 

src/message/index.ts

@@ -65,7 +65,7 @@ export class Message {
       clusterLevelRaw: this.clusterLevelRaw,
       closerPeers: this.closerPeers.map(toPbPeer),
       providerPeers: this.providerPeers.map(toPbPeer),
-      record: this.record == null ? undefined : this.record.serialize()
+      record: this.record == null ? undefined : this.record.serialize().subarray()
     })
   }