diff --git a/packages/connection-encrypter-plaintext/package.json b/packages/connection-encrypter-plaintext/package.json index d127f04f0f..361fd5eb59 100644 --- a/packages/connection-encrypter-plaintext/package.json +++ b/packages/connection-encrypter-plaintext/package.json @@ -49,7 +49,7 @@ "@libp2p/interface": "^3.1.0", "@libp2p/peer-id": "^6.0.4", "@libp2p/utils": "^7.0.13", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -57,7 +57,7 @@ "@libp2p/crypto": "^5.1.13", "@libp2p/logger": "^6.2.2", "aegir": "^47.0.22", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0" }, "sideEffects": false diff --git a/packages/connection-encrypter-plaintext/src/pb/proto.ts b/packages/connection-encrypter-plaintext/src/pb/proto.ts index 12fcbb8ef8..52a368f0a8 100644 --- a/packages/connection-encrypter-plaintext/src/pb/proto.ts +++ b/packages/connection-encrypter-plaintext/src/pb/proto.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime' import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -58,19 +58,65 @@ export namespace Exchange { } 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}.id`, + value: reader.bytes() + } + break + } + case 2: { + yield * PublicKey.codec().stream(reader, reader.uint32(), `${prefix}.pubkey`, { + limits: opts.limits?.pubkey + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ExchangeIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface ExchangePubkeyTypeFieldEvent { + field: '$.pubkey.Type' + value: KeyType + } + + export interface ExchangePubkeyDataFieldEvent { + field: '$.pubkey.Data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Exchange.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Exchange => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Exchange { return decodeMessage(buf, Exchange.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Exchange.codec(), opts) + } } export enum KeyType { @@ -92,6 +138,7 @@ export namespace KeyType { return enumeration(__KeyTypeValues) } } + export interface PublicKey { Type?: KeyType Data: Uint8Array @@ -147,17 +194,58 @@ export namespace PublicKey { } 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}.Type`, + value: KeyType.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.Data`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PublicKeyTypeFieldEvent { + field: '$.Type' + value: KeyType + } + + export interface PublicKeyDataFieldEvent { + field: '$.Data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PublicKey.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PublicKey => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PublicKey { return decodeMessage(buf, PublicKey.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PublicKey.codec(), opts) + } } diff --git a/packages/connection-encrypter-tls/package.json b/packages/connection-encrypter-tls/package.json index 818da585ed..2852ea579d 100644 --- a/packages/connection-encrypter-tls/package.json +++ b/packages/connection-encrypter-tls/package.json @@ -51,14 +51,14 @@ "@peculiar/x509": "^1.13.0", "asn1js": "^3.0.6", "p-event": "^7.0.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, "devDependencies": { "@libp2p/logger": "^6.2.2", "aegir": "^47.0.22", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0" }, diff --git a/packages/connection-encrypter-tls/src/pb/index.ts b/packages/connection-encrypter-tls/src/pb/index.ts index 2fdbaf4fde..41b809ddd7 100644 --- a/packages/connection-encrypter-tls/src/pb/index.ts +++ b/packages/connection-encrypter-tls/src/pb/index.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -21,6 +21,7 @@ export namespace KeyType { return enumeration(__KeyTypeValues) } } + export interface PublicKey { type?: KeyType data?: Uint8Array @@ -74,17 +75,58 @@ export namespace PublicKey { } 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}.type`, + value: KeyType.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PublicKeyTypeFieldEvent { + field: '$.type' + value: KeyType + } + + export interface PublicKeyDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PublicKey.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PublicKey => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PublicKey { return decodeMessage(buf, PublicKey.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PublicKey.codec(), opts) + } } diff --git a/packages/crypto/package.json b/packages/crypto/package.json index 28b2233f9d..5eb59311c2 100644 --- a/packages/crypto/package.json +++ b/packages/crypto/package.json @@ -89,7 +89,7 @@ "@noble/curves": "^2.0.1", "@noble/hashes": "^2.0.1", "multiformats": "^13.4.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -98,7 +98,7 @@ "aegir": "^47.0.22", "asn1js": "^3.0.6", "benchmark": "^2.1.4", - "protons": "^7.7.0" + "protons": "^8.1.1" }, "browser": { "./dist/src/ciphers/aes-gcm.js": "./dist/src/ciphers/aes-gcm.browser.js", diff --git a/packages/crypto/src/keys/keys.ts b/packages/crypto/src/keys/keys.ts index afd2ac719d..7f8b5a5182 100644 --- a/packages/crypto/src/keys/keys.ts +++ b/packages/crypto/src/keys/keys.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -21,6 +21,7 @@ export namespace KeyType { return enumeration(__KeyTypeValues) } } + export interface PublicKey { Type?: KeyType Data?: Uint8Array @@ -74,19 +75,60 @@ export namespace PublicKey { } 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}.Type`, + value: KeyType.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.Data`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PublicKeyTypeFieldEvent { + field: '$.Type' + value: KeyType + } + + export interface PublicKeyDataFieldEvent { + field: '$.Data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PublicKey.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PublicKey => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PublicKey { return decodeMessage(buf, PublicKey.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PublicKey.codec(), opts) + } } export interface PrivateKey { @@ -142,17 +184,58 @@ export namespace PrivateKey { } 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}.Type`, + value: KeyType.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.Data`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PrivateKeyTypeFieldEvent { + field: '$.Type' + value: KeyType + } + + export interface PrivateKeyDataFieldEvent { + field: '$.Data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PrivateKey.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PrivateKey => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PrivateKey { return decodeMessage(buf, PrivateKey.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PrivateKey.codec(), opts) + } } diff --git a/packages/floodsub/package.json b/packages/floodsub/package.json index 47b9d563e7..7ba7dcf467 100644 --- a/packages/floodsub/package.json +++ b/packages/floodsub/package.json @@ -63,7 +63,7 @@ "main-event": "^1.0.1", "multiformats": "^13.4.1", "p-queue": "^9.0.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -74,7 +74,7 @@ "aegir": "^47.0.22", "delay": "^7.0.0", "p-wait-for": "^6.0.0", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0" }, diff --git a/packages/floodsub/src/message/rpc.ts b/packages/floodsub/src/message/rpc.ts index 1892774c07..4b2aac7c90 100644 --- a/packages/floodsub/src/message/rpc.ts +++ b/packages/floodsub/src/message/rpc.ts @@ -1,6 +1,4 @@ -/* eslint-disable complexity */ - -import { decodeMessage, encodeMessage, MaxLengthError, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, MaxLengthError, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -64,19 +62,60 @@ export namespace RPC { } 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}.subscribe`, + value: reader.bool() + } + break + } + case 2: { + yield { + field: `${prefix}.topic`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface SubOptsSubscribeFieldEvent { + field: '$.subscribe' + value: boolean + } + + export interface SubOptsTopicFieldEvent { + field: '$.topic' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, SubOpts.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): SubOpts => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): SubOpts { return decodeMessage(buf, SubOpts.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, SubOpts.codec(), opts) + } } export interface Message { @@ -172,19 +211,108 @@ export namespace RPC { } 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}.from`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.sequenceNumber`, + value: reader.bytes() + } + break + } + case 4: { + yield { + field: `${prefix}.topic`, + value: reader.string() + } + break + } + case 5: { + yield { + field: `${prefix}.signature`, + value: reader.bytes() + } + break + } + case 6: { + yield { + field: `${prefix}.key`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageFromFieldEvent { + field: '$.from' + value: Uint8Array + } + + export interface MessageDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export interface MessageSequenceNumberFieldEvent { + field: '$.sequenceNumber' + value: Uint8Array + } + + export interface MessageTopicFieldEvent { + field: '$.topic' + value: string + } + + export interface MessageSignatureFieldEvent { + field: '$.signature' + value: Uint8Array + } + + export interface MessageKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } } let _codec: Codec @@ -196,14 +324,14 @@ export namespace RPC { w.fork() } - if (obj.subscriptions != null) { + if (obj.subscriptions != null && obj.subscriptions.length > 0) { for (const value of obj.subscriptions) { w.uint32(10) RPC.SubOpts.codec().encode(value, w) } } - if (obj.messages != null) { + if (obj.messages != null && obj.messages.length > 0) { for (const value of obj.messages) { w.uint32(18) RPC.Message.codec().encode(value, w) @@ -232,7 +360,7 @@ export namespace RPC { switch (tag >>> 3) { case 1: { if (opts.limits?.subscriptions != null && obj.subscriptions.length === opts.limits.subscriptions) { - throw new MaxLengthError('Decode error - map field "subscriptions" had too many elements') + throw new MaxLengthError('Decode error - repeated field "subscriptions" had too many elements') } obj.subscriptions.push(RPC.SubOpts.codec().decode(reader, reader.uint32(), { @@ -242,7 +370,7 @@ export namespace RPC { } case 2: { if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) { - throw new MaxLengthError('Decode error - map field "messages" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messages" had too many elements') } obj.messages.push(RPC.Message.codec().decode(reader, reader.uint32(), { @@ -264,19 +392,180 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + subscriptions: 0, + messages: 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?.subscriptions != null && obj.subscriptions === opts.limits.subscriptions) { + throw new MaxLengthError('Streaming decode error - repeated field "subscriptions" had too many elements') + } + + for (const evt of RPC.SubOpts.codec().stream(reader, reader.uint32(), `${prefix}.subscriptions[]`, { + limits: opts.limits?.subscriptions$ + })) { + yield { + ...evt, + index: obj.subscriptions + } + } + + obj.subscriptions++ + + break + } + case 2: { + if (opts.limits?.messages != null && obj.messages === opts.limits.messages) { + throw new MaxLengthError('Streaming decode error - repeated field "messages" had too many elements') + } + + for (const evt of RPC.Message.codec().stream(reader, reader.uint32(), `${prefix}.messages[]`, { + limits: opts.limits?.messages$ + })) { + yield { + ...evt, + index: obj.messages + } + } + + obj.messages++ + + break + } + case 3: { + yield * ControlMessage.codec().stream(reader, reader.uint32(), `${prefix}.control`, { + limits: opts.limits?.control + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface RPCSubscriptionsSubscribeFieldEvent { + field: '$.subscriptions[].subscribe' + value: boolean + index: number + } + + export interface RPCSubscriptionsTopicFieldEvent { + field: '$.subscriptions[].topic' + value: string + index: number + } + + export interface RPCMessagesFromFieldEvent { + field: '$.messages[].from' + value: Uint8Array + index: number + } + + export interface RPCMessagesDataFieldEvent { + field: '$.messages[].data' + value: Uint8Array + index: number + } + + export interface RPCMessagesSequenceNumberFieldEvent { + field: '$.messages[].sequenceNumber' + value: Uint8Array + index: number + } + + export interface RPCMessagesTopicFieldEvent { + field: '$.messages[].topic' + value: string + index: number + } + + export interface RPCMessagesSignatureFieldEvent { + field: '$.messages[].signature' + value: Uint8Array + index: number + } + + export interface RPCMessagesKeyFieldEvent { + field: '$.messages[].key' + value: Uint8Array + index: number + } + + export interface RPCControlIhaveTopicFieldEvent { + field: '$.control.ihave[].topic' + value: string + index: number + } + + export interface RPCControlIhaveMessageIDsFieldEvent { + field: '$.control.ihave[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface RPCControlIwantMessageIDsFieldEvent { + field: '$.control.iwant[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface RPCControlGraftTopicFieldEvent { + field: '$.control.graft[].topic' + value: string + index: number + } + + export interface RPCControlPruneTopicFieldEvent { + field: '$.control.prune[].topic' + value: string + index: number + } + + export interface RPCControlPrunePeersPeerIDFieldEvent { + field: '$.control.prune[].peers[].peerID' + value: Uint8Array + index: number + } + + export interface RPCControlPrunePeersSignedPeerRecordFieldEvent { + field: '$.control.prune[].peers[].signedPeerRecord' + value: Uint8Array + index: number + } + + export interface RPCControlPruneBackoffFieldEvent { + field: '$.control.prune[].backoff' + value: bigint + index: number + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, RPC.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): RPC => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): RPC { return decodeMessage(buf, RPC.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, RPC.codec(), opts) + } } export interface ControlMessage { @@ -296,28 +585,28 @@ export namespace ControlMessage { w.fork() } - if (obj.ihave != null) { + if (obj.ihave != null && obj.ihave.length > 0) { for (const value of obj.ihave) { w.uint32(10) ControlIHave.codec().encode(value, w) } } - if (obj.iwant != null) { + if (obj.iwant != null && obj.iwant.length > 0) { for (const value of obj.iwant) { w.uint32(18) ControlIWant.codec().encode(value, w) } } - if (obj.graft != null) { + if (obj.graft != null && obj.graft.length > 0) { for (const value of obj.graft) { w.uint32(26) ControlGraft.codec().encode(value, w) } } - if (obj.prune != null) { + if (obj.prune != null && obj.prune.length > 0) { for (const value of obj.prune) { w.uint32(34) ControlPrune.codec().encode(value, w) @@ -343,7 +632,7 @@ export namespace ControlMessage { switch (tag >>> 3) { case 1: { if (opts.limits?.ihave != null && obj.ihave.length === opts.limits.ihave) { - throw new MaxLengthError('Decode error - map field "ihave" had too many elements') + throw new MaxLengthError('Decode error - repeated field "ihave" had too many elements') } obj.ihave.push(ControlIHave.codec().decode(reader, reader.uint32(), { @@ -353,7 +642,7 @@ export namespace ControlMessage { } case 2: { if (opts.limits?.iwant != null && obj.iwant.length === opts.limits.iwant) { - throw new MaxLengthError('Decode error - map field "iwant" had too many elements') + throw new MaxLengthError('Decode error - repeated field "iwant" had too many elements') } obj.iwant.push(ControlIWant.codec().decode(reader, reader.uint32(), { @@ -363,7 +652,7 @@ export namespace ControlMessage { } case 3: { if (opts.limits?.graft != null && obj.graft.length === opts.limits.graft) { - throw new MaxLengthError('Decode error - map field "graft" had too many elements') + throw new MaxLengthError('Decode error - repeated field "graft" had too many elements') } obj.graft.push(ControlGraft.codec().decode(reader, reader.uint32(), { @@ -373,7 +662,7 @@ export namespace ControlMessage { } case 4: { if (opts.limits?.prune != null && obj.prune.length === opts.limits.prune) { - throw new MaxLengthError('Decode error - map field "prune" had too many elements') + throw new MaxLengthError('Decode error - repeated field "prune" had too many elements') } obj.prune.push(ControlPrune.codec().decode(reader, reader.uint32(), { @@ -389,19 +678,163 @@ export namespace ControlMessage { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + ihave: 0, + iwant: 0, + graft: 0, + prune: 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?.ihave != null && obj.ihave === opts.limits.ihave) { + throw new MaxLengthError('Streaming decode error - repeated field "ihave" had too many elements') + } + + for (const evt of ControlIHave.codec().stream(reader, reader.uint32(), `${prefix}.ihave[]`, { + limits: opts.limits?.ihave$ + })) { + yield { + ...evt, + index: obj.ihave + } + } + + obj.ihave++ + + break + } + case 2: { + if (opts.limits?.iwant != null && obj.iwant === opts.limits.iwant) { + throw new MaxLengthError('Streaming decode error - repeated field "iwant" had too many elements') + } + + for (const evt of ControlIWant.codec().stream(reader, reader.uint32(), `${prefix}.iwant[]`, { + limits: opts.limits?.iwant$ + })) { + yield { + ...evt, + index: obj.iwant + } + } + + obj.iwant++ + + break + } + case 3: { + if (opts.limits?.graft != null && obj.graft === opts.limits.graft) { + throw new MaxLengthError('Streaming decode error - repeated field "graft" had too many elements') + } + + for (const evt of ControlGraft.codec().stream(reader, reader.uint32(), `${prefix}.graft[]`, { + limits: opts.limits?.graft$ + })) { + yield { + ...evt, + index: obj.graft + } + } + + obj.graft++ + + break + } + case 4: { + if (opts.limits?.prune != null && obj.prune === opts.limits.prune) { + throw new MaxLengthError('Streaming decode error - repeated field "prune" had too many elements') + } + + for (const evt of ControlPrune.codec().stream(reader, reader.uint32(), `${prefix}.prune[]`, { + limits: opts.limits?.prune$ + })) { + yield { + ...evt, + index: obj.prune + } + } + + obj.prune++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlMessageIhaveTopicFieldEvent { + field: '$.ihave[].topic' + value: string + index: number + } + + export interface ControlMessageIhaveMessageIDsFieldEvent { + field: '$.ihave[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface ControlMessageIwantMessageIDsFieldEvent { + field: '$.iwant[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface ControlMessageGraftTopicFieldEvent { + field: '$.graft[].topic' + value: string + index: number + } + + export interface ControlMessagePruneTopicFieldEvent { + field: '$.prune[].topic' + value: string + index: number + } + + export interface ControlMessagePrunePeersPeerIDFieldEvent { + field: '$.prune[].peers[].peerID' + value: Uint8Array + index: number + } + + export interface ControlMessagePrunePeersSignedPeerRecordFieldEvent { + field: '$.prune[].peers[].signedPeerRecord' + value: Uint8Array + index: number + } + + export interface ControlMessagePruneBackoffFieldEvent { + field: '$.prune[].backoff' + value: bigint + index: number + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlMessage => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlMessage { return decodeMessage(buf, ControlMessage.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlMessage.codec(), opts) + } } export interface ControlIHave { @@ -424,7 +857,7 @@ export namespace ControlIHave { w.string(obj.topic) } - if (obj.messageIDs != null) { + if (obj.messageIDs != null && obj.messageIDs.length > 0) { for (const value of obj.messageIDs) { w.uint32(18) w.bytes(value) @@ -451,7 +884,7 @@ export namespace ControlIHave { } case 2: { if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) { - throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements') } obj.messageIDs.push(reader.bytes()) @@ -465,19 +898,73 @@ export namespace ControlIHave { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + messageIDs: 0 + } + + 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}.topic`, + value: reader.string() + } + break + } + case 2: { + if (opts.limits?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements') + } + + yield { + field: `${prefix}.messageIDs[]`, + index: obj.messageIDs, + value: reader.bytes() + } + + obj.messageIDs++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlIHaveTopicFieldEvent { + field: '$.topic' + value: string + } + + export interface ControlIHaveMessageIDsFieldEvent { + field: '$.messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlIHave.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIHave => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIHave { return decodeMessage(buf, ControlIHave.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlIHave.codec(), opts) + } } export interface ControlIWant { @@ -494,7 +981,7 @@ export namespace ControlIWant { w.fork() } - if (obj.messageIDs != null) { + if (obj.messageIDs != null && obj.messageIDs.length > 0) { for (const value of obj.messageIDs) { w.uint32(10) w.bytes(value) @@ -517,7 +1004,7 @@ export namespace ControlIWant { switch (tag >>> 3) { case 1: { if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) { - throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements') } obj.messageIDs.push(reader.bytes()) @@ -531,19 +1018,61 @@ export namespace ControlIWant { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + messageIDs: 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?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements') + } + + yield { + field: `${prefix}.messageIDs[]`, + index: obj.messageIDs, + value: reader.bytes() + } + + obj.messageIDs++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlIWantMessageIDsFieldEvent { + field: '$.messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlIWant.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIWant => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIWant { return decodeMessage(buf, ControlIWant.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlIWant.codec(), opts) + } } export interface ControlGraft { @@ -589,19 +1118,48 @@ export namespace ControlGraft { } 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}.topic`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlGraftTopicFieldEvent { + field: '$.topic' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlGraft.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlGraft => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlGraft { return decodeMessage(buf, ControlGraft.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlGraft.codec(), opts) + } } export interface ControlPrune { @@ -625,7 +1183,7 @@ export namespace ControlPrune { w.string(obj.topic) } - if (obj.peers != null) { + if (obj.peers != null && obj.peers.length > 0) { for (const value of obj.peers) { w.uint32(18) PeerInfo.codec().encode(value, w) @@ -657,7 +1215,7 @@ export namespace ControlPrune { } case 2: { if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) { - throw new MaxLengthError('Decode error - map field "peers" had too many elements') + throw new MaxLengthError('Decode error - repeated field "peers" had too many elements') } obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32(), { @@ -677,19 +1235,94 @@ export namespace ControlPrune { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + peers: 0 + } + + 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}.topic`, + value: reader.string() + } + break + } + case 2: { + if (opts.limits?.peers != null && obj.peers === opts.limits.peers) { + throw new MaxLengthError('Streaming decode error - repeated field "peers" had too many elements') + } + + for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peers[]`, { + limits: opts.limits?.peers$ + })) { + yield { + ...evt, + index: obj.peers + } + } + + obj.peers++ + + break + } + case 3: { + yield { + field: `${prefix}.backoff`, + value: reader.uint64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlPruneTopicFieldEvent { + field: '$.topic' + value: string + } + + export interface ControlPrunePeersPeerIDFieldEvent { + field: '$.peers[].peerID' + value: Uint8Array + index: number + } + + export interface ControlPrunePeersSignedPeerRecordFieldEvent { + field: '$.peers[].signedPeerRecord' + value: Uint8Array + index: number + } + + export interface ControlPruneBackoffFieldEvent { + field: '$.backoff' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlPrune.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlPrune => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlPrune { return decodeMessage(buf, ControlPrune.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlPrune.codec(), opts) + } } export interface PeerInfo { @@ -745,17 +1378,58 @@ export namespace PeerInfo { } 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}.peerID`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.signedPeerRecord`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerInfoPeerIDFieldEvent { + field: '$.peerID' + value: Uint8Array + } + + export interface PeerInfoSignedPeerRecordFieldEvent { + field: '$.signedPeerRecord' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo { return decodeMessage(buf, PeerInfo.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerInfo.codec(), opts) + } } diff --git a/packages/gossipsub/package.json b/packages/gossipsub/package.json index bbb3bf760e..55c695694c 100644 --- a/packages/gossipsub/package.json +++ b/packages/gossipsub/package.json @@ -83,7 +83,7 @@ "it-pipe": "^3.0.1", "it-pushable": "^3.2.3", "multiformats": "^13.0.1", - "protons-runtime": "^5.5.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.0.1" }, @@ -105,7 +105,7 @@ "p-event": "^7.0.0", "p-retry": "^7.0.0", "p-wait-for": "^6.0.0", - "protons": "^7.5.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0", "time-cache": "^0.3.0" diff --git a/packages/gossipsub/src/message/rpc.ts b/packages/gossipsub/src/message/rpc.ts index eb018dd6e1..4505976902 100644 --- a/packages/gossipsub/src/message/rpc.ts +++ b/packages/gossipsub/src/message/rpc.ts @@ -1,6 +1,4 @@ -/* eslint-disable complexity */ - -import { decodeMessage, encodeMessage, MaxLengthError, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, MaxLengthError, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -64,19 +62,60 @@ export namespace RPC { } 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}.subscribe`, + value: reader.bool() + } + break + } + case 2: { + yield { + field: `${prefix}.topic`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface SubOptsSubscribeFieldEvent { + field: '$.subscribe' + value: boolean + } + + export interface SubOptsTopicFieldEvent { + field: '$.topic' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, SubOpts.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): SubOpts => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): SubOpts { return decodeMessage(buf, SubOpts.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, SubOpts.codec(), opts) + } } export interface Message { @@ -174,19 +213,108 @@ export namespace RPC { } 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}.from`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.seqno`, + value: reader.bytes() + } + break + } + case 4: { + yield { + field: `${prefix}.topic`, + value: reader.string() + } + break + } + case 5: { + yield { + field: `${prefix}.signature`, + value: reader.bytes() + } + break + } + case 6: { + yield { + field: `${prefix}.key`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageFromFieldEvent { + field: '$.from' + value: Uint8Array + } + + export interface MessageDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export interface MessageSeqnoFieldEvent { + field: '$.seqno' + value: Uint8Array + } + + export interface MessageTopicFieldEvent { + field: '$.topic' + value: string + } + + export interface MessageSignatureFieldEvent { + field: '$.signature' + value: Uint8Array + } + + export interface MessageKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } } export interface ControlMessage { @@ -207,35 +335,35 @@ export namespace RPC { w.fork() } - if (obj.ihave != null) { + if (obj.ihave != null && obj.ihave.length > 0) { for (const value of obj.ihave) { w.uint32(10) RPC.ControlIHave.codec().encode(value, w) } } - if (obj.iwant != null) { + if (obj.iwant != null && obj.iwant.length > 0) { for (const value of obj.iwant) { w.uint32(18) RPC.ControlIWant.codec().encode(value, w) } } - if (obj.graft != null) { + if (obj.graft != null && obj.graft.length > 0) { for (const value of obj.graft) { w.uint32(26) RPC.ControlGraft.codec().encode(value, w) } } - if (obj.prune != null) { + if (obj.prune != null && obj.prune.length > 0) { for (const value of obj.prune) { w.uint32(34) RPC.ControlPrune.codec().encode(value, w) } } - if (obj.idontwant != null) { + if (obj.idontwant != null && obj.idontwant.length > 0) { for (const value of obj.idontwant) { w.uint32(42) RPC.ControlIDontWant.codec().encode(value, w) @@ -262,7 +390,7 @@ export namespace RPC { switch (tag >>> 3) { case 1: { if (opts.limits?.ihave != null && obj.ihave.length === opts.limits.ihave) { - throw new MaxLengthError('Decode error - map field "ihave" had too many elements') + throw new MaxLengthError('Decode error - repeated field "ihave" had too many elements') } obj.ihave.push(RPC.ControlIHave.codec().decode(reader, reader.uint32(), { @@ -272,7 +400,7 @@ export namespace RPC { } case 2: { if (opts.limits?.iwant != null && obj.iwant.length === opts.limits.iwant) { - throw new MaxLengthError('Decode error - map field "iwant" had too many elements') + throw new MaxLengthError('Decode error - repeated field "iwant" had too many elements') } obj.iwant.push(RPC.ControlIWant.codec().decode(reader, reader.uint32(), { @@ -282,7 +410,7 @@ export namespace RPC { } case 3: { if (opts.limits?.graft != null && obj.graft.length === opts.limits.graft) { - throw new MaxLengthError('Decode error - map field "graft" had too many elements') + throw new MaxLengthError('Decode error - repeated field "graft" had too many elements') } obj.graft.push(RPC.ControlGraft.codec().decode(reader, reader.uint32(), { @@ -292,7 +420,7 @@ export namespace RPC { } case 4: { if (opts.limits?.prune != null && obj.prune.length === opts.limits.prune) { - throw new MaxLengthError('Decode error - map field "prune" had too many elements') + throw new MaxLengthError('Decode error - repeated field "prune" had too many elements') } obj.prune.push(RPC.ControlPrune.codec().decode(reader, reader.uint32(), { @@ -302,7 +430,7 @@ export namespace RPC { } case 5: { if (opts.limits?.idontwant != null && obj.idontwant.length === opts.limits.idontwant) { - throw new MaxLengthError('Decode error - map field "idontwant" had too many elements') + throw new MaxLengthError('Decode error - repeated field "idontwant" had too many elements') } obj.idontwant.push(RPC.ControlIDontWant.codec().decode(reader, reader.uint32(), { @@ -318,19 +446,188 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + ihave: 0, + iwant: 0, + graft: 0, + prune: 0, + idontwant: 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?.ihave != null && obj.ihave === opts.limits.ihave) { + throw new MaxLengthError('Streaming decode error - repeated field "ihave" had too many elements') + } + + for (const evt of RPC.ControlIHave.codec().stream(reader, reader.uint32(), `${prefix}.ihave[]`, { + limits: opts.limits?.ihave$ + })) { + yield { + ...evt, + index: obj.ihave + } + } + + obj.ihave++ + + break + } + case 2: { + if (opts.limits?.iwant != null && obj.iwant === opts.limits.iwant) { + throw new MaxLengthError('Streaming decode error - repeated field "iwant" had too many elements') + } + + for (const evt of RPC.ControlIWant.codec().stream(reader, reader.uint32(), `${prefix}.iwant[]`, { + limits: opts.limits?.iwant$ + })) { + yield { + ...evt, + index: obj.iwant + } + } + + obj.iwant++ + + break + } + case 3: { + if (opts.limits?.graft != null && obj.graft === opts.limits.graft) { + throw new MaxLengthError('Streaming decode error - repeated field "graft" had too many elements') + } + + for (const evt of RPC.ControlGraft.codec().stream(reader, reader.uint32(), `${prefix}.graft[]`, { + limits: opts.limits?.graft$ + })) { + yield { + ...evt, + index: obj.graft + } + } + + obj.graft++ + + break + } + case 4: { + if (opts.limits?.prune != null && obj.prune === opts.limits.prune) { + throw new MaxLengthError('Streaming decode error - repeated field "prune" had too many elements') + } + + for (const evt of RPC.ControlPrune.codec().stream(reader, reader.uint32(), `${prefix}.prune[]`, { + limits: opts.limits?.prune$ + })) { + yield { + ...evt, + index: obj.prune + } + } + + obj.prune++ + + break + } + case 5: { + if (opts.limits?.idontwant != null && obj.idontwant === opts.limits.idontwant) { + throw new MaxLengthError('Streaming decode error - repeated field "idontwant" had too many elements') + } + + for (const evt of RPC.ControlIDontWant.codec().stream(reader, reader.uint32(), `${prefix}.idontwant[]`, { + limits: opts.limits?.idontwant$ + })) { + yield { + ...evt, + index: obj.idontwant + } + } + + obj.idontwant++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlMessageIhaveTopicIDFieldEvent { + field: '$.ihave[].topicID' + value: string + index: number + } + + export interface ControlMessageIhaveMessageIDsFieldEvent { + field: '$.ihave[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface ControlMessageIwantMessageIDsFieldEvent { + field: '$.iwant[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface ControlMessageGraftTopicIDFieldEvent { + field: '$.graft[].topicID' + value: string + index: number + } + + export interface ControlMessagePruneTopicIDFieldEvent { + field: '$.prune[].topicID' + value: string + index: number + } + + export interface ControlMessagePrunePeersPeerIDFieldEvent { + field: '$.prune[].peers[].peerID' + value: Uint8Array + index: number + } + + export interface ControlMessagePrunePeersSignedPeerRecordFieldEvent { + field: '$.prune[].peers[].signedPeerRecord' + value: Uint8Array + index: number + } + + export interface ControlMessagePruneBackoffFieldEvent { + field: '$.prune[].backoff' + value: number + index: number + } + + export interface ControlMessageIdontwantMessageIDsFieldEvent { + field: '$.idontwant[].messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlMessage => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlMessage { return decodeMessage(buf, ControlMessage.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlMessage.codec(), opts) + } } export interface ControlIHave { @@ -353,7 +650,7 @@ export namespace RPC { w.string(obj.topicID) } - if (obj.messageIDs != null) { + if (obj.messageIDs != null && obj.messageIDs.length > 0) { for (const value of obj.messageIDs) { w.uint32(18) w.bytes(value) @@ -380,7 +677,7 @@ export namespace RPC { } case 2: { if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) { - throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements') } obj.messageIDs.push(reader.bytes()) @@ -394,19 +691,73 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + messageIDs: 0 + } + + 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}.topicID`, + value: reader.string() + } + break + } + case 2: { + if (opts.limits?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements') + } + + yield { + field: `${prefix}.messageIDs[]`, + index: obj.messageIDs, + value: reader.bytes() + } + + obj.messageIDs++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlIHaveTopicIDFieldEvent { + field: '$.topicID' + value: string + } + + export interface ControlIHaveMessageIDsFieldEvent { + field: '$.messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlIHave.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIHave => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIHave { return decodeMessage(buf, ControlIHave.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlIHave.codec(), opts) + } } export interface ControlIWant { @@ -423,7 +774,7 @@ export namespace RPC { w.fork() } - if (obj.messageIDs != null) { + if (obj.messageIDs != null && obj.messageIDs.length > 0) { for (const value of obj.messageIDs) { w.uint32(10) w.bytes(value) @@ -446,7 +797,7 @@ export namespace RPC { switch (tag >>> 3) { case 1: { if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) { - throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements') } obj.messageIDs.push(reader.bytes()) @@ -460,19 +811,61 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + messageIDs: 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?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements') + } + + yield { + field: `${prefix}.messageIDs[]`, + index: obj.messageIDs, + value: reader.bytes() + } + + obj.messageIDs++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlIWantMessageIDsFieldEvent { + field: '$.messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlIWant.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIWant => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIWant { return decodeMessage(buf, ControlIWant.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlIWant.codec(), opts) + } } export interface ControlGraft { @@ -518,19 +911,48 @@ export namespace RPC { } 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}.topicID`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlGraftTopicIDFieldEvent { + field: '$.topicID' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlGraft.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlGraft => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlGraft { return decodeMessage(buf, ControlGraft.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlGraft.codec(), opts) + } } export interface ControlPrune { @@ -554,7 +976,7 @@ export namespace RPC { w.string(obj.topicID) } - if (obj.peers != null) { + if (obj.peers != null && obj.peers.length > 0) { for (const value of obj.peers) { w.uint32(18) RPC.PeerInfo.codec().encode(value, w) @@ -586,7 +1008,7 @@ export namespace RPC { } case 2: { if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) { - throw new MaxLengthError('Decode error - map field "peers" had too many elements') + throw new MaxLengthError('Decode error - repeated field "peers" had too many elements') } obj.peers.push(RPC.PeerInfo.codec().decode(reader, reader.uint32(), { @@ -606,19 +1028,94 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + peers: 0 + } + + 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}.topicID`, + value: reader.string() + } + break + } + case 2: { + if (opts.limits?.peers != null && obj.peers === opts.limits.peers) { + throw new MaxLengthError('Streaming decode error - repeated field "peers" had too many elements') + } + + for (const evt of RPC.PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peers[]`, { + limits: opts.limits?.peers$ + })) { + yield { + ...evt, + index: obj.peers + } + } + + obj.peers++ + + break + } + case 3: { + yield { + field: `${prefix}.backoff`, + value: reader.uint64Number() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlPruneTopicIDFieldEvent { + field: '$.topicID' + value: string + } + + export interface ControlPrunePeersPeerIDFieldEvent { + field: '$.peers[].peerID' + value: Uint8Array + index: number + } + + export interface ControlPrunePeersSignedPeerRecordFieldEvent { + field: '$.peers[].signedPeerRecord' + value: Uint8Array + index: number + } + + export interface ControlPruneBackoffFieldEvent { + field: '$.backoff' + value: number + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlPrune.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlPrune => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlPrune { return decodeMessage(buf, ControlPrune.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlPrune.codec(), opts) + } } export interface PeerInfo { @@ -674,19 +1171,60 @@ export namespace RPC { } 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}.peerID`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.signedPeerRecord`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerInfoPeerIDFieldEvent { + field: '$.peerID' + value: Uint8Array + } + + export interface PeerInfoSignedPeerRecordFieldEvent { + field: '$.signedPeerRecord' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo { return decodeMessage(buf, PeerInfo.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerInfo.codec(), opts) + } } export interface ControlIDontWant { @@ -703,7 +1241,7 @@ export namespace RPC { w.fork() } - if (obj.messageIDs != null) { + if (obj.messageIDs != null && obj.messageIDs.length > 0) { for (const value of obj.messageIDs) { w.uint32(10) w.bytes(value) @@ -726,7 +1264,7 @@ export namespace RPC { switch (tag >>> 3) { case 1: { if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) { - throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements') } obj.messageIDs.push(reader.bytes()) @@ -740,19 +1278,61 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + messageIDs: 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?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements') + } + + yield { + field: `${prefix}.messageIDs[]`, + index: obj.messageIDs, + value: reader.bytes() + } + + obj.messageIDs++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ControlIDontWantMessageIDsFieldEvent { + field: '$.messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ControlIDontWant.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIDontWant => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ControlIDontWant { return decodeMessage(buf, ControlIDontWant.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ControlIDontWant.codec(), opts) + } } let _codec: Codec @@ -764,14 +1344,14 @@ export namespace RPC { w.fork() } - if (obj.subscriptions != null) { + if (obj.subscriptions != null && obj.subscriptions.length > 0) { for (const value of obj.subscriptions) { w.uint32(10) RPC.SubOpts.codec().encode(value, w) } } - if (obj.messages != null) { + if (obj.messages != null && obj.messages.length > 0) { for (const value of obj.messages) { w.uint32(18) RPC.Message.codec().encode(value, w) @@ -800,7 +1380,7 @@ export namespace RPC { switch (tag >>> 3) { case 1: { if (opts.limits?.subscriptions != null && obj.subscriptions.length === opts.limits.subscriptions) { - throw new MaxLengthError('Decode error - map field "subscriptions" had too many elements') + throw new MaxLengthError('Decode error - repeated field "subscriptions" had too many elements') } obj.subscriptions.push(RPC.SubOpts.codec().decode(reader, reader.uint32(), { @@ -810,7 +1390,7 @@ export namespace RPC { } case 2: { if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) { - throw new MaxLengthError('Decode error - map field "messages" had too many elements') + throw new MaxLengthError('Decode error - repeated field "messages" had too many elements') } obj.messages.push(RPC.Message.codec().decode(reader, reader.uint32(), { @@ -832,17 +1412,184 @@ export namespace RPC { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + subscriptions: 0, + messages: 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?.subscriptions != null && obj.subscriptions === opts.limits.subscriptions) { + throw new MaxLengthError('Streaming decode error - repeated field "subscriptions" had too many elements') + } + + for (const evt of RPC.SubOpts.codec().stream(reader, reader.uint32(), `${prefix}.subscriptions[]`, { + limits: opts.limits?.subscriptions$ + })) { + yield { + ...evt, + index: obj.subscriptions + } + } + + obj.subscriptions++ + + break + } + case 2: { + if (opts.limits?.messages != null && obj.messages === opts.limits.messages) { + throw new MaxLengthError('Streaming decode error - repeated field "messages" had too many elements') + } + + for (const evt of RPC.Message.codec().stream(reader, reader.uint32(), `${prefix}.messages[]`, { + limits: opts.limits?.messages$ + })) { + yield { + ...evt, + index: obj.messages + } + } + + obj.messages++ + + break + } + case 3: { + yield * RPC.ControlMessage.codec().stream(reader, reader.uint32(), `${prefix}.control`, { + limits: opts.limits?.control + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface RPCSubscriptionsSubscribeFieldEvent { + field: '$.subscriptions[].subscribe' + value: boolean + index: number + } + + export interface RPCSubscriptionsTopicFieldEvent { + field: '$.subscriptions[].topic' + value: string + index: number + } + + export interface RPCMessagesFromFieldEvent { + field: '$.messages[].from' + value: Uint8Array + index: number + } + + export interface RPCMessagesDataFieldEvent { + field: '$.messages[].data' + value: Uint8Array + index: number + } + + export interface RPCMessagesSeqnoFieldEvent { + field: '$.messages[].seqno' + value: Uint8Array + index: number + } + + export interface RPCMessagesTopicFieldEvent { + field: '$.messages[].topic' + value: string + index: number + } + + export interface RPCMessagesSignatureFieldEvent { + field: '$.messages[].signature' + value: Uint8Array + index: number + } + + export interface RPCMessagesKeyFieldEvent { + field: '$.messages[].key' + value: Uint8Array + index: number + } + + export interface RPCControlIhaveTopicIDFieldEvent { + field: '$.control.ihave[].topicID' + value: string + index: number + } + + export interface RPCControlIhaveMessageIDsFieldEvent { + field: '$.control.ihave[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface RPCControlIwantMessageIDsFieldEvent { + field: '$.control.iwant[].messageIDs[]' + index: number + value: Uint8Array + } + + export interface RPCControlGraftTopicIDFieldEvent { + field: '$.control.graft[].topicID' + value: string + index: number + } + + export interface RPCControlPruneTopicIDFieldEvent { + field: '$.control.prune[].topicID' + value: string + index: number + } + + export interface RPCControlPrunePeersPeerIDFieldEvent { + field: '$.control.prune[].peers[].peerID' + value: Uint8Array + index: number + } + + export interface RPCControlPrunePeersSignedPeerRecordFieldEvent { + field: '$.control.prune[].peers[].signedPeerRecord' + value: Uint8Array + index: number + } + + export interface RPCControlPruneBackoffFieldEvent { + field: '$.control.prune[].backoff' + value: number + index: number + } + + export interface RPCControlIdontwantMessageIDsFieldEvent { + field: '$.control.idontwant[].messageIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, RPC.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): RPC => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): RPC { return decodeMessage(buf, RPC.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, RPC.codec(), opts) + } } diff --git a/packages/interface-compliance-tests/package.json b/packages/interface-compliance-tests/package.json index 1e29c61eca..182f51a306 100644 --- a/packages/interface-compliance-tests/package.json +++ b/packages/interface-compliance-tests/package.json @@ -104,13 +104,13 @@ "p-event": "^7.0.0", "p-retry": "^7.0.0", "p-wait-for": "^6.0.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "race-signal": "^2.0.0", "sinon": "^21.0.0", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, "devDependencies": { - "protons": "^7.7.0" + "protons": "^8.1.1" } } diff --git a/packages/interface-compliance-tests/src/stream-muxer/fixtures/pb/message.ts b/packages/interface-compliance-tests/src/stream-muxer/fixtures/pb/message.ts index d1e17d5973..3977aa1030 100644 --- a/packages/interface-compliance-tests/src/stream-muxer/fixtures/pb/message.ts +++ b/packages/interface-compliance-tests/src/stream-muxer/fixtures/pb/message.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -69,17 +69,70 @@ 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 { + field: `${prefix}.message`, + value: reader.string() + } + break + } + case 2: { + yield { + field: `${prefix}.value`, + value: reader.uint32() + } + break + } + case 3: { + yield { + field: `${prefix}.flag`, + value: reader.bool() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageMessageFieldEvent { + field: '$.message' + value: string + } + + export interface MessageValueFieldEvent { + field: '$.value' + value: number + } + + export interface MessageFlagFieldEvent { + field: '$.flag' + value: boolean + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } } diff --git a/packages/interop/package.json b/packages/interop/package.json index 44d888c7b9..e967f37b24 100644 --- a/packages/interop/package.json +++ b/packages/interop/package.json @@ -52,13 +52,13 @@ "multiformats": "^13.4.0", "p-retry": "^7.0.0", "p-wait-for": "^6.0.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, "devDependencies": { "aegir": "^47.0.22", - "protons": "^7.7.0" + "protons": "^8.1.1" }, "peerDependencies": { "aegir": "^47.0.22" diff --git a/packages/interop/src/relay/pb/index.ts b/packages/interop/src/relay/pb/index.ts index 54298b9425..591f0b7384 100644 --- a/packages/interop/src/relay/pb/index.ts +++ b/packages/interop/src/relay/pb/index.ts @@ -1,5 +1,6 @@ -import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime' -import type { Codec } 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' export interface HopMessage { @@ -66,7 +67,7 @@ export namespace HopMessage { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -75,40 +76,151 @@ export namespace HopMessage { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = HopMessage.Type.codec().decode(reader) break - case 2: - obj.peer = Peer.codec().decode(reader, reader.uint32()) + } + case 2: { + obj.peer = Peer.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peer + }) break - case 3: - obj.reservation = Reservation.codec().decode(reader, reader.uint32()) + } + case 3: { + obj.reservation = Reservation.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.reservation + }) break - case 4: - obj.limit = Limit.codec().decode(reader, reader.uint32()) + } + case 4: { + obj.limit = Limit.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.limit + }) break - case 5: + } + case 5: { obj.status = Status.codec().decode(reader) break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.type`, + value: HopMessage.Type.codec().decode(reader) + } + break + } + case 2: { + yield * Peer.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + case 3: { + yield * Reservation.codec().stream(reader, reader.uint32(), `${prefix}.reservation`, { + limits: opts.limits?.reservation + }) + + break + } + case 4: { + yield * Limit.codec().stream(reader, reader.uint32(), `${prefix}.limit`, { + limits: opts.limits?.limit + }) + + break + } + case 5: { + yield { + field: `${prefix}.status`, + value: Status.codec().decode(reader) + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface HopMessageTypeFieldEvent { + field: '$.type' + value: HopMessage.Type + } + + export interface HopMessagePeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface HopMessagePeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface HopMessageReservationExpireFieldEvent { + field: '$.reservation.expire' + value: bigint + } + + export interface HopMessageReservationAddrsFieldEvent { + field: '$.reservation.addrs[]' + index: number + value: Uint8Array + } + + export interface HopMessageReservationVoucherFieldEvent { + field: '$.reservation.voucher' + value: Uint8Array + } + + export interface HopMessageLimitDurationFieldEvent { + field: '$.limit.duration' + value: number + } + + export interface HopMessageLimitDataFieldEvent { + field: '$.limit.data' + value: bigint + } + + export interface HopMessageStatusFieldEvent { + field: '$.status' + value: Status + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, HopMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): HopMessage => { - return decodeMessage(buf, HopMessage.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): HopMessage { + return decodeMessage(buf, HopMessage.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, HopMessage.codec(), opts) } } @@ -168,7 +280,7 @@ export namespace StopMessage { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -177,37 +289,122 @@ export namespace StopMessage { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = StopMessage.Type.codec().decode(reader) break - case 2: - obj.peer = Peer.codec().decode(reader, reader.uint32()) + } + case 2: { + obj.peer = Peer.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peer + }) break - case 3: - obj.limit = Limit.codec().decode(reader, reader.uint32()) + } + case 3: { + obj.limit = Limit.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.limit + }) break - case 4: + } + case 4: { obj.status = Status.codec().decode(reader) break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.type`, + value: StopMessage.Type.codec().decode(reader) + } + break + } + case 2: { + yield * Peer.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + case 3: { + yield * Limit.codec().stream(reader, reader.uint32(), `${prefix}.limit`, { + limits: opts.limits?.limit + }) + + break + } + case 4: { + yield { + field: `${prefix}.status`, + value: Status.codec().decode(reader) + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface StopMessageTypeFieldEvent { + field: '$.type' + value: StopMessage.Type + } + + export interface StopMessagePeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface StopMessagePeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface StopMessageLimitDurationFieldEvent { + field: '$.limit.duration' + value: number + } + + export interface StopMessageLimitDataFieldEvent { + field: '$.limit.data' + value: bigint + } + + export interface StopMessageStatusFieldEvent { + field: '$.status' + value: Status + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, StopMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): StopMessage => { - return decodeMessage(buf, StopMessage.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): StopMessage { + return decodeMessage(buf, StopMessage.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, StopMessage.codec(), opts) } } @@ -231,7 +428,7 @@ export namespace Peer { w.bytes(obj.id) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -241,9 +438,9 @@ export namespace Peer { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - id: new Uint8Array(0), + id: uint8ArrayAlloc(0), addrs: [] } @@ -253,31 +450,92 @@ export namespace Peer { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.id = reader.bytes() break - case 2: + } + case 2: { + if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) { + throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements') + } + obj.addrs.push(reader.bytes()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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: { + yield { + field: `${prefix}.id`, + value: reader.bytes() + } + break + } + case 2: { + 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 + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface PeerAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Peer.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): Peer => { - return decodeMessage(buf, Peer.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer { + return decodeMessage(buf, Peer.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Peer.codec(), opts) } } @@ -302,7 +560,7 @@ export namespace Reservation { w.uint64(obj.expire) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -317,7 +575,7 @@ export namespace Reservation { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { expire: 0n, addrs: [] @@ -329,34 +587,108 @@ export namespace Reservation { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.expire = reader.uint64() break - case 2: + } + case 2: { + if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) { + throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements') + } + obj.addrs.push(reader.bytes()) break - case 3: + } + case 3: { obj.voucher = reader.bytes() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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: { + yield { + field: `${prefix}.expire`, + value: reader.uint64() + } + break + } + case 2: { + 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 3: { + yield { + field: `${prefix}.voucher`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ReservationExpireFieldEvent { + field: '$.expire' + value: bigint + } + + export interface ReservationAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export interface ReservationVoucherFieldEvent { + field: '$.voucher' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Reservation.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): Reservation => { - return decodeMessage(buf, Reservation.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Reservation { + return decodeMessage(buf, Reservation.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Reservation.codec(), opts) } } @@ -388,7 +720,7 @@ export namespace Limit { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -397,31 +729,75 @@ export namespace Limit { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.duration = reader.uint32() break - case 2: + } + case 2: { obj.data = reader.uint64() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.duration`, + value: reader.uint32() + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.uint64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface LimitDurationFieldEvent { + field: '$.duration' + value: number + } + + export interface LimitDataFieldEvent { + field: '$.data' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Limit.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): Limit => { - return decodeMessage(buf, Limit.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Limit { + return decodeMessage(buf, Limit.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Limit.codec(), opts) } } @@ -454,6 +830,7 @@ export namespace Status { return enumeration(__StatusValues) } } + export interface ReservationVoucher { relay: Uint8Array peer: Uint8Array @@ -488,10 +865,10 @@ export namespace ReservationVoucher { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - relay: new Uint8Array(0), - peer: new Uint8Array(0), + relay: uint8ArrayAlloc(0), + peer: uint8ArrayAlloc(0), expiration: 0n } @@ -501,33 +878,90 @@ export namespace ReservationVoucher { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.relay = reader.bytes() break - case 2: + } + case 2: { obj.peer = reader.bytes() break - case 3: + } + case 3: { obj.expiration = reader.uint64() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.relay`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.peer`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.expiration`, + value: reader.uint64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ReservationVoucherRelayFieldEvent { + field: '$.relay' + value: Uint8Array + } + + export interface ReservationVoucherPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface ReservationVoucherExpirationFieldEvent { + field: '$.expiration' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ReservationVoucher.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): ReservationVoucher => { - return decodeMessage(buf, ReservationVoucher.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ReservationVoucher { + return decodeMessage(buf, ReservationVoucher.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ReservationVoucher.codec(), opts) } } diff --git a/packages/kad-dht/package.json b/packages/kad-dht/package.json index 5c43caaf7c..6815087f1e 100644 --- a/packages/kad-dht/package.json +++ b/packages/kad-dht/package.json @@ -73,7 +73,7 @@ "p-defer": "^4.0.1", "p-event": "^7.0.0", "progress-events": "^1.0.1", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "race-signal": "^2.0.0", "uint8-varint": "^2.0.4", "uint8arraylist": "^2.4.8", @@ -98,7 +98,7 @@ "lodash.random": "^3.2.0", "lodash.range": "^3.2.0", "p-retry": "^7.0.0", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0", "which": "^6.0.0" diff --git a/packages/kad-dht/src/message/dht.ts b/packages/kad-dht/src/message/dht.ts index 734929866b..e66e128789 100644 --- a/packages/kad-dht/src/message/dht.ts +++ b/packages/kad-dht/src/message/dht.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' @@ -86,19 +86,96 @@ export namespace Record { } 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}.key`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.value`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.author`, + value: reader.bytes() + } + break + } + case 4: { + yield { + field: `${prefix}.signature`, + value: reader.bytes() + } + break + } + case 5: { + yield { + field: `${prefix}.timeReceived`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface RecordKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export interface RecordValueFieldEvent { + field: '$.value' + value: Uint8Array + } + + export interface RecordAuthorFieldEvent { + field: '$.author' + value: Uint8Array + } + + export interface RecordSignatureFieldEvent { + field: '$.signature' + value: Uint8Array + } + + export interface RecordTimeReceivedFieldEvent { + field: '$.timeReceived' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Record.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Record => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Record { return decodeMessage(buf, Record.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Record.codec(), opts) + } } export enum MessageType { @@ -124,6 +201,7 @@ export namespace MessageType { return enumeration(__MessageTypeValues) } } + export enum ConnectionType { NOT_CONNECTED = 'NOT_CONNECTED', CONNECTED = 'CONNECTED', @@ -143,6 +221,7 @@ export namespace ConnectionType { return enumeration(__ConnectionTypeValues) } } + export interface PeerInfo { id: Uint8Array multiaddrs: Uint8Array[] @@ -164,7 +243,7 @@ export namespace PeerInfo { w.bytes(obj.id) } - if (obj.multiaddrs != null) { + if (obj.multiaddrs != null && obj.multiaddrs.length > 0) { for (const value of obj.multiaddrs) { w.uint32(18) w.bytes(value) @@ -197,7 +276,7 @@ export namespace PeerInfo { } case 2: { if (opts.limits?.multiaddrs != null && obj.multiaddrs.length === opts.limits.multiaddrs) { - throw new MaxLengthError('Decode error - map field "multiaddrs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "multiaddrs" had too many elements') } obj.multiaddrs.push(reader.bytes()) @@ -215,19 +294,85 @@ export namespace PeerInfo { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + multiaddrs: 0 + } + + 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}.id`, + value: reader.bytes() + } + break + } + case 2: { + if (opts.limits?.multiaddrs != null && obj.multiaddrs === opts.limits.multiaddrs) { + throw new MaxLengthError('Streaming decode error - repeated field "multiaddrs" had too many elements') + } + + yield { + field: `${prefix}.multiaddrs[]`, + index: obj.multiaddrs, + value: reader.bytes() + } + + obj.multiaddrs++ + + break + } + case 3: { + yield { + field: `${prefix}.connection`, + value: ConnectionType.codec().decode(reader) + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerInfoIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface PeerInfoMultiaddrsFieldEvent { + field: '$.multiaddrs[]' + index: number + value: Uint8Array + } + + export interface PeerInfoConnectionFieldEvent { + field: '$.connection' + value: ConnectionType + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo { return decodeMessage(buf, PeerInfo.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerInfo.codec(), opts) + } } export interface Message { @@ -269,14 +414,14 @@ export namespace Message { w.bytes(obj.record) } - if (obj.closer != null) { + if (obj.closer != null && obj.closer.length > 0) { for (const value of obj.closer) { w.uint32(66) PeerInfo.codec().encode(value, w) } } - if (obj.providers != null) { + if (obj.providers != null && obj.providers.length > 0) { for (const value of obj.providers) { w.uint32(74) PeerInfo.codec().encode(value, w) @@ -317,7 +462,7 @@ export namespace Message { } case 8: { if (opts.limits?.closer != null && obj.closer.length === opts.limits.closer) { - throw new MaxLengthError('Decode error - map field "closer" had too many elements') + throw new MaxLengthError('Decode error - repeated field "closer" had too many elements') } obj.closer.push(PeerInfo.codec().decode(reader, reader.uint32(), { @@ -327,7 +472,7 @@ export namespace Message { } case 9: { if (opts.limits?.providers != null && obj.providers.length === opts.limits.providers) { - throw new MaxLengthError('Decode error - map field "providers" had too many elements') + throw new MaxLengthError('Decode error - repeated field "providers" had too many elements') } obj.providers.push(PeerInfo.codec().decode(reader, reader.uint32(), { @@ -343,17 +488,159 @@ export namespace Message { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + closer: 0, + providers: 0 + } + + 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}.type`, + value: MessageType.codec().decode(reader) + } + break + } + case 10: { + yield { + field: `${prefix}.clusterLevel`, + value: reader.int32() + } + break + } + case 2: { + yield { + field: `${prefix}.key`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.record`, + value: reader.bytes() + } + break + } + case 8: { + if (opts.limits?.closer != null && obj.closer === opts.limits.closer) { + throw new MaxLengthError('Streaming decode error - repeated field "closer" had too many elements') + } + + for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.closer[]`, { + limits: opts.limits?.closer$ + })) { + yield { + ...evt, + index: obj.closer + } + } + + obj.closer++ + + break + } + case 9: { + if (opts.limits?.providers != null && obj.providers === opts.limits.providers) { + throw new MaxLengthError('Streaming decode error - repeated field "providers" had too many elements') + } + + for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.providers[]`, { + limits: opts.limits?.providers$ + })) { + yield { + ...evt, + index: obj.providers + } + } + + obj.providers++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageTypeFieldEvent { + field: '$.type' + value: MessageType + } + + export interface MessageClusterLevelFieldEvent { + field: '$.clusterLevel' + value: number + } + + export interface MessageKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export interface MessageRecordFieldEvent { + field: '$.record' + value: Uint8Array + } + + export interface MessageCloserIdFieldEvent { + field: '$.closer[].id' + value: Uint8Array + index: number + } + + export interface MessageCloserMultiaddrsFieldEvent { + field: '$.closer[].multiaddrs[]' + index: number + value: Uint8Array + } + + export interface MessageCloserConnectionFieldEvent { + field: '$.closer[].connection' + value: ConnectionType + index: number + } + + export interface MessageProvidersIdFieldEvent { + field: '$.providers[].id' + value: Uint8Array + index: number + } + + export interface MessageProvidersMultiaddrsFieldEvent { + field: '$.providers[].multiaddrs[]' + index: number + value: Uint8Array + } + + export interface MessageProvidersConnectionFieldEvent { + field: '$.providers[].connection' + value: ConnectionType + index: number + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } } diff --git a/packages/libp2p-daemon-protocol/package.json b/packages/libp2p-daemon-protocol/package.json index 6f7bcc29ab..fe3c0294df 100644 --- a/packages/libp2p-daemon-protocol/package.json +++ b/packages/libp2p-daemon-protocol/package.json @@ -64,11 +64,12 @@ "dependencies": { "@libp2p/interface": "^3.1.0", "any-signal": "^4.1.1", - "protons-runtime": "^5.6.0", - "uint8arraylist": "^2.4.8" + "protons-runtime": "^6.0.1", + "uint8arraylist": "^2.4.8", + "uint8arrays": "^5.1.0" }, "devDependencies": { "aegir": "^47.0.22", - "protons": "^7.7.0" + "protons": "^8.1.1" } } diff --git a/packages/libp2p-daemon-protocol/src/index.ts b/packages/libp2p-daemon-protocol/src/index.ts index 2b073f27f9..82b3820107 100644 --- a/packages/libp2p-daemon-protocol/src/index.ts +++ b/packages/libp2p-daemon-protocol/src/index.ts @@ -1,5 +1,6 @@ -import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime' -import type { Codec } 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' export interface Request { @@ -104,7 +105,7 @@ export namespace Request { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -113,52 +114,297 @@ export namespace Request { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = Request.Type.codec().decode(reader) break - case 2: - obj.connect = ConnectRequest.codec().decode(reader, reader.uint32()) + } + case 2: { + obj.connect = ConnectRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.connect + }) + break + } + case 3: { + obj.streamOpen = StreamOpenRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.streamOpen + }) + break + } + case 4: { + obj.streamHandler = StreamHandlerRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.streamHandler + }) + break + } + case 5: { + obj.dht = DHTRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.dht + }) + break + } + case 6: { + obj.connManager = ConnManagerRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.connManager + }) + break + } + case 7: { + obj.disconnect = DisconnectRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.disconnect + }) + break + } + case 8: { + obj.pubsub = PSRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.pubsub + }) + break + } + case 9: { + obj.peerStore = PeerstoreRequest.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peerStore + }) + break + } + default: { + reader.skipType(tag & 7) break - case 3: - obj.streamOpen = StreamOpenRequest.codec().decode(reader, reader.uint32()) + } + } + } + + 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}.type`, + value: Request.Type.codec().decode(reader) + } break - case 4: - obj.streamHandler = StreamHandlerRequest.codec().decode(reader, reader.uint32()) + } + case 2: { + yield * ConnectRequest.codec().stream(reader, reader.uint32(), `${prefix}.connect`, { + limits: opts.limits?.connect + }) + break - case 5: - obj.dht = DHTRequest.codec().decode(reader, reader.uint32()) + } + case 3: { + yield * StreamOpenRequest.codec().stream(reader, reader.uint32(), `${prefix}.streamOpen`, { + limits: opts.limits?.streamOpen + }) + break - case 6: - obj.connManager = ConnManagerRequest.codec().decode(reader, reader.uint32()) + } + case 4: { + yield * StreamHandlerRequest.codec().stream(reader, reader.uint32(), `${prefix}.streamHandler`, { + limits: opts.limits?.streamHandler + }) + break - case 7: - obj.disconnect = DisconnectRequest.codec().decode(reader, reader.uint32()) + } + case 5: { + yield * DHTRequest.codec().stream(reader, reader.uint32(), `${prefix}.dht`, { + limits: opts.limits?.dht + }) + break - case 8: - obj.pubsub = PSRequest.codec().decode(reader, reader.uint32()) + } + case 6: { + yield * ConnManagerRequest.codec().stream(reader, reader.uint32(), `${prefix}.connManager`, { + limits: opts.limits?.connManager + }) + break - case 9: - obj.peerStore = PeerstoreRequest.codec().decode(reader, reader.uint32()) + } + case 7: { + yield * DisconnectRequest.codec().stream(reader, reader.uint32(), `${prefix}.disconnect`, { + limits: opts.limits?.disconnect + }) + + break + } + case 8: { + yield * PSRequest.codec().stream(reader, reader.uint32(), `${prefix}.pubsub`, { + limits: opts.limits?.pubsub + }) + + break + } + case 9: { + yield * PeerstoreRequest.codec().stream(reader, reader.uint32(), `${prefix}.peerStore`, { + limits: opts.limits?.peerStore + }) + break - default: + } + default: { reader.skipType(tag & 7) break + } } } - - return obj }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface RequestTypeFieldEvent { + field: '$.type' + value: Request.Type + } + + export interface RequestConnectPeerFieldEvent { + field: '$.connect.peer' + value: Uint8Array + } + + export interface RequestConnectAddrsFieldEvent { + field: '$.connect.addrs[]' + index: number + value: Uint8Array + } + + export interface RequestConnectTimeoutFieldEvent { + field: '$.connect.timeout' + value: bigint + } + + export interface RequestStreamOpenPeerFieldEvent { + field: '$.streamOpen.peer' + value: Uint8Array + } + + export interface RequestStreamOpenProtoFieldEvent { + field: '$.streamOpen.proto[]' + index: number + value: string + } + + export interface RequestStreamOpenTimeoutFieldEvent { + field: '$.streamOpen.timeout' + value: bigint + } + + export interface RequestStreamHandlerAddrFieldEvent { + field: '$.streamHandler.addr' + value: Uint8Array + } + + export interface RequestStreamHandlerProtoFieldEvent { + field: '$.streamHandler.proto[]' + index: number + value: string + } + + export interface RequestDhtTypeFieldEvent { + field: '$.dht.type' + value: DHTRequest.Type + } + + export interface RequestDhtPeerFieldEvent { + field: '$.dht.peer' + value: Uint8Array + } + + export interface RequestDhtCidFieldEvent { + field: '$.dht.cid' + value: Uint8Array + } + + export interface RequestDhtKeyFieldEvent { + field: '$.dht.key' + value: Uint8Array + } + + export interface RequestDhtValueFieldEvent { + field: '$.dht.value' + value: Uint8Array + } + + export interface RequestDhtCountFieldEvent { + field: '$.dht.count' + value: number + } + + export interface RequestDhtTimeoutFieldEvent { + field: '$.dht.timeout' + value: bigint + } + + export interface RequestConnManagerTypeFieldEvent { + field: '$.connManager.type' + value: ConnManagerRequest.Type + } + + export interface RequestConnManagerPeerFieldEvent { + field: '$.connManager.peer' + value: Uint8Array + } + + export interface RequestConnManagerTagFieldEvent { + field: '$.connManager.tag' + value: string + } + + export interface RequestConnManagerWeightFieldEvent { + field: '$.connManager.weight' + value: bigint + } + + export interface RequestDisconnectPeerFieldEvent { + field: '$.disconnect.peer' + value: Uint8Array + } + + export interface RequestPubsubTypeFieldEvent { + field: '$.pubsub.type' + value: PSRequest.Type + } + + export interface RequestPubsubTopicFieldEvent { + field: '$.pubsub.topic' + value: string + } + + export interface RequestPubsubDataFieldEvent { + field: '$.pubsub.data' + value: Uint8Array + } + + export interface RequestPeerStoreTypeFieldEvent { + field: '$.peerStore.type' + value: PeerstoreRequest.Type + } + + export interface RequestPeerStoreIdFieldEvent { + field: '$.peerStore.id' + value: Uint8Array + } + + export interface RequestPeerStoreProtosFieldEvent { + field: '$.peerStore.protos[]' + index: number + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Request.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): Request => { - return decodeMessage(buf, Request.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Request { + return decodeMessage(buf, Request.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Request.codec(), opts) } } @@ -224,7 +470,7 @@ export namespace Response { DHTResponse.codec().encode(obj.dht, w) } - if (obj.peers != null) { + if (obj.peers != null && obj.peers.length > 0) { for (const value of obj.peers) { w.uint32(50) PeerInfo.codec().encode(value, w) @@ -244,7 +490,7 @@ export namespace Response { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { peers: [] } @@ -255,49 +501,262 @@ export namespace Response { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = Response.Type.codec().decode(reader) break - case 2: - obj.error = ErrorResponse.codec().decode(reader, reader.uint32()) + } + case 2: { + obj.error = ErrorResponse.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.error + }) + break + } + case 3: { + obj.streamInfo = StreamInfo.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.streamInfo + }) + break + } + case 4: { + obj.identify = IdentifyResponse.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.identify + }) + break + } + case 5: { + obj.dht = DHTResponse.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.dht + }) + break + } + case 6: { + if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) { + throw new MaxLengthError('Decode error - repeated field "peers" had too many elements') + } + + obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peers$ + })) + break + } + case 7: { + obj.pubsub = PSResponse.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.pubsub + }) + break + } + case 8: { + obj.peerStore = PeerstoreResponse.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peerStore + }) + break + } + default: { + reader.skipType(tag & 7) break - case 3: - obj.streamInfo = StreamInfo.codec().decode(reader, reader.uint32()) + } + } + } + + return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + peers: 0 + } + + 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}.type`, + value: Response.Type.codec().decode(reader) + } break - case 4: - obj.identify = IdentifyResponse.codec().decode(reader, reader.uint32()) + } + case 2: { + yield * ErrorResponse.codec().stream(reader, reader.uint32(), `${prefix}.error`, { + limits: opts.limits?.error + }) + break - case 5: - obj.dht = DHTResponse.codec().decode(reader, reader.uint32()) + } + case 3: { + yield * StreamInfo.codec().stream(reader, reader.uint32(), `${prefix}.streamInfo`, { + limits: opts.limits?.streamInfo + }) + + break + } + case 4: { + yield * IdentifyResponse.codec().stream(reader, reader.uint32(), `${prefix}.identify`, { + limits: opts.limits?.identify + }) + break - case 6: - obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32())) + } + case 5: { + yield * DHTResponse.codec().stream(reader, reader.uint32(), `${prefix}.dht`, { + limits: opts.limits?.dht + }) + break - case 7: - obj.pubsub = PSResponse.codec().decode(reader, reader.uint32()) + } + case 6: { + if (opts.limits?.peers != null && obj.peers === opts.limits.peers) { + throw new MaxLengthError('Streaming decode error - repeated field "peers" had too many elements') + } + + for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peers[]`, { + limits: opts.limits?.peers$ + })) { + yield { + ...evt, + index: obj.peers + } + } + + obj.peers++ + break - case 8: - obj.peerStore = PeerstoreResponse.codec().decode(reader, reader.uint32()) + } + case 7: { + yield * PSResponse.codec().stream(reader, reader.uint32(), `${prefix}.pubsub`, { + limits: opts.limits?.pubsub + }) + break - default: + } + case 8: { + yield * PeerstoreResponse.codec().stream(reader, reader.uint32(), `${prefix}.peerStore`, { + limits: opts.limits?.peerStore + }) + + break + } + default: { reader.skipType(tag & 7) break + } } } - - return obj }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ResponseTypeFieldEvent { + field: '$.type' + value: Response.Type + } + + export interface ResponseErrorMsgFieldEvent { + field: '$.error.msg' + value: string + } + + export interface ResponseStreamInfoPeerFieldEvent { + field: '$.streamInfo.peer' + value: Uint8Array + } + + export interface ResponseStreamInfoAddrFieldEvent { + field: '$.streamInfo.addr' + value: Uint8Array + } + + export interface ResponseStreamInfoProtoFieldEvent { + field: '$.streamInfo.proto' + value: string + } + + export interface ResponseIdentifyIdFieldEvent { + field: '$.identify.id' + value: Uint8Array + } + + export interface ResponseIdentifyAddrsFieldEvent { + field: '$.identify.addrs[]' + index: number + value: Uint8Array + } + + export interface ResponseDhtTypeFieldEvent { + field: '$.dht.type' + value: DHTResponse.Type + } + + export interface ResponseDhtPeerIdFieldEvent { + field: '$.dht.peer.id' + value: Uint8Array + } + + export interface ResponseDhtPeerAddrsFieldEvent { + field: '$.dht.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface ResponseDhtValueFieldEvent { + field: '$.dht.value' + value: Uint8Array + } + + export interface ResponsePeersIdFieldEvent { + field: '$.peers[].id' + value: Uint8Array + index: number + } + + export interface ResponsePeersAddrsFieldEvent { + field: '$.peers[].addrs[]' + index: number + value: Uint8Array + } + + export interface ResponsePubsubTopicsFieldEvent { + field: '$.pubsub.topics[]' + index: number + value: string + } + + export interface ResponsePubsubPeerIDsFieldEvent { + field: '$.pubsub.peerIDs[]' + index: number + value: Uint8Array + } + + export interface ResponsePeerStorePeerIdFieldEvent { + field: '$.peerStore.peer.id' + value: Uint8Array + } + + export interface ResponsePeerStorePeerAddrsFieldEvent { + field: '$.peerStore.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface ResponsePeerStoreProtosFieldEvent { + field: '$.peerStore.protos[]' + index: number + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Response.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): Response => { - return decodeMessage(buf, Response.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Response { + return decodeMessage(buf, Response.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Response.codec(), opts) } } @@ -321,7 +780,7 @@ export namespace IdentifyResponse { w.bytes(obj.id) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -331,9 +790,9 @@ export namespace IdentifyResponse { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - id: new Uint8Array(0), + id: uint8ArrayAlloc(0), addrs: [] } @@ -343,31 +802,92 @@ export namespace IdentifyResponse { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.id = reader.bytes() break - case 2: + } + case 2: { + if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) { + throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements') + } + obj.addrs.push(reader.bytes()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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: { + yield { + field: `${prefix}.id`, + value: reader.bytes() + } + break + } + case 2: { + 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 + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface IdentifyResponseIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface IdentifyResponseAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, IdentifyResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): IdentifyResponse => { - return decodeMessage(buf, IdentifyResponse.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): IdentifyResponse { + return decodeMessage(buf, IdentifyResponse.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, IdentifyResponse.codec(), opts) } } @@ -392,7 +912,7 @@ export namespace ConnectRequest { w.bytes(obj.peer) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -407,9 +927,9 @@ export namespace ConnectRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - peer: new Uint8Array(0), + peer: uint8ArrayAlloc(0), addrs: [] } @@ -419,34 +939,108 @@ export namespace ConnectRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.peer = reader.bytes() break - case 2: + } + case 2: { + if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) { + throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements') + } + obj.addrs.push(reader.bytes()) break - case 3: + } + case 3: { obj.timeout = reader.int64() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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: { + yield { + field: `${prefix}.peer`, + value: reader.bytes() + } + break + } + case 2: { + 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 3: { + yield { + field: `${prefix}.timeout`, + value: reader.int64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ConnectRequestPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface ConnectRequestAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export interface ConnectRequestTimeoutFieldEvent { + field: '$.timeout' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ConnectRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): ConnectRequest => { - return decodeMessage(buf, ConnectRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ConnectRequest { + return decodeMessage(buf, ConnectRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ConnectRequest.codec(), opts) } } @@ -471,7 +1065,7 @@ export namespace StreamOpenRequest { w.bytes(obj.peer) } - if (obj.proto != null) { + if (obj.proto != null && obj.proto.length > 0) { for (const value of obj.proto) { w.uint32(18) w.string(value) @@ -486,9 +1080,9 @@ export namespace StreamOpenRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - peer: new Uint8Array(0), + peer: uint8ArrayAlloc(0), proto: [] } @@ -498,34 +1092,108 @@ export namespace StreamOpenRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.peer = reader.bytes() break - case 2: + } + case 2: { + if (opts.limits?.proto != null && obj.proto.length === opts.limits.proto) { + throw new MaxLengthError('Decode error - repeated field "proto" had too many elements') + } + obj.proto.push(reader.string()) break - case 3: + } + case 3: { obj.timeout = reader.int64() break - default: + } + default: { reader.skipType(tag & 7) break + } } } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + proto: 0 + } + + 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}.peer`, + value: reader.bytes() + } + break + } + case 2: { + if (opts.limits?.proto != null && obj.proto === opts.limits.proto) { + throw new MaxLengthError('Streaming decode error - repeated field "proto" had too many elements') + } + + yield { + field: `${prefix}.proto[]`, + index: obj.proto, + value: reader.string() + } + + obj.proto++ + + break + } + case 3: { + yield { + field: `${prefix}.timeout`, + value: reader.int64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface StreamOpenRequestPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface StreamOpenRequestProtoFieldEvent { + field: '$.proto[]' + index: number + value: string + } + + export interface StreamOpenRequestTimeoutFieldEvent { + field: '$.timeout' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, StreamOpenRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): StreamOpenRequest => { - return decodeMessage(buf, StreamOpenRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): StreamOpenRequest { + return decodeMessage(buf, StreamOpenRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, StreamOpenRequest.codec(), opts) } } @@ -549,7 +1217,7 @@ export namespace StreamHandlerRequest { w.bytes(obj.addr) } - if (obj.proto != null) { + if (obj.proto != null && obj.proto.length > 0) { for (const value of obj.proto) { w.uint32(18) w.string(value) @@ -559,9 +1227,9 @@ export namespace StreamHandlerRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - addr: new Uint8Array(0), + addr: uint8ArrayAlloc(0), proto: [] } @@ -571,31 +1239,92 @@ export namespace StreamHandlerRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.addr = reader.bytes() break - case 2: + } + case 2: { + if (opts.limits?.proto != null && obj.proto.length === opts.limits.proto) { + throw new MaxLengthError('Decode error - repeated field "proto" had too many elements') + } + obj.proto.push(reader.string()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + proto: 0 + } + + 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}.addr`, + value: reader.bytes() + } + break + } + case 2: { + if (opts.limits?.proto != null && obj.proto === opts.limits.proto) { + throw new MaxLengthError('Streaming decode error - repeated field "proto" had too many elements') + } + + yield { + field: `${prefix}.proto[]`, + index: obj.proto, + value: reader.string() + } + + obj.proto++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface StreamHandlerRequestAddrFieldEvent { + field: '$.addr' + value: Uint8Array + } + + export interface StreamHandlerRequestProtoFieldEvent { + field: '$.proto[]' + index: number + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, StreamHandlerRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): StreamHandlerRequest => { - return decodeMessage(buf, StreamHandlerRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): StreamHandlerRequest { + return decodeMessage(buf, StreamHandlerRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, StreamHandlerRequest.codec(), opts) } } @@ -621,7 +1350,7 @@ export namespace ErrorResponse { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { msg: '' } @@ -632,28 +1361,59 @@ export namespace ErrorResponse { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.msg = reader.string() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.msg`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ErrorResponseMsgFieldEvent { + field: '$.msg' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ErrorResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): ErrorResponse => { - return decodeMessage(buf, ErrorResponse.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ErrorResponse { + return decodeMessage(buf, ErrorResponse.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ErrorResponse.codec(), opts) } } @@ -691,10 +1451,10 @@ export namespace StreamInfo { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - peer: new Uint8Array(0), - addr: new Uint8Array(0), + peer: uint8ArrayAlloc(0), + addr: uint8ArrayAlloc(0), proto: '' } @@ -704,34 +1464,91 @@ export namespace StreamInfo { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.peer = reader.bytes() break - case 2: + } + case 2: { obj.addr = reader.bytes() break - case 3: + } + case 3: { obj.proto = reader.string() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.peer`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.addr`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.proto`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface StreamInfoPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface StreamInfoAddrFieldEvent { + field: '$.addr' + value: Uint8Array + } + + export interface StreamInfoProtoFieldEvent { + field: '$.proto' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, StreamInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): StreamInfo => { - return decodeMessage(buf, StreamInfo.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): StreamInfo { + return decodeMessage(buf, StreamInfo.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, StreamInfo.codec(), opts) } } @@ -823,7 +1640,7 @@ export namespace DHTRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -832,46 +1649,155 @@ export namespace DHTRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = DHTRequest.Type.codec().decode(reader) break - case 2: + } + case 2: { obj.peer = reader.bytes() break - case 3: + } + case 3: { obj.cid = reader.bytes() break - case 4: + } + case 4: { obj.key = reader.bytes() break - case 5: + } + case 5: { obj.value = reader.bytes() break - case 6: + } + case 6: { obj.count = reader.int32() break - case 7: + } + case 7: { obj.timeout = reader.int64() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.type`, + value: DHTRequest.Type.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.peer`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.cid`, + value: reader.bytes() + } + break + } + case 4: { + yield { + field: `${prefix}.key`, + value: reader.bytes() + } + break + } + case 5: { + yield { + field: `${prefix}.value`, + value: reader.bytes() + } + break + } + case 6: { + yield { + field: `${prefix}.count`, + value: reader.int32() + } + break + } + case 7: { + yield { + field: `${prefix}.timeout`, + value: reader.int64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface DHTRequestTypeFieldEvent { + field: '$.type' + value: DHTRequest.Type + } + + export interface DHTRequestPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface DHTRequestCidFieldEvent { + field: '$.cid' + value: Uint8Array + } + + export interface DHTRequestKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export interface DHTRequestValueFieldEvent { + field: '$.value' + value: Uint8Array + } + + export interface DHTRequestCountFieldEvent { + field: '$.count' + value: number + } + + export interface DHTRequestTimeoutFieldEvent { + field: '$.timeout' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DHTRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): DHTRequest => { - return decodeMessage(buf, DHTRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DHTRequest { + return decodeMessage(buf, DHTRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, DHTRequest.codec(), opts) } } @@ -927,7 +1853,7 @@ export namespace DHTResponse { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -936,34 +1862,99 @@ export namespace DHTResponse { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = DHTResponse.Type.codec().decode(reader) break - case 2: - obj.peer = PeerInfo.codec().decode(reader, reader.uint32()) + } + case 2: { + obj.peer = PeerInfo.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peer + }) break - case 3: + } + case 3: { obj.value = reader.bytes() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.type`, + value: DHTResponse.Type.codec().decode(reader) + } + break + } + case 2: { + yield * PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + case 3: { + yield { + field: `${prefix}.value`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface DHTResponseTypeFieldEvent { + field: '$.type' + value: DHTResponse.Type + } + + export interface DHTResponsePeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface DHTResponsePeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface DHTResponseValueFieldEvent { + field: '$.value' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DHTResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): DHTResponse => { - return decodeMessage(buf, DHTResponse.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DHTResponse { + return decodeMessage(buf, DHTResponse.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, DHTResponse.codec(), opts) } } @@ -987,7 +1978,7 @@ export namespace PeerInfo { w.bytes(obj.id) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -997,9 +1988,9 @@ export namespace PeerInfo { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - id: new Uint8Array(0), + id: uint8ArrayAlloc(0), addrs: [] } @@ -1009,31 +2000,92 @@ export namespace PeerInfo { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.id = reader.bytes() break - case 2: + } + case 2: { + if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) { + throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements') + } + obj.addrs.push(reader.bytes()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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: { + yield { + field: `${prefix}.id`, + value: reader.bytes() + } + break + } + case 2: { + 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 + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerInfoIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface PeerInfoAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): PeerInfo => { - return decodeMessage(buf, PeerInfo.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo { + return decodeMessage(buf, PeerInfo.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerInfo.codec(), opts) } } @@ -1095,7 +2147,7 @@ export namespace ConnManagerRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -1104,37 +2156,107 @@ export namespace ConnManagerRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = ConnManagerRequest.Type.codec().decode(reader) break - case 2: + } + case 2: { obj.peer = reader.bytes() break - case 3: + } + case 3: { obj.tag = reader.string() break - case 4: + } + case 4: { obj.weight = reader.int64() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.type`, + value: ConnManagerRequest.Type.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.peer`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.tag`, + value: reader.string() + } + break + } + case 4: { + yield { + field: `${prefix}.weight`, + value: reader.int64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ConnManagerRequestTypeFieldEvent { + field: '$.type' + value: ConnManagerRequest.Type + } + + export interface ConnManagerRequestPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface ConnManagerRequestTagFieldEvent { + field: '$.tag' + value: string + } + + export interface ConnManagerRequestWeightFieldEvent { + field: '$.weight' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ConnManagerRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): ConnManagerRequest => { - return decodeMessage(buf, ConnManagerRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ConnManagerRequest { + return decodeMessage(buf, ConnManagerRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ConnManagerRequest.codec(), opts) } } @@ -1160,9 +2282,9 @@ export namespace DisconnectRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { - peer: new Uint8Array(0) + peer: uint8ArrayAlloc(0) } const end = length == null ? reader.len : reader.pos + length @@ -1171,28 +2293,59 @@ export namespace DisconnectRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.peer = reader.bytes() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.peer`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface DisconnectRequestPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DisconnectRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): DisconnectRequest => { - return decodeMessage(buf, DisconnectRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DisconnectRequest { + return decodeMessage(buf, DisconnectRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, DisconnectRequest.codec(), opts) } } @@ -1250,7 +2403,7 @@ export namespace PSRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = {} const end = length == null ? reader.len : reader.pos + length @@ -1259,34 +2412,91 @@ export namespace PSRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = PSRequest.Type.codec().decode(reader) break - case 2: + } + case 2: { obj.topic = reader.string() break - case 3: + } + case 3: { obj.data = reader.bytes() break - default: + } + default: { reader.skipType(tag & 7) break + } } } 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}.type`, + value: PSRequest.Type.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.topic`, + value: reader.string() + } + break + } + case 3: { + yield { + field: `${prefix}.data`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PSRequestTypeFieldEvent { + field: '$.type' + value: PSRequest.Type + } + + export interface PSRequestTopicFieldEvent { + field: '$.topic' + value: string + } + + export interface PSRequestDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PSRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): PSRequest => { - return decodeMessage(buf, PSRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PSRequest { + return decodeMessage(buf, PSRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PSRequest.codec(), opts) } } @@ -1324,7 +2534,7 @@ export namespace PSMessage { w.bytes(obj.seqno) } - if (obj.topicIDs != null) { + if (obj.topicIDs != null && obj.topicIDs.length > 0) { for (const value of obj.topicIDs) { w.uint32(34) w.string(value) @@ -1344,7 +2554,7 @@ export namespace PSMessage { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { topicIDs: [] } @@ -1355,43 +2565,156 @@ export namespace PSMessage { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.from = reader.bytes() break - case 2: + } + case 2: { obj.data = reader.bytes() break - case 3: + } + case 3: { obj.seqno = reader.bytes() break - case 4: + } + case 4: { + if (opts.limits?.topicIDs != null && obj.topicIDs.length === opts.limits.topicIDs) { + throw new MaxLengthError('Decode error - repeated field "topicIDs" had too many elements') + } + obj.topicIDs.push(reader.string()) break - case 5: + } + case 5: { obj.signature = reader.bytes() break - case 6: + } + case 6: { obj.key = reader.bytes() break - default: + } + default: { reader.skipType(tag & 7) break + } } } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + topicIDs: 0 + } + + 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}.from`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.seqno`, + value: reader.bytes() + } + break + } + case 4: { + if (opts.limits?.topicIDs != null && obj.topicIDs === opts.limits.topicIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "topicIDs" had too many elements') + } + + yield { + field: `${prefix}.topicIDs[]`, + index: obj.topicIDs, + value: reader.string() + } + + obj.topicIDs++ + + break + } + case 5: { + yield { + field: `${prefix}.signature`, + value: reader.bytes() + } + break + } + case 6: { + yield { + field: `${prefix}.key`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PSMessageFromFieldEvent { + field: '$.from' + value: Uint8Array + } + + export interface PSMessageDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export interface PSMessageSeqnoFieldEvent { + field: '$.seqno' + value: Uint8Array + } + + export interface PSMessageTopicIDsFieldEvent { + field: '$.topicIDs[]' + index: number + value: string + } + + export interface PSMessageSignatureFieldEvent { + field: '$.signature' + value: Uint8Array + } + + export interface PSMessageKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PSMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): PSMessage => { - return decodeMessage(buf, PSMessage.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PSMessage { + return decodeMessage(buf, PSMessage.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PSMessage.codec(), opts) } } @@ -1410,14 +2733,14 @@ export namespace PSResponse { w.fork() } - if (obj.topics != null) { + if (obj.topics != null && obj.topics.length > 0) { for (const value of obj.topics) { w.uint32(10) w.string(value) } } - if (obj.peerIDs != null) { + if (obj.peerIDs != null && obj.peerIDs.length > 0) { for (const value of obj.peerIDs) { w.uint32(18) w.bytes(value) @@ -1427,7 +2750,7 @@ export namespace PSResponse { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { topics: [], peerIDs: [] @@ -1439,31 +2762,106 @@ export namespace PSResponse { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { + if (opts.limits?.topics != null && obj.topics.length === opts.limits.topics) { + throw new MaxLengthError('Decode error - repeated field "topics" had too many elements') + } + obj.topics.push(reader.string()) break - case 2: + } + case 2: { + if (opts.limits?.peerIDs != null && obj.peerIDs.length === opts.limits.peerIDs) { + throw new MaxLengthError('Decode error - repeated field "peerIDs" had too many elements') + } + obj.peerIDs.push(reader.bytes()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + topics: 0, + peerIDs: 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?.topics != null && obj.topics === opts.limits.topics) { + throw new MaxLengthError('Streaming decode error - repeated field "topics" had too many elements') + } + + yield { + field: `${prefix}.topics[]`, + index: obj.topics, + value: reader.string() + } + + obj.topics++ + + break + } + case 2: { + if (opts.limits?.peerIDs != null && obj.peerIDs === opts.limits.peerIDs) { + throw new MaxLengthError('Streaming decode error - repeated field "peerIDs" had too many elements') + } + + yield { + field: `${prefix}.peerIDs[]`, + index: obj.peerIDs, + value: reader.bytes() + } + + obj.peerIDs++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PSResponseTopicsFieldEvent { + field: '$.topics[]' + index: number + value: string + } + + export interface PSResponsePeerIDsFieldEvent { + field: '$.peerIDs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PSResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): PSResponse => { - return decodeMessage(buf, PSResponse.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PSResponse { + return decodeMessage(buf, PSResponse.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PSResponse.codec(), opts) } } @@ -1511,7 +2909,7 @@ export namespace PeerstoreRequest { w.bytes(obj.id) } - if (obj.protos != null) { + if (obj.protos != null && obj.protos.length > 0) { for (const value of obj.protos) { w.uint32(26) w.string(value) @@ -1521,7 +2919,7 @@ export namespace PeerstoreRequest { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { protos: [] } @@ -1532,34 +2930,108 @@ export namespace PeerstoreRequest { const tag = reader.uint32() switch (tag >>> 3) { - case 1: + case 1: { obj.type = PeerstoreRequest.Type.codec().decode(reader) break - case 2: + } + case 2: { obj.id = reader.bytes() break - case 3: + } + case 3: { + if (opts.limits?.protos != null && obj.protos.length === opts.limits.protos) { + throw new MaxLengthError('Decode error - repeated field "protos" had too many elements') + } + obj.protos.push(reader.string()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + protos: 0 + } + + 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}.type`, + value: PeerstoreRequest.Type.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.id`, + value: reader.bytes() + } + break + } + case 3: { + if (opts.limits?.protos != null && obj.protos === opts.limits.protos) { + throw new MaxLengthError('Streaming decode error - repeated field "protos" had too many elements') + } + + yield { + field: `${prefix}.protos[]`, + index: obj.protos, + value: reader.string() + } + + obj.protos++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerstoreRequestTypeFieldEvent { + field: '$.type' + value: PeerstoreRequest.Type + } + + export interface PeerstoreRequestIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface PeerstoreRequestProtosFieldEvent { + field: '$.protos[]' + index: number + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerstoreRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): PeerstoreRequest => { - return decodeMessage(buf, PeerstoreRequest.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerstoreRequest { + return decodeMessage(buf, PeerstoreRequest.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerstoreRequest.codec(), opts) } } @@ -1583,7 +3055,7 @@ export namespace PeerstoreResponse { PeerInfo.codec().encode(obj.peer, w) } - if (obj.protos != null) { + if (obj.protos != null && obj.protos.length > 0) { for (const value of obj.protos) { w.uint32(18) w.string(value) @@ -1593,7 +3065,7 @@ export namespace PeerstoreResponse { if (opts.lengthDelimited !== false) { w.ldelim() } - }, (reader, length) => { + }, (reader, length, opts = {}) => { const obj: any = { protos: [] } @@ -1604,30 +3076,99 @@ export namespace PeerstoreResponse { const tag = reader.uint32() switch (tag >>> 3) { - case 1: - obj.peer = PeerInfo.codec().decode(reader, reader.uint32()) + case 1: { + obj.peer = PeerInfo.codec().decode(reader, reader.uint32(), { + limits: opts.limits?.peer + }) break - case 2: + } + case 2: { + if (opts.limits?.protos != null && obj.protos.length === opts.limits.protos) { + throw new MaxLengthError('Decode error - repeated field "protos" had too many elements') + } + obj.protos.push(reader.string()) break - default: + } + default: { reader.skipType(tag & 7) break + } } } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + protos: 0 + } + + const end = length == null ? reader.len : reader.pos + length + + while (reader.pos < end) { + const tag = reader.uint32() + + switch (tag >>> 3) { + case 1: { + yield * PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + case 2: { + if (opts.limits?.protos != null && obj.protos === opts.limits.protos) { + throw new MaxLengthError('Streaming decode error - repeated field "protos" had too many elements') + } + + yield { + field: `${prefix}.protos[]`, + index: obj.protos, + value: reader.string() + } + + obj.protos++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerstoreResponsePeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface PeerstoreResponsePeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface PeerstoreResponseProtosFieldEvent { + field: '$.protos[]' + index: number + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerstoreResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList): PeerstoreResponse => { - return decodeMessage(buf, PeerstoreResponse.codec()) + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerstoreResponse { + return decodeMessage(buf, PeerstoreResponse.codec(), opts) + } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerstoreResponse.codec(), opts) } } diff --git a/packages/peer-record/package.json b/packages/peer-record/package.json index 7a6ec44a86..a2bcddff10 100644 --- a/packages/peer-record/package.json +++ b/packages/peer-record/package.json @@ -53,14 +53,14 @@ "@libp2p/peer-id": "^6.0.4", "@multiformats/multiaddr": "^13.0.1", "multiformats": "^13.4.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8-varint": "^2.0.4", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, "devDependencies": { "aegir": "^47.0.22", - "protons": "^7.7.0" + "protons": "^8.1.1" }, "sideEffects": false } diff --git a/packages/peer-record/src/envelope/envelope.ts b/packages/peer-record/src/envelope/envelope.ts index 100a945d93..74ea27c66b 100644 --- a/packages/peer-record/src/envelope/envelope.ts +++ b/packages/peer-record/src/envelope/envelope.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, message, streamMessage } from 'protons-runtime' import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -81,17 +81,82 @@ export namespace Envelope { } 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}.publicKey`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.payloadType`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.payload`, + value: reader.bytes() + } + break + } + case 5: { + yield { + field: `${prefix}.signature`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface EnvelopePublicKeyFieldEvent { + field: '$.publicKey' + value: Uint8Array + } + + export interface EnvelopePayloadTypeFieldEvent { + field: '$.payloadType' + value: Uint8Array + } + + export interface EnvelopePayloadFieldEvent { + field: '$.payload' + value: Uint8Array + } + + export interface EnvelopeSignatureFieldEvent { + field: '$.signature' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Envelope.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Envelope => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Envelope { return decodeMessage(buf, Envelope.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Envelope.codec(), opts) + } } diff --git a/packages/peer-record/src/peer-record/peer-record.ts b/packages/peer-record/src/peer-record/peer-record.ts index a607de9658..9306ea7de4 100644 --- a/packages/peer-record/src/peer-record/peer-record.ts +++ b/packages/peer-record/src/peer-record/peer-record.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, MaxLengthError, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, 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' @@ -55,19 +55,48 @@ export namespace PeerRecord { } 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}.multiaddr`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface AddressInfoMultiaddrFieldEvent { + field: '$.multiaddr' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, AddressInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): AddressInfo => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): AddressInfo { return decodeMessage(buf, AddressInfo.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, AddressInfo.codec(), opts) + } } let _codec: Codec @@ -89,7 +118,7 @@ export namespace PeerRecord { w.uint64(obj.seq) } - if (obj.addresses != null) { + if (obj.addresses != null && obj.addresses.length > 0) { for (const value of obj.addresses) { w.uint32(26) PeerRecord.AddressInfo.codec().encode(value, w) @@ -122,7 +151,7 @@ export namespace PeerRecord { } case 3: { if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) { - throw new MaxLengthError('Decode error - map field "addresses" had too many elements') + throw new MaxLengthError('Decode error - repeated field "addresses" had too many elements') } obj.addresses.push(PeerRecord.AddressInfo.codec().decode(reader, reader.uint32(), { @@ -138,17 +167,86 @@ export namespace PeerRecord { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + addresses: 0 + } + + 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}.peerId`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.seq`, + value: reader.uint64() + } + break + } + case 3: { + if (opts.limits?.addresses != null && obj.addresses === opts.limits.addresses) { + throw new MaxLengthError('Streaming decode error - repeated field "addresses" had too many elements') + } + + for (const evt of PeerRecord.AddressInfo.codec().stream(reader, reader.uint32(), `${prefix}.addresses[]`, { + limits: opts.limits?.addresses$ + })) { + yield { + ...evt, + index: obj.addresses + } + } + + obj.addresses++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerRecordPeerIdFieldEvent { + field: '$.peerId' + value: Uint8Array + } + + export interface PeerRecordSeqFieldEvent { + field: '$.seq' + value: bigint + } + + export interface PeerRecordAddressesMultiaddrFieldEvent { + field: '$.addresses[].multiaddr' + value: Uint8Array + index: number + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerRecord.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerRecord => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerRecord { return decodeMessage(buf, PeerRecord.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerRecord.codec(), opts) + } } diff --git a/packages/peer-store/package.json b/packages/peer-store/package.json index bdab8ba0e9..a4cc07c0fa 100644 --- a/packages/peer-store/package.json +++ b/packages/peer-store/package.json @@ -59,7 +59,7 @@ "main-event": "^1.0.1", "mortice": "^3.3.1", "multiformats": "^13.4.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -72,7 +72,7 @@ "delay": "^7.0.0", "p-defer": "^4.0.1", "p-event": "^7.0.0", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0" }, "sideEffects": false diff --git a/packages/peer-store/src/pb/peer.ts b/packages/peer-store/src/pb/peer.ts index 275ed55c3f..25e0b1ea98 100644 --- a/packages/peer-store/src/pb/peer.ts +++ b/packages/peer-store/src/pb/peer.ts @@ -1,6 +1,4 @@ -/* eslint-disable complexity */ - -import { decodeMessage, encodeMessage, MaxLengthError, MaxSizeError, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, MaxLengthError, MaxSizeError, message, streamMessage } from 'protons-runtime' import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -72,19 +70,60 @@ export namespace Peer { } 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}.key`, + value: reader.string() + } + break + } + case 2: { + yield { + field: `${prefix}.value`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface Peer$metadataEntryKeyFieldEvent { + field: '$.key' + value: string + } + + export interface Peer$metadataEntryValueFieldEvent { + field: '$.value' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Peer$metadataEntry.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer$metadataEntry => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer$metadataEntry { return decodeMessage(buf, Peer$metadataEntry.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Peer$metadataEntry.codec(), opts) + } } export interface Peer$tagsEntry { @@ -144,19 +183,65 @@ export namespace Peer { } 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}.key`, + value: reader.string() + } + break + } + case 2: { + yield * Tag.codec().stream(reader, reader.uint32(), `${prefix}.value`, { + limits: opts.limits?.value + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface Peer$tagsEntryKeyFieldEvent { + field: '$.key' + value: string + } + + export interface Peer$tagsEntryValueValueFieldEvent { + field: '$.value.value' + value: number + } + + export interface Peer$tagsEntryValueExpiryFieldEvent { + field: '$.value.expiry' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Peer$tagsEntry.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer$tagsEntry => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer$tagsEntry { return decodeMessage(buf, Peer$tagsEntry.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Peer$tagsEntry.codec(), opts) + } } let _codec: Codec @@ -168,14 +253,14 @@ export namespace Peer { w.fork() } - if (obj.addresses != null) { + if (obj.addresses != null && obj.addresses.length > 0) { for (const value of obj.addresses) { w.uint32(10) Address.codec().encode(value, w) } } - if (obj.protocols != null) { + if (obj.protocols != null && obj.protocols.length > 0) { for (const value of obj.protocols) { w.uint32(18) w.string(value) @@ -192,14 +277,14 @@ export namespace Peer { w.bytes(obj.peerRecordEnvelope) } - if (obj.metadata != null && obj.metadata.size !== 0) { + if (obj.metadata != null && obj.metadata.size > 0) { for (const [key, value] of obj.metadata.entries()) { w.uint32(50) Peer.Peer$metadataEntry.codec().encode({ key, value }, w) } } - if (obj.tags != null && obj.tags.size !== 0) { + if (obj.tags != null && obj.tags.size > 0) { for (const [key, value] of obj.tags.entries()) { w.uint32(58) Peer.Peer$tagsEntry.codec().encode({ key, value }, w) @@ -219,7 +304,7 @@ export namespace Peer { addresses: [], protocols: [], metadata: new Map(), - tags: new Map() + tags: new Map() } const end = length == null ? reader.len : reader.pos + length @@ -230,7 +315,7 @@ export namespace Peer { switch (tag >>> 3) { case 1: { if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) { - throw new MaxLengthError('Decode error - map field "addresses" had too many elements') + throw new MaxLengthError('Decode error - repeated field "addresses" had too many elements') } obj.addresses.push(Address.codec().decode(reader, reader.uint32(), { @@ -240,7 +325,7 @@ export namespace Peer { } case 2: { if (opts.limits?.protocols != null && obj.protocols.length === opts.limits.protocols) { - throw new MaxLengthError('Decode error - map field "protocols" had too many elements') + throw new MaxLengthError('Decode error - repeated field "protocols" had too many elements') } obj.protocols.push(reader.string()) @@ -259,7 +344,11 @@ export namespace Peer { throw new MaxSizeError('Decode error - map field "metadata" had too many elements') } - const entry = Peer.Peer$metadataEntry.codec().decode(reader, reader.uint32()) + const entry = Peer.Peer$metadataEntry.codec().decode(reader, reader.uint32(), { + limits: { + value: opts.limits?.metadata$value + } + }) obj.metadata.set(entry.key, entry.value) break } @@ -288,19 +377,184 @@ export namespace Peer { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + addresses: 0, + protocols: 0, + metadata: 0, + tags: 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?.addresses != null && obj.addresses === opts.limits.addresses) { + throw new MaxLengthError('Streaming decode error - repeated field "addresses" had too many elements') + } + + for (const evt of Address.codec().stream(reader, reader.uint32(), `${prefix}.addresses[]`, { + limits: opts.limits?.addresses$ + })) { + yield { + ...evt, + index: obj.addresses + } + } + + obj.addresses++ + + break + } + case 2: { + if (opts.limits?.protocols != null && obj.protocols === opts.limits.protocols) { + throw new MaxLengthError('Streaming decode error - repeated field "protocols" had too many elements') + } + + yield { + field: `${prefix}.protocols[]`, + index: obj.protocols, + value: reader.string() + } + + obj.protocols++ + + break + } + case 4: { + yield { + field: `${prefix}.publicKey`, + value: reader.bytes() + } + break + } + case 5: { + yield { + field: `${prefix}.peerRecordEnvelope`, + value: reader.bytes() + } + break + } + case 6: { + if (opts.limits?.metadata != null && obj.metadata === opts.limits.metadata) { + throw new MaxLengthError('Decode error - map field "metadata" had too many elements') + } + + yield * Peer.Peer$metadataEntry.codec().stream(reader, reader.uint32(), `${prefix}.metadata{}`, { + limits: { + value: opts.limits?.metadata$value + } + }) + + obj.metadata++ + + break + } + case 7: { + if (opts.limits?.tags != null && obj.tags === opts.limits.tags) { + throw new MaxLengthError('Decode error - map field "tags" had too many elements') + } + + yield * Peer.Peer$tagsEntry.codec().stream(reader, reader.uint32(), `${prefix}.tags{}`, { + limits: { + value: opts.limits?.tags$value + } + }) + + obj.tags++ + + break + } + case 8: { + yield { + field: `${prefix}.updated`, + value: reader.uint64Number() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerAddressesMultiaddrFieldEvent { + field: '$.addresses[].multiaddr' + value: Uint8Array + index: number + } + + export interface PeerAddressesIsCertifiedFieldEvent { + field: '$.addresses[].isCertified' + value: boolean + index: number + } + + export interface PeerAddressesObservedFieldEvent { + field: '$.addresses[].observed' + value: number + index: number + } + + export interface PeerProtocolsFieldEvent { + field: '$.protocols[]' + index: number + value: string + } + + export interface PeerPublicKeyFieldEvent { + field: '$.publicKey' + value: Uint8Array + } + + export interface PeerPeerRecordEnvelopeFieldEvent { + field: '$.peerRecordEnvelope' + value: Uint8Array + } + + export interface PeerMetadataFieldEvent { + field: '$.metadata{}' + key: string + value: Uint8Array + } + + export interface PeerTagsValueFieldEvent { + field: '$.tags{}.value' + value: Tag + key: string + } + + export interface PeerTagsExpiryFieldEvent { + field: '$.tags{}.expiry' + value: Tag + key: string + } + + export interface PeerUpdatedFieldEvent { + field: '$.updated' + value: number + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Peer.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer { return decodeMessage(buf, Peer.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Peer.codec(), opts) + } } export interface Address { @@ -368,19 +622,72 @@ export namespace Address { } 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}.multiaddr`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.isCertified`, + value: reader.bool() + } + break + } + case 3: { + yield { + field: `${prefix}.observed`, + value: reader.uint64Number() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial
): Uint8Array => { + export interface AddressMultiaddrFieldEvent { + field: '$.multiaddr' + value: Uint8Array + } + + export interface AddressIsCertifiedFieldEvent { + field: '$.isCertified' + value: boolean + } + + export interface AddressObservedFieldEvent { + field: '$.observed' + value: number + } + + export function encode (obj: Partial
): Uint8Array { return encodeMessage(obj, Address.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions
): Address => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions
): Address { return decodeMessage(buf, Address.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions
): Generator { + return streamMessage(buf, Address.codec(), opts) + } } export interface Tag { @@ -438,17 +745,58 @@ export namespace Tag { } 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}.value`, + value: reader.uint32() + } + break + } + case 2: { + yield { + field: `${prefix}.expiry`, + value: reader.uint64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface TagValueFieldEvent { + field: '$.value' + value: number + } + + export interface TagExpiryFieldEvent { + field: '$.expiry' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Tag.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Tag => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Tag { return decodeMessage(buf, Tag.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Tag.codec(), opts) + } } diff --git a/packages/protocol-autonat-v2/package.json b/packages/protocol-autonat-v2/package.json index c94e5e2e15..469ba7647f 100644 --- a/packages/protocol-autonat-v2/package.json +++ b/packages/protocol-autonat-v2/package.json @@ -52,7 +52,7 @@ "@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" }, @@ -66,7 +66,7 @@ "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" }, diff --git a/packages/protocol-autonat-v2/src/pb/index.ts b/packages/protocol-autonat-v2/src/pb/index.ts index 2a214f0541..1b1a4ebf32 100644 --- a/packages/protocol-autonat-v2/src/pb/index.ts +++ b/packages/protocol-autonat-v2/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): 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): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + 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): Uint8Array => { + export interface DialRequestAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export interface DialRequestNonceFieldEvent { + field: '$.nonce' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DialRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialRequest => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialRequest { return decodeMessage(buf, DialRequest.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + 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): Uint8Array => { + export interface DialDataRequestAddrIdxFieldEvent { + field: '$.addrIdx' + value: number + } + + export interface DialDataRequestNumBytesFieldEvent { + field: '$.numBytes' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DialDataRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialDataRequest => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialDataRequest { return decodeMessage(buf, DialDataRequest.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + 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): 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): Uint8Array { return encodeMessage(obj, DialResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialResponse => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialResponse { return decodeMessage(buf, DialResponse.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + 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): Uint8Array => { + export interface DialDataResponseDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DialDataResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialDataResponse => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialDataResponse { return decodeMessage(buf, DialDataResponse.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + 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): Uint8Array => { + export interface DialBackNonceFieldEvent { + field: '$.nonce' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DialBack.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialBack => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialBack { return decodeMessage(buf, DialBack.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + 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): Uint8Array => { + export interface DialBackResponseStatusFieldEvent { + field: '$.status' + value: DialBackResponse.DialBackStatus + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DialBackResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialBackResponse => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialBackResponse { return decodeMessage(buf, DialBackResponse.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, DialBackResponse.codec(), opts) + } } diff --git a/packages/protocol-autonat/package.json b/packages/protocol-autonat/package.json index ae4ca0f6fe..60e2946a09 100644 --- a/packages/protocol-autonat/package.json +++ b/packages/protocol-autonat/package.json @@ -54,7 +54,7 @@ "any-signal": "^4.1.1", "main-event": "^1.0.1", "multiformats": "^13.4.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8" }, "devDependencies": { @@ -66,7 +66,7 @@ "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" }, diff --git a/packages/protocol-autonat/src/pb/index.ts b/packages/protocol-autonat/src/pb/index.ts index 976cde5949..569cac7c20 100644 --- a/packages/protocol-autonat/src/pb/index.ts +++ b/packages/protocol-autonat/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 type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -67,7 +67,7 @@ export namespace Message { w.bytes(obj.id) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -94,7 +94,7 @@ export namespace Message { } case 2: { 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()) @@ -108,19 +108,73 @@ export namespace Message { } 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: { + yield { + field: `${prefix}.id`, + value: reader.bytes() + } + break + } + case 2: { + 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 + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerInfoIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface PeerInfoAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, PeerInfo.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): PeerInfo { return decodeMessage(buf, PeerInfo.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, PeerInfo.codec(), opts) + } } export interface Dial { @@ -168,19 +222,54 @@ 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 * Message.PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface DialPeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface DialPeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Dial.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Dial => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Dial { return decodeMessage(buf, Dial.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Dial.codec(), opts) + } } export interface DialResponse { @@ -246,19 +335,72 @@ 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 { + field: `${prefix}.status`, + value: Message.ResponseStatus.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.statusText`, + value: reader.string() + } + break + } + case 3: { + yield { + field: `${prefix}.addr`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface DialResponseStatusFieldEvent { + field: '$.status' + value: Message.ResponseStatus + } + + export interface DialResponseStatusTextFieldEvent { + field: '$.statusText' + value: string + } + + export interface DialResponseAddrFieldEvent { + field: '$.addr' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, DialResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialResponse => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): DialResponse { return decodeMessage(buf, DialResponse.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, DialResponse.codec(), opts) + } } let _codec: Codec @@ -321,17 +463,86 @@ 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 { + field: `${prefix}.type`, + value: Message.MessageType.codec().decode(reader) + } + break + } + case 2: { + yield * Message.Dial.codec().stream(reader, reader.uint32(), `${prefix}.dial`, { + limits: opts.limits?.dial + }) + + break + } + case 3: { + yield * Message.DialResponse.codec().stream(reader, reader.uint32(), `${prefix}.dialResponse`, { + limits: opts.limits?.dialResponse + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageTypeFieldEvent { + field: '$.type' + value: Message.MessageType + } + + export interface MessageDialPeerIdFieldEvent { + field: '$.dial.peer.id' + value: Uint8Array + } + + export interface MessageDialPeerAddrsFieldEvent { + field: '$.dial.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface MessageDialResponseStatusFieldEvent { + field: '$.dialResponse.status' + value: Message.ResponseStatus + } + + export interface MessageDialResponseStatusTextFieldEvent { + field: '$.dialResponse.statusText' + value: string + } + + export interface MessageDialResponseAddrFieldEvent { + field: '$.dialResponse.addr' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } } diff --git a/packages/protocol-dcutr/package.json b/packages/protocol-dcutr/package.json index 7775fdf352..37a64808a2 100644 --- a/packages/protocol-dcutr/package.json +++ b/packages/protocol-dcutr/package.json @@ -51,12 +51,12 @@ "@multiformats/multiaddr": "^13.0.1", "@multiformats/multiaddr-matcher": "^3.0.1", "delay": "^7.0.0", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8" }, "devDependencies": { "aegir": "^47.0.22", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0" }, diff --git a/packages/protocol-dcutr/src/pb/message.ts b/packages/protocol-dcutr/src/pb/message.ts index ca23065517..8aabe58381 100644 --- a/packages/protocol-dcutr/src/pb/message.ts +++ b/packages/protocol-dcutr/src/pb/message.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 type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -40,7 +40,7 @@ export namespace HolePunch { HolePunch.Type.codec().encode(obj.type, w) } - if (obj.observedAddresses != null) { + if (obj.observedAddresses != null && obj.observedAddresses.length > 0) { for (const value of obj.observedAddresses) { w.uint32(18) w.bytes(value) @@ -67,7 +67,7 @@ export namespace HolePunch { } case 2: { if (opts.limits?.observedAddresses != null && obj.observedAddresses.length === opts.limits.observedAddresses) { - throw new MaxLengthError('Decode error - map field "observedAddresses" had too many elements') + throw new MaxLengthError('Decode error - repeated field "observedAddresses" had too many elements') } obj.observedAddresses.push(reader.bytes()) @@ -81,17 +81,71 @@ export namespace HolePunch { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + observedAddresses: 0 + } + + 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}.type`, + value: HolePunch.Type.codec().decode(reader) + } + break + } + case 2: { + if (opts.limits?.observedAddresses != null && obj.observedAddresses === opts.limits.observedAddresses) { + throw new MaxLengthError('Streaming decode error - repeated field "observedAddresses" had too many elements') + } + + yield { + field: `${prefix}.observedAddresses[]`, + index: obj.observedAddresses, + value: reader.bytes() + } + + obj.observedAddresses++ + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface HolePunchTypeFieldEvent { + field: '$.type' + value: HolePunch.Type + } + + export interface HolePunchObservedAddressesFieldEvent { + field: '$.observedAddresses[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, HolePunch.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): HolePunch => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): HolePunch { return decodeMessage(buf, HolePunch.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, HolePunch.codec(), opts) + } } diff --git a/packages/protocol-fetch/package.json b/packages/protocol-fetch/package.json index 5aca2410bc..9a6d6ba64c 100644 --- a/packages/protocol-fetch/package.json +++ b/packages/protocol-fetch/package.json @@ -49,7 +49,7 @@ "@libp2p/interface-internal": "^3.0.13", "@libp2p/utils": "^7.0.13", "main-event": "^1.0.1", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -57,7 +57,7 @@ "@libp2p/crypto": "^5.1.13", "@libp2p/peer-id": "^6.0.4", "aegir": "^47.0.22", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0" }, diff --git a/packages/protocol-fetch/src/pb/proto.ts b/packages/protocol-fetch/src/pb/proto.ts index 901c8d584b..46f071da82 100644 --- a/packages/protocol-fetch/src/pb/proto.ts +++ b/packages/protocol-fetch/src/pb/proto.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime' import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -48,19 +48,48 @@ export namespace FetchRequest { } 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}.identifier`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface FetchRequestIdentifierFieldEvent { + field: '$.identifier' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, FetchRequest.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): FetchRequest => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): FetchRequest { return decodeMessage(buf, FetchRequest.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, FetchRequest.codec(), opts) + } } export interface FetchResponse { @@ -137,17 +166,58 @@ export namespace FetchResponse { } 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: FetchResponse.StatusCode.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface FetchResponseStatusFieldEvent { + field: '$.status' + value: FetchResponse.StatusCode + } + + export interface FetchResponseDataFieldEvent { + field: '$.data' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, FetchResponse.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): FetchResponse => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): FetchResponse { return decodeMessage(buf, FetchResponse.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, FetchResponse.codec(), opts) + } } diff --git a/packages/protocol-identify/package.json b/packages/protocol-identify/package.json index 360db00666..386ff345da 100644 --- a/packages/protocol-identify/package.json +++ b/packages/protocol-identify/package.json @@ -56,7 +56,7 @@ "it-drain": "^3.0.10", "it-parallel": "^3.0.13", "main-event": "^1.0.1", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -65,7 +65,7 @@ "aegir": "^47.0.22", "delay": "^7.0.0", "it-length-prefixed": "^10.0.1", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon-ts": "^2.0.0" }, "sideEffects": false diff --git a/packages/protocol-identify/src/pb/message.ts b/packages/protocol-identify/src/pb/message.ts index 6f34c75ff2..479a09b23f 100644 --- a/packages/protocol-identify/src/pb/message.ts +++ b/packages/protocol-identify/src/pb/message.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, MaxLengthError, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, MaxLengthError, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -37,7 +37,7 @@ export namespace Identify { w.bytes(obj.publicKey) } - if (obj.listenAddrs != null) { + if (obj.listenAddrs != null && obj.listenAddrs.length > 0) { for (const value of obj.listenAddrs) { w.uint32(18) w.bytes(value) @@ -49,7 +49,7 @@ export namespace Identify { w.bytes(obj.observedAddr) } - if (obj.protocols != null) { + if (obj.protocols != null && obj.protocols.length > 0) { for (const value of obj.protocols) { w.uint32(26) w.string(value) @@ -90,7 +90,7 @@ export namespace Identify { } case 2: { if (opts.limits?.listenAddrs != null && obj.listenAddrs.length === opts.limits.listenAddrs) { - throw new MaxLengthError('Decode error - map field "listenAddrs" had too many elements') + throw new MaxLengthError('Decode error - repeated field "listenAddrs" had too many elements') } obj.listenAddrs.push(reader.bytes()) @@ -102,7 +102,7 @@ export namespace Identify { } case 3: { if (opts.limits?.protocols != null && obj.protocols.length === opts.limits.protocols) { - throw new MaxLengthError('Decode error - map field "protocols" had too many elements') + throw new MaxLengthError('Decode error - repeated field "protocols" had too many elements') } obj.protocols.push(reader.string()) @@ -120,17 +120,141 @@ export namespace Identify { } return obj + }, function * (reader, length, prefix, opts = {}) { + const obj = { + listenAddrs: 0, + protocols: 0 + } + + const end = length == null ? reader.len : reader.pos + length + + while (reader.pos < end) { + const tag = reader.uint32() + + switch (tag >>> 3) { + case 5: { + yield { + field: `${prefix}.protocolVersion`, + value: reader.string() + } + break + } + case 6: { + yield { + field: `${prefix}.agentVersion`, + value: reader.string() + } + break + } + case 1: { + yield { + field: `${prefix}.publicKey`, + value: reader.bytes() + } + break + } + case 2: { + if (opts.limits?.listenAddrs != null && obj.listenAddrs === opts.limits.listenAddrs) { + throw new MaxLengthError('Streaming decode error - repeated field "listenAddrs" had too many elements') + } + + yield { + field: `${prefix}.listenAddrs[]`, + index: obj.listenAddrs, + value: reader.bytes() + } + + obj.listenAddrs++ + + break + } + case 4: { + yield { + field: `${prefix}.observedAddr`, + value: reader.bytes() + } + break + } + case 3: { + if (opts.limits?.protocols != null && obj.protocols === opts.limits.protocols) { + throw new MaxLengthError('Streaming decode error - repeated field "protocols" had too many elements') + } + + yield { + field: `${prefix}.protocols[]`, + index: obj.protocols, + value: reader.string() + } + + obj.protocols++ + + break + } + case 8: { + yield { + field: `${prefix}.signedPeerRecord`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface IdentifyProtocolVersionFieldEvent { + field: '$.protocolVersion' + value: string + } + + export interface IdentifyAgentVersionFieldEvent { + field: '$.agentVersion' + value: string + } + + export interface IdentifyPublicKeyFieldEvent { + field: '$.publicKey' + value: Uint8Array + } + + export interface IdentifyListenAddrsFieldEvent { + field: '$.listenAddrs[]' + index: number + value: Uint8Array + } + + export interface IdentifyObservedAddrFieldEvent { + field: '$.observedAddr' + value: Uint8Array + } + + export interface IdentifyProtocolsFieldEvent { + field: '$.protocols[]' + index: number + value: string + } + + export interface IdentifySignedPeerRecordFieldEvent { + field: '$.signedPeerRecord' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Identify.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Identify => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Identify { return decodeMessage(buf, Identify.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Identify.codec(), opts) + } } diff --git a/packages/record/package.json b/packages/record/package.json index 5603ee39e8..01fef4f8d8 100644 --- a/packages/record/package.json +++ b/packages/record/package.json @@ -47,7 +47,7 @@ "doc-check": "aegir doc-check" }, "dependencies": { - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" }, @@ -57,7 +57,7 @@ "@types/which": "^3.0.4", "aegir": "^47.0.22", "multiformats": "^13.4.0", - "protons": "^7.7.0" + "protons": "^8.1.1" }, "sideEffects": false } diff --git a/packages/record/src/record.ts b/packages/record/src/record.ts index f60f866968..aa769c4ab8 100644 --- a/packages/record/src/record.ts +++ b/packages/record/src/record.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, message, streamMessage } from 'protons-runtime' import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -70,17 +70,70 @@ export namespace Record { } 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}.key`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.value`, + value: reader.bytes() + } + break + } + case 5: { + yield { + field: `${prefix}.timeReceived`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface RecordKeyFieldEvent { + field: '$.key' + value: Uint8Array + } + + export interface RecordValueFieldEvent { + field: '$.value' + value: Uint8Array + } + + export interface RecordTimeReceivedFieldEvent { + field: '$.timeReceived' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Record.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Record => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Record { return decodeMessage(buf, Record.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Record.codec(), opts) + } } diff --git a/packages/transport-circuit-relay-v2/package.json b/packages/transport-circuit-relay-v2/package.json index aea4460e25..83c3765544 100644 --- a/packages/transport-circuit-relay-v2/package.json +++ b/packages/transport-circuit-relay-v2/package.json @@ -59,7 +59,7 @@ "multiformats": "^13.4.0", "nanoid": "^5.1.5", "progress-events": "^1.0.1", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "retimeable-signal": "^1.0.1", "uint8arraylist": "^2.4.8", "uint8arrays": "^5.1.0" @@ -72,7 +72,7 @@ "it-protobuf-stream": "^2.0.3", "p-event": "^7.0.0", "p-wait-for": "^6.0.0", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0" }, diff --git a/packages/transport-circuit-relay-v2/src/pb/index.ts b/packages/transport-circuit-relay-v2/src/pb/index.ts index cbd430b633..0c9258a7bb 100644 --- a/packages/transport-circuit-relay-v2/src/pb/index.ts +++ b/packages/transport-circuit-relay-v2/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' @@ -110,19 +110,143 @@ export namespace HopMessage { } 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}.type`, + value: HopMessage.Type.codec().decode(reader) + } + break + } + case 2: { + yield * Peer.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + case 3: { + yield * Reservation.codec().stream(reader, reader.uint32(), `${prefix}.reservation`, { + limits: opts.limits?.reservation + }) + + break + } + case 4: { + yield * Limit.codec().stream(reader, reader.uint32(), `${prefix}.limit`, { + limits: opts.limits?.limit + }) + + break + } + case 5: { + yield { + field: `${prefix}.status`, + value: Status.codec().decode(reader) + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface HopMessageTypeFieldEvent { + field: '$.type' + value: HopMessage.Type + } + + export interface HopMessagePeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface HopMessagePeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface HopMessageReservationExpireFieldEvent { + field: '$.reservation.expire' + value: bigint + } + + export interface HopMessageReservationAddrsFieldEvent { + field: '$.reservation.addrs[]' + index: number + value: Uint8Array + } + + export interface HopMessageReservationVoucherPublicKeyFieldEvent { + field: '$.reservation.voucher.publicKey' + value: Uint8Array + } + + export interface HopMessageReservationVoucherPayloadTypeFieldEvent { + field: '$.reservation.voucher.payloadType' + value: Uint8Array + } + + export interface HopMessageReservationVoucherPayloadRelayFieldEvent { + field: '$.reservation.voucher.payload.relay' + value: Uint8Array + } + + export interface HopMessageReservationVoucherPayloadPeerFieldEvent { + field: '$.reservation.voucher.payload.peer' + value: Uint8Array + } + + export interface HopMessageReservationVoucherPayloadExpirationFieldEvent { + field: '$.reservation.voucher.payload.expiration' + value: bigint + } + + export interface HopMessageReservationVoucherSignatureFieldEvent { + field: '$.reservation.voucher.signature' + value: Uint8Array + } + + export interface HopMessageLimitDurationFieldEvent { + field: '$.limit.duration' + value: number + } + + export interface HopMessageLimitDataFieldEvent { + field: '$.limit.data' + value: bigint + } + + export interface HopMessageStatusFieldEvent { + field: '$.status' + value: Status + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, HopMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): HopMessage => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): HopMessage { return decodeMessage(buf, HopMessage.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, HopMessage.codec(), opts) + } } export interface StopMessage { @@ -218,19 +342,95 @@ export namespace StopMessage { } 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}.type`, + value: StopMessage.Type.codec().decode(reader) + } + break + } + case 2: { + yield * Peer.codec().stream(reader, reader.uint32(), `${prefix}.peer`, { + limits: opts.limits?.peer + }) + + break + } + case 3: { + yield * Limit.codec().stream(reader, reader.uint32(), `${prefix}.limit`, { + limits: opts.limits?.limit + }) + + break + } + case 4: { + yield { + field: `${prefix}.status`, + value: Status.codec().decode(reader) + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface StopMessageTypeFieldEvent { + field: '$.type' + value: StopMessage.Type + } + + export interface StopMessagePeerIdFieldEvent { + field: '$.peer.id' + value: Uint8Array + } + + export interface StopMessagePeerAddrsFieldEvent { + field: '$.peer.addrs[]' + index: number + value: Uint8Array + } + + export interface StopMessageLimitDurationFieldEvent { + field: '$.limit.duration' + value: number + } + + export interface StopMessageLimitDataFieldEvent { + field: '$.limit.data' + value: bigint + } + + export interface StopMessageStatusFieldEvent { + field: '$.status' + value: Status + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, StopMessage.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): StopMessage => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): StopMessage { return decodeMessage(buf, StopMessage.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, StopMessage.codec(), opts) + } } export interface Peer { @@ -253,7 +453,7 @@ export namespace Peer { w.bytes(obj.id) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -281,7 +481,7 @@ export namespace Peer { } case 2: { 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()) @@ -295,19 +495,73 @@ export namespace Peer { } 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: { + yield { + field: `${prefix}.id`, + value: reader.bytes() + } + break + } + case 2: { + 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 + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface PeerIdFieldEvent { + field: '$.id' + value: Uint8Array + } + + export interface PeerAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Peer.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Peer { return decodeMessage(buf, Peer.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Peer.codec(), opts) + } } export interface Reservation { @@ -331,7 +585,7 @@ export namespace Reservation { w.uint64(obj.expire) } - if (obj.addrs != null) { + if (obj.addrs != null && obj.addrs.length > 0) { for (const value of obj.addrs) { w.uint32(18) w.bytes(value) @@ -364,7 +618,7 @@ export namespace Reservation { } case 2: { 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()) @@ -384,19 +638,110 @@ export namespace Reservation { } 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: { + yield { + field: `${prefix}.expire`, + value: reader.uint64() + } + break + } + case 2: { + 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 3: { + yield * Envelope.codec().stream(reader, reader.uint32(), `${prefix}.voucher`, { + limits: opts.limits?.voucher + }) + + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ReservationExpireFieldEvent { + field: '$.expire' + value: bigint + } + + export interface ReservationAddrsFieldEvent { + field: '$.addrs[]' + index: number + value: Uint8Array + } + + export interface ReservationVoucherPublicKeyFieldEvent { + field: '$.voucher.publicKey' + value: Uint8Array + } + + export interface ReservationVoucherPayloadTypeFieldEvent { + field: '$.voucher.payloadType' + value: Uint8Array + } + + export interface ReservationVoucherPayloadRelayFieldEvent { + field: '$.voucher.payload.relay' + value: Uint8Array + } + + export interface ReservationVoucherPayloadPeerFieldEvent { + field: '$.voucher.payload.peer' + value: Uint8Array + } + + export interface ReservationVoucherPayloadExpirationFieldEvent { + field: '$.voucher.payload.expiration' + value: bigint + } + + export interface ReservationVoucherSignatureFieldEvent { + field: '$.voucher.signature' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Reservation.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Reservation => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Reservation { return decodeMessage(buf, Reservation.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Reservation.codec(), opts) + } } export interface Limit { @@ -452,19 +797,60 @@ export namespace Limit { } 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}.duration`, + value: reader.uint32() + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.uint64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface LimitDurationFieldEvent { + field: '$.duration' + value: number + } + + export interface LimitDataFieldEvent { + field: '$.data' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Limit.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Limit => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Limit { return decodeMessage(buf, Limit.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Limit.codec(), opts) + } } export enum Status { @@ -496,6 +882,7 @@ export namespace Status { return enumeration(__StatusValues) } } + export interface ReservationVoucher { relay: Uint8Array peer: Uint8Array @@ -563,19 +950,72 @@ export namespace ReservationVoucher { } 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}.relay`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.peer`, + value: reader.bytes() + } + break + } + case 3: { + yield { + field: `${prefix}.expiration`, + value: reader.uint64() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface ReservationVoucherRelayFieldEvent { + field: '$.relay' + value: Uint8Array + } + + export interface ReservationVoucherPeerFieldEvent { + field: '$.peer' + value: Uint8Array + } + + export interface ReservationVoucherExpirationFieldEvent { + field: '$.expiration' + value: bigint + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, ReservationVoucher.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ReservationVoucher => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): ReservationVoucher { return decodeMessage(buf, ReservationVoucher.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, ReservationVoucher.codec(), opts) + } } export interface Envelope { @@ -657,17 +1097,92 @@ export namespace Envelope { } 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}.publicKey`, + value: reader.bytes() + } + break + } + case 2: { + yield { + field: `${prefix}.payloadType`, + value: reader.bytes() + } + break + } + case 3: { + yield * ReservationVoucher.codec().stream(reader, reader.uint32(), `${prefix}.payload`, { + limits: opts.limits?.payload + }) + + break + } + case 5: { + yield { + field: `${prefix}.signature`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface EnvelopePublicKeyFieldEvent { + field: '$.publicKey' + value: Uint8Array + } + + export interface EnvelopePayloadTypeFieldEvent { + field: '$.payloadType' + value: Uint8Array + } + + export interface EnvelopePayloadRelayFieldEvent { + field: '$.payload.relay' + value: Uint8Array + } + + export interface EnvelopePayloadPeerFieldEvent { + field: '$.payload.peer' + value: Uint8Array + } + + export interface EnvelopePayloadExpirationFieldEvent { + field: '$.payload.expiration' + value: bigint + } + + export interface EnvelopeSignatureFieldEvent { + field: '$.signature' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Envelope.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Envelope => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Envelope { return decodeMessage(buf, Envelope.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Envelope.codec(), opts) + } } diff --git a/packages/transport-webrtc/package.json b/packages/transport-webrtc/package.json index ce1b4d8ab6..81bee3e7e9 100644 --- a/packages/transport-webrtc/package.json +++ b/packages/transport-webrtc/package.json @@ -30,7 +30,7 @@ } }, "scripts": { - "generate": "protons src/private-to-private/pb/message.proto", + "generate": "protons src/private-to-private/pb/message.proto src/private-to-public/pb/message.proto", "build": "aegir build", "test": "aegir test -t node -t browser", "test:node": "aegir test -t node --cov -- --exit", @@ -71,7 +71,7 @@ "p-timeout": "^7.0.0", "p-wait-for": "^6.0.0", "progress-events": "^1.0.1", - "protons-runtime": "^5.6.0", + "protons-runtime": "^6.0.1", "race-signal": "^2.0.0", "react-native-webrtc": "^124.0.6", "uint8-varint": "^2.0.4", @@ -86,7 +86,7 @@ "datastore-core": "^11.0.1", "delay": "^7.0.0", "p-retry": "^7.0.0", - "protons": "^7.7.0", + "protons": "^8.1.1", "sinon": "^21.0.0", "sinon-ts": "^2.0.0", "wherearewe": "^2.0.1" diff --git a/packages/transport-webrtc/src/private-to-private/pb/message.ts b/packages/transport-webrtc/src/private-to-private/pb/message.ts index eadb1b68fc..9598177a36 100644 --- a/packages/transport-webrtc/src/private-to-private/pb/message.ts +++ b/packages/transport-webrtc/src/private-to-private/pb/message.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -73,17 +73,58 @@ 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 { + field: `${prefix}.type`, + value: Message.Type.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.data`, + value: reader.string() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageTypeFieldEvent { + field: '$.type' + value: Message.Type + } + + export interface MessageDataFieldEvent { + field: '$.data' + value: string + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } } diff --git a/packages/transport-webrtc/src/private-to-public/pb/message.ts b/packages/transport-webrtc/src/private-to-public/pb/message.ts index efa39b50ff..2d92279e8b 100644 --- a/packages/transport-webrtc/src/private-to-public/pb/message.ts +++ b/packages/transport-webrtc/src/private-to-public/pb/message.ts @@ -1,4 +1,4 @@ -import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime' +import { decodeMessage, encodeMessage, enumeration, message, streamMessage } from 'protons-runtime' import type { Codec, DecodeOptions } from 'protons-runtime' import type { Uint8ArrayList } from 'uint8arraylist' @@ -75,17 +75,58 @@ 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 { + field: `${prefix}.flag`, + value: Message.Flag.codec().decode(reader) + } + break + } + case 2: { + yield { + field: `${prefix}.message`, + value: reader.bytes() + } + break + } + default: { + reader.skipType(tag & 7) + break + } + } + } }) } return _codec } - export const encode = (obj: Partial): Uint8Array => { + export interface MessageFlagFieldEvent { + field: '$.flag' + value: Message.Flag + } + + export interface MessageMessageFieldEvent { + field: '$.message' + value: Uint8Array + } + + export function encode (obj: Partial): Uint8Array { return encodeMessage(obj, Message.codec()) } - export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message => { + export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Message { return decodeMessage(buf, Message.codec(), opts) } + + export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions): Generator { + return streamMessage(buf, Message.codec(), opts) + } }