@libp2p/autonat-v2 2.0.13 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/autonat-v2",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "Implementation of the AutoNAT Protocol v2",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/protocol-autonat-v2#readme",
@@ -45,28 +45,28 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/interface": "^3.1.0",
-    "@libp2p/interface-internal": "^3.0.13",
-    "@libp2p/peer-collections": "^7.0.13",
-    "@libp2p/utils": "^7.0.13",
+    "@libp2p/interface": "^3.1.1",
+    "@libp2p/interface-internal": "^3.0.14",
+    "@libp2p/peer-collections": "^7.0.14",
+    "@libp2p/utils": "^7.0.14",
     "@multiformats/multiaddr": "^13.0.1",
     "any-signal": "^4.1.1",
     "main-event": "^1.0.1",
-    "protons-runtime": "^5.6.0",
+    "protons-runtime": "^6.0.1",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/crypto": "^5.1.13",
-    "@libp2p/logger": "^6.2.2",
-    "@libp2p/peer-id": "^6.0.4",
+    "@libp2p/crypto": "^5.1.14",
+    "@libp2p/logger": "^6.2.3",
+    "@libp2p/peer-id": "^6.0.5",
     "aegir": "^47.0.22",
     "delay": "^7.0.0",
     "it-all": "^3.0.9",
     "it-length-prefixed": "^10.0.1",
     "it-pipe": "^3.0.1",
     "p-retry": "^7.0.0",
-    "protons": "^7.7.0",
+    "protons": "^8.1.1",
     "sinon": "^21.0.0",
     "sinon-ts": "^2.0.0"
   },

package/src/pb/index.ts

@@ -1,4 +1,4 @@
-import { decodeMessage, encodeMessage, enumeration, MaxLengthError, message } from 'protons-runtime'
+import { decodeMessage, encodeMessage, enumeration, MaxLengthError, message, streamMessage } from 'protons-runtime'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -134,19 +134,105 @@ export namespace Message {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield * DialRequest.codec().stream(reader, reader.uint32(), `${prefix}.dialRequest`, {
+                limits: opts.limits?.dialRequest
+              })
+
+              break
+            }
+            case 2: {
+              yield * DialResponse.codec().stream(reader, reader.uint32(), `${prefix}.dialResponse`, {
+                limits: opts.limits?.dialResponse
+              })
+
+              break
+            }
+            case 3: {
+              yield * DialDataRequest.codec().stream(reader, reader.uint32(), `${prefix}.dialDataRequest`, {
+                limits: opts.limits?.dialDataRequest
+              })
+
+              break
+            }
+            case 4: {
+              yield * DialDataResponse.codec().stream(reader, reader.uint32(), `${prefix}.dialDataResponse`, {
+                limits: opts.limits?.dialDataResponse
+              })
+
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<Message>): Uint8Array => {
+  export interface MessageDialRequestAddrsFieldEvent {
+    field: '$.dialRequest.addrs[]'
+    index: number
+    value: Uint8Array
+  }
+
+  export interface MessageDialRequestNonceFieldEvent {
+    field: '$.dialRequest.nonce'
+    value: bigint
+  }
+
+  export interface MessageDialResponseStatusFieldEvent {
+    field: '$.dialResponse.status'
+    value: DialResponse.ResponseStatus
+  }
+
+  export interface MessageDialResponseAddrIdxFieldEvent {
+    field: '$.dialResponse.addrIdx'
+    value: number
+  }
+
+  export interface MessageDialResponseDialStatusFieldEvent {
+    field: '$.dialResponse.dialStatus'
+    value: DialStatus
+  }
+
+  export interface MessageDialDataRequestAddrIdxFieldEvent {
+    field: '$.dialDataRequest.addrIdx'
+    value: number
+  }
+
+  export interface MessageDialDataRequestNumBytesFieldEvent {
+    field: '$.dialDataRequest.numBytes'
+    value: bigint
+  }
+
+  export interface MessageDialDataResponseDataFieldEvent {
+    field: '$.dialDataResponse.data'
+    value: Uint8Array
+  }
+
+  export function encode (obj: Partial<Message>): Uint8Array {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message {
     return decodeMessage(buf, Message.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Generator<MessageDialRequestAddrsFieldEvent | MessageDialRequestNonceFieldEvent | MessageDialResponseStatusFieldEvent | MessageDialResponseAddrIdxFieldEvent | MessageDialResponseDialStatusFieldEvent | MessageDialDataRequestAddrIdxFieldEvent | MessageDialDataRequestNumBytesFieldEvent | MessageDialDataResponseDataFieldEvent> {
+    return streamMessage(buf, Message.codec(), opts)
+  }
 }
 
 export interface DialRequest {
@@ -164,7 +250,7 @@ export namespace DialRequest {
           w.fork()
         }
 
-        if (obj.addrs != null) {
+        if (obj.addrs != null && obj.addrs.length > 0) {
           for (const value of obj.addrs) {
             w.uint32(10)
             w.bytes(value)
@@ -193,7 +279,7 @@ export namespace DialRequest {
           switch (tag >>> 3) {
             case 1: {
               if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
-                throw new MaxLengthError('Decode error - map field "addrs" had too many elements')
+                throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements')
               }
 
               obj.addrs.push(reader.bytes())
@@ -211,19 +297,73 @@ export namespace DialRequest {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const obj = {
+          addrs: 0
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
+                throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements')
+              }
+
+              yield {
+                field: `${prefix}.addrs[]`,
+                index: obj.addrs,
+                value: reader.bytes()
+              }
+
+              obj.addrs++
+
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.nonce`,
+                value: reader.fixed64()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<DialRequest>): Uint8Array => {
+  export interface DialRequestAddrsFieldEvent {
+    field: '$.addrs[]'
+    index: number
+    value: Uint8Array
+  }
+
+  export interface DialRequestNonceFieldEvent {
+    field: '$.nonce'
+    value: bigint
+  }
+
+  export function encode (obj: Partial<DialRequest>): Uint8Array {
     return encodeMessage(obj, DialRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialRequest>): DialRequest => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialRequest>): DialRequest {
     return decodeMessage(buf, DialRequest.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialRequest>): Generator<DialRequestAddrsFieldEvent | DialRequestNonceFieldEvent> {
+    return streamMessage(buf, DialRequest.codec(), opts)
+  }
 }
 
 export interface DialDataRequest {
@@ -282,19 +422,60 @@ export namespace DialDataRequest {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.addrIdx`,
+                value: reader.uint32()
+              }
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.numBytes`,
+                value: reader.uint64()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<DialDataRequest>): Uint8Array => {
+  export interface DialDataRequestAddrIdxFieldEvent {
+    field: '$.addrIdx'
+    value: number
+  }
+
+  export interface DialDataRequestNumBytesFieldEvent {
+    field: '$.numBytes'
+    value: bigint
+  }
+
+  export function encode (obj: Partial<DialDataRequest>): Uint8Array {
     return encodeMessage(obj, DialDataRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialDataRequest>): DialDataRequest => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialDataRequest>): DialDataRequest {
     return decodeMessage(buf, DialDataRequest.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialDataRequest>): Generator<DialDataRequestAddrIdxFieldEvent | DialDataRequestNumBytesFieldEvent> {
+    return streamMessage(buf, DialDataRequest.codec(), opts)
+  }
 }
 
 export enum DialStatus {
@@ -404,19 +585,72 @@ export namespace DialResponse {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.status`,
+                value: DialResponse.ResponseStatus.codec().decode(reader)
+              }
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.addrIdx`,
+                value: reader.uint32()
+              }
+              break
+            }
+            case 3: {
+              yield {
+                field: `${prefix}.dialStatus`,
+                value: DialStatus.codec().decode(reader)
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<DialResponse>): Uint8Array => {
+  export interface DialResponseStatusFieldEvent {
+    field: '$.status'
+    value: DialResponse.ResponseStatus
+  }
+
+  export interface DialResponseAddrIdxFieldEvent {
+    field: '$.addrIdx'
+    value: number
+  }
+
+  export interface DialResponseDialStatusFieldEvent {
+    field: '$.dialStatus'
+    value: DialStatus
+  }
+
+  export function encode (obj: Partial<DialResponse>): Uint8Array {
     return encodeMessage(obj, DialResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialResponse>): DialResponse => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialResponse>): DialResponse {
     return decodeMessage(buf, DialResponse.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialResponse>): Generator<DialResponseStatusFieldEvent | DialResponseAddrIdxFieldEvent | DialResponseDialStatusFieldEvent> {
+    return streamMessage(buf, DialResponse.codec(), opts)
+  }
 }
 
 export interface DialDataResponse {
@@ -464,19 +698,48 @@ export namespace DialDataResponse {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.data`,
+                value: reader.bytes()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<DialDataResponse>): Uint8Array => {
+  export interface DialDataResponseDataFieldEvent {
+    field: '$.data'
+    value: Uint8Array
+  }
+
+  export function encode (obj: Partial<DialDataResponse>): Uint8Array {
     return encodeMessage(obj, DialDataResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialDataResponse>): DialDataResponse => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialDataResponse>): DialDataResponse {
     return decodeMessage(buf, DialDataResponse.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialDataResponse>): Generator<DialDataResponseDataFieldEvent> {
+    return streamMessage(buf, DialDataResponse.codec(), opts)
+  }
 }
 
 export interface DialBack {
@@ -524,19 +787,48 @@ export namespace DialBack {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.nonce`,
+                value: reader.fixed64()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<DialBack>): Uint8Array => {
+  export interface DialBackNonceFieldEvent {
+    field: '$.nonce'
+    value: bigint
+  }
+
+  export function encode (obj: Partial<DialBack>): Uint8Array {
     return encodeMessage(obj, DialBack.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialBack>): DialBack => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialBack>): DialBack {
     return decodeMessage(buf, DialBack.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialBack>): Generator<DialBackNonceFieldEvent> {
+    return streamMessage(buf, DialBack.codec(), opts)
+  }
 }
 
 export interface DialBackResponse {
@@ -598,17 +890,46 @@ export namespace DialBackResponse {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.status`,
+                value: DialBackResponse.DialBackStatus.codec().decode(reader)
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<DialBackResponse>): Uint8Array => {
+  export interface DialBackResponseStatusFieldEvent {
+    field: '$.status'
+    value: DialBackResponse.DialBackStatus
+  }
+
+  export function encode (obj: Partial<DialBackResponse>): Uint8Array {
     return encodeMessage(obj, DialBackResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialBackResponse>): DialBackResponse => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialBackResponse>): DialBackResponse {
     return decodeMessage(buf, DialBackResponse.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialBackResponse>): Generator<DialBackResponseStatusFieldEvent> {
+    return streamMessage(buf, DialBackResponse.codec(), opts)
+  }
 }