@waku/core 0.0.28-b5e8b17.0 → 0.0.28-efe9b8d.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (28) hide show
  1. package/bundle/{base_protocol-BCwLeb-A.js → base_protocol-D0Zdzb-v.js} +1 -1
  2. package/bundle/{index-vlQahmUj.js → index-BJwgMx4y.js} +32 -61
  3. package/bundle/index.js +111 -250
  4. package/bundle/lib/base_protocol.js +2 -2
  5. package/bundle/lib/message/version_0.js +2 -2
  6. package/bundle/lib/predefined_bootstrap_nodes.js +16 -16
  7. package/bundle/{version_0-DiakMc1A.js → version_0-C6o0DvNW.js} +566 -321
  8. package/dist/.tsbuildinfo +1 -1
  9. package/dist/index.d.ts +2 -1
  10. package/dist/index.js +2 -1
  11. package/dist/index.js.map +1 -1
  12. package/dist/lib/message/version_0.js +1 -1
  13. package/dist/lib/message/version_0.js.map +1 -1
  14. package/dist/lib/predefined_bootstrap_nodes.d.ts +11 -11
  15. package/dist/lib/predefined_bootstrap_nodes.js +16 -16
  16. package/dist/lib/predefined_bootstrap_nodes.js.map +1 -1
  17. package/dist/lib/store/history_rpc.js +1 -1
  18. package/dist/lib/store/history_rpc.js.map +1 -1
  19. package/dist/lib/store/index.d.ts +14 -6
  20. package/dist/lib/store/index.js +50 -232
  21. package/dist/lib/store/index.js.map +1 -1
  22. package/dist/lib/wait_for_remote_peer.js +1 -1
  23. package/dist/lib/wait_for_remote_peer.js.map +1 -1
  24. package/package.json +1 -1
  25. package/src/index.ts +2 -1
  26. package/src/lib/predefined_bootstrap_nodes.ts +22 -22
  27. package/src/lib/store/index.ts +77 -339
  28. package/src/lib/wait_for_remote_peer.ts +1 -1
package/bundle/{version_0-DiakMc1A.js → version_0-C6o0DvNW.js} RENAMED
@@ -1,4 +1,4 @@
1
- import { d as allocUnsafe, i as fromString, L as Logger, j as determinePubsubTopic } from './index-vlQahmUj.js';
1
+ import { a as allocUnsafe, h as fromString, d as alloc$1, L as Logger, i as determinePubsubTopic } from './index-BJwgMx4y.js';
2
2
 
3
3
  /* eslint-disable no-fallthrough */
4
4
  const N1 = Math.pow(2, 7);
@@ -1422,6 +1422,25 @@ function message$1(encode, decode) {
1422
1422
  return createCodec('message', CODEC_TYPES.LENGTH_DELIMITED, encode, decode);
1423
1423
  }
1424
1424
 
1425
+ /**
1426
+ * @packageDocumentation
1427
+ *
1428
+ * This module contains serialization/deserialization code used when encoding/decoding protobufs.
1429
+ *
1430
+ * It should be declared as a dependency of your project:
1431
+ *
1432
+ * ```console
1433
+ * npm i protons-runtime
1434
+ * ```
1435
+ */
1436
+ class CodeError extends Error {
1437
+ code;
1438
+ constructor(message, code, options) {
1439
+ super(message, options);
1440
+ this.code = code;
1441
+ }
1442
+ }
1443
+
1425
1444
  /* eslint-disable import/export */
1426
1445
  /* eslint-disable complexity */
1427
1446
  /* eslint-disable @typescript-eslint/no-namespace */
@@ -1467,44 +1486,52 @@ var RateLimitProof$4;
1467
1486
  if (opts.lengthDelimited !== false) {
1468
1487
  w.ldelim();
1469
1488
  }
1470
- }, (reader, length) => {
1489
+ }, (reader, length, opts = {}) => {
1471
1490
  const obj = {
1472
- proof: new Uint8Array(0),
1473
- merkleRoot: new Uint8Array(0),
1474
- epoch: new Uint8Array(0),
1475
- shareX: new Uint8Array(0),
1476
- shareY: new Uint8Array(0),
1477
- nullifier: new Uint8Array(0),
1478
- rlnIdentifier: new Uint8Array(0)
1491
+ proof: alloc$1(0),
1492
+ merkleRoot: alloc$1(0),
1493
+ epoch: alloc$1(0),
1494
+ shareX: alloc$1(0),
1495
+ shareY: alloc$1(0),
1496
+ nullifier: alloc$1(0),
1497
+ rlnIdentifier: alloc$1(0)
1479
1498
  };
1480
1499
  const end = length == null ? reader.len : reader.pos + length;
1481
1500
  while (reader.pos < end) {
1482
1501
  const tag = reader.uint32();
1483
1502
  switch (tag >>> 3) {
1484
- case 1:
1503
+ case 1: {
1485
1504
  obj.proof = reader.bytes();
1486
1505
  break;
1487
- case 2:
1506
+ }
1507
+ case 2: {
1488
1508
  obj.merkleRoot = reader.bytes();
1489
1509
  break;
1490
- case 3:
1510
+ }
1511
+ case 3: {
1491
1512
  obj.epoch = reader.bytes();
1492
1513
  break;
1493
- case 4:
1514
+ }
1515
+ case 4: {
1494
1516
  obj.shareX = reader.bytes();
1495
1517
  break;
1496
- case 5:
1518
+ }
1519
+ case 5: {
1497
1520
  obj.shareY = reader.bytes();
1498
1521
  break;
1499
- case 6:
1522
+ }
1523
+ case 6: {
1500
1524
  obj.nullifier = reader.bytes();
1501
1525
  break;
1502
- case 7:
1526
+ }
1527
+ case 7: {
1503
1528
  obj.rlnIdentifier = reader.bytes();
1504
1529
  break;
1505
- default:
1530
+ }
1531
+ default: {
1506
1532
  reader.skipType(tag & 7);
1507
1533
  break;
1534
+ }
1508
1535
  }
1509
1536
  }
1510
1537
  return obj;
@@ -1515,8 +1542,8 @@ var RateLimitProof$4;
1515
1542
  RateLimitProof.encode = (obj) => {
1516
1543
  return encodeMessage(obj, RateLimitProof.codec());
1517
1544
  };
1518
- RateLimitProof.decode = (buf) => {
1519
- return decodeMessage(buf, RateLimitProof.codec());
1545
+ RateLimitProof.decode = (buf, opts) => {
1546
+ return decodeMessage(buf, RateLimitProof.codec(), opts);
1520
1547
  };
1521
1548
  })(RateLimitProof$4 || (RateLimitProof$4 = {}));
1522
1549
  var WakuMessage$4;
@@ -1559,39 +1586,49 @@ var WakuMessage$4;
1559
1586
  if (opts.lengthDelimited !== false) {
1560
1587
  w.ldelim();
1561
1588
  }
1562
- }, (reader, length) => {
1589
+ }, (reader, length, opts = {}) => {
1563
1590
  const obj = {
1564
- payload: new Uint8Array(0),
1591
+ payload: alloc$1(0),
1565
1592
  contentTopic: ''
1566
1593
  };
1567
1594
  const end = length == null ? reader.len : reader.pos + length;
1568
1595
  while (reader.pos < end) {
1569
1596
  const tag = reader.uint32();
1570
1597
  switch (tag >>> 3) {
1571
- case 1:
1598
+ case 1: {
1572
1599
  obj.payload = reader.bytes();
1573
1600
  break;
1574
- case 2:
1601
+ }
1602
+ case 2: {
1575
1603
  obj.contentTopic = reader.string();
1576
1604
  break;
1577
- case 3:
1605
+ }
1606
+ case 3: {
1578
1607
  obj.version = reader.uint32();
1579
1608
  break;
1580
- case 10:
1609
+ }
1610
+ case 10: {
1581
1611
  obj.timestamp = reader.sint64();
1582
1612
  break;
1583
- case 11:
1613
+ }
1614
+ case 11: {
1584
1615
  obj.meta = reader.bytes();
1585
1616
  break;
1586
- case 21:
1587
- obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32());
1617
+ }
1618
+ case 21: {
1619
+ obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32(), {
1620
+ limits: opts.limits?.rateLimitProof
1621
+ });
1588
1622
  break;
1589
- case 31:
1623
+ }
1624
+ case 31: {
1590
1625
  obj.ephemeral = reader.bool();
1591
1626
  break;
1592
- default:
1627
+ }
1628
+ default: {
1593
1629
  reader.skipType(tag & 7);
1594
1630
  break;
1631
+ }
1595
1632
  }
1596
1633
  }
1597
1634
  return obj;
@@ -1602,8 +1639,8 @@ var WakuMessage$4;
1602
1639
  WakuMessage.encode = (obj) => {
1603
1640
  return encodeMessage(obj, WakuMessage.codec());
1604
1641
  };
1605
- WakuMessage.decode = (buf) => {
1606
- return decodeMessage(buf, WakuMessage.codec());
1642
+ WakuMessage.decode = (buf, opts) => {
1643
+ return decodeMessage(buf, WakuMessage.codec(), opts);
1607
1644
  };
1608
1645
  })(WakuMessage$4 || (WakuMessage$4 = {}));
1609
1646
 
@@ -1635,7 +1672,7 @@ var FilterRequest;
1635
1672
  if (opts.lengthDelimited !== false) {
1636
1673
  w.ldelim();
1637
1674
  }
1638
- }, (reader, length) => {
1675
+ }, (reader, length, opts = {}) => {
1639
1676
  const obj = {
1640
1677
  contentTopic: ''
1641
1678
  };
@@ -1643,12 +1680,14 @@ var FilterRequest;
1643
1680
  while (reader.pos < end) {
1644
1681
  const tag = reader.uint32();
1645
1682
  switch (tag >>> 3) {
1646
- case 1:
1683
+ case 1: {
1647
1684
  obj.contentTopic = reader.string();
1648
1685
  break;
1649
- default:
1686
+ }
1687
+ default: {
1650
1688
  reader.skipType(tag & 7);
1651
1689
  break;
1690
+ }
1652
1691
  }
1653
1692
  }
1654
1693
  return obj;
@@ -1659,8 +1698,8 @@ var FilterRequest;
1659
1698
  ContentFilter.encode = (obj) => {
1660
1699
  return encodeMessage(obj, ContentFilter.codec());
1661
1700
  };
1662
- ContentFilter.decode = (buf) => {
1663
- return decodeMessage(buf, ContentFilter.codec());
1701
+ ContentFilter.decode = (buf, opts) => {
1702
+ return decodeMessage(buf, ContentFilter.codec(), opts);
1664
1703
  };
1665
1704
  })(FilterRequest.ContentFilter || (FilterRequest.ContentFilter = {}));
1666
1705
  let _codec;
@@ -1687,7 +1726,7 @@ var FilterRequest;
1687
1726
  if (opts.lengthDelimited !== false) {
1688
1727
  w.ldelim();
1689
1728
  }
1690
- }, (reader, length) => {
1729
+ }, (reader, length, opts = {}) => {
1691
1730
  const obj = {
1692
1731
  subscribe: false,
1693
1732
  topic: '',
@@ -1697,18 +1736,27 @@ var FilterRequest;
1697
1736
  while (reader.pos < end) {
1698
1737
  const tag = reader.uint32();
1699
1738
  switch (tag >>> 3) {
1700
- case 1:
1739
+ case 1: {
1701
1740
  obj.subscribe = reader.bool();
1702
1741
  break;
1703
- case 2:
1742
+ }
1743
+ case 2: {
1704
1744
  obj.topic = reader.string();
1705
1745
  break;
1706
- case 3:
1707
- obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32()));
1746
+ }
1747
+ case 3: {
1748
+ if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
1749
+ throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
1750
+ }
1751
+ obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32(), {
1752
+ limits: opts.limits?.contentFilters$
1753
+ }));
1708
1754
  break;
1709
- default:
1755
+ }
1756
+ default: {
1710
1757
  reader.skipType(tag & 7);
1711
1758
  break;
1759
+ }
1712
1760
  }
1713
1761
  }
1714
1762
  return obj;
@@ -1719,8 +1767,8 @@ var FilterRequest;
1719
1767
  FilterRequest.encode = (obj) => {
1720
1768
  return encodeMessage(obj, FilterRequest.codec());
1721
1769
  };
1722
- FilterRequest.decode = (buf) => {
1723
- return decodeMessage(buf, FilterRequest.codec());
1770
+ FilterRequest.decode = (buf, opts) => {
1771
+ return decodeMessage(buf, FilterRequest.codec(), opts);
1724
1772
  };
1725
1773
  })(FilterRequest || (FilterRequest = {}));
1726
1774
  var MessagePush$1;
@@ -1741,7 +1789,7 @@ var MessagePush$1;
1741
1789
  if (opts.lengthDelimited !== false) {
1742
1790
  w.ldelim();
1743
1791
  }
1744
- }, (reader, length) => {
1792
+ }, (reader, length, opts = {}) => {
1745
1793
  const obj = {
1746
1794
  messages: []
1747
1795
  };
@@ -1749,12 +1797,19 @@ var MessagePush$1;
1749
1797
  while (reader.pos < end) {
1750
1798
  const tag = reader.uint32();
1751
1799
  switch (tag >>> 3) {
1752
- case 1:
1753
- obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32()));
1800
+ case 1: {
1801
+ if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
1802
+ throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
1803
+ }
1804
+ obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32(), {
1805
+ limits: opts.limits?.messages$
1806
+ }));
1754
1807
  break;
1755
- default:
1808
+ }
1809
+ default: {
1756
1810
  reader.skipType(tag & 7);
1757
1811
  break;
1812
+ }
1758
1813
  }
1759
1814
  }
1760
1815
  return obj;
@@ -1765,8 +1820,8 @@ var MessagePush$1;
1765
1820
  MessagePush.encode = (obj) => {
1766
1821
  return encodeMessage(obj, MessagePush.codec());
1767
1822
  };
1768
- MessagePush.decode = (buf) => {
1769
- return decodeMessage(buf, MessagePush.codec());
1823
+ MessagePush.decode = (buf, opts) => {
1824
+ return decodeMessage(buf, MessagePush.codec(), opts);
1770
1825
  };
1771
1826
  })(MessagePush$1 || (MessagePush$1 = {}));
1772
1827
  var FilterRpc;
@@ -1793,7 +1848,7 @@ var FilterRpc;
1793
1848
  if (opts.lengthDelimited !== false) {
1794
1849
  w.ldelim();
1795
1850
  }
1796
- }, (reader, length) => {
1851
+ }, (reader, length, opts = {}) => {
1797
1852
  const obj = {
1798
1853
  requestId: ''
1799
1854
  };
@@ -1801,18 +1856,26 @@ var FilterRpc;
1801
1856
  while (reader.pos < end) {
1802
1857
  const tag = reader.uint32();
1803
1858
  switch (tag >>> 3) {
1804
- case 1:
1859
+ case 1: {
1805
1860
  obj.requestId = reader.string();
1806
1861
  break;
1807
- case 2:
1808
- obj.request = FilterRequest.codec().decode(reader, reader.uint32());
1862
+ }
1863
+ case 2: {
1864
+ obj.request = FilterRequest.codec().decode(reader, reader.uint32(), {
1865
+ limits: opts.limits?.request
1866
+ });
1809
1867
  break;
1810
- case 3:
1811
- obj.push = MessagePush$1.codec().decode(reader, reader.uint32());
1868
+ }
1869
+ case 3: {
1870
+ obj.push = MessagePush$1.codec().decode(reader, reader.uint32(), {
1871
+ limits: opts.limits?.push
1872
+ });
1812
1873
  break;
1813
- default:
1874
+ }
1875
+ default: {
1814
1876
  reader.skipType(tag & 7);
1815
1877
  break;
1878
+ }
1816
1879
  }
1817
1880
  }
1818
1881
  return obj;
@@ -1823,8 +1886,8 @@ var FilterRpc;
1823
1886
  FilterRpc.encode = (obj) => {
1824
1887
  return encodeMessage(obj, FilterRpc.codec());
1825
1888
  };
1826
- FilterRpc.decode = (buf) => {
1827
- return decodeMessage(buf, FilterRpc.codec());
1889
+ FilterRpc.decode = (buf, opts) => {
1890
+ return decodeMessage(buf, FilterRpc.codec(), opts);
1828
1891
  };
1829
1892
  })(FilterRpc || (FilterRpc = {}));
1830
1893
  var RateLimitProof$3;
@@ -1867,44 +1930,52 @@ var RateLimitProof$3;
1867
1930
  if (opts.lengthDelimited !== false) {
1868
1931
  w.ldelim();
1869
1932
  }
1870
- }, (reader, length) => {
1933
+ }, (reader, length, opts = {}) => {
1871
1934
  const obj = {
1872
- proof: new Uint8Array(0),
1873
- merkleRoot: new Uint8Array(0),
1874
- epoch: new Uint8Array(0),
1875
- shareX: new Uint8Array(0),
1876
- shareY: new Uint8Array(0),
1877
- nullifier: new Uint8Array(0),
1878
- rlnIdentifier: new Uint8Array(0)
1935
+ proof: alloc$1(0),
1936
+ merkleRoot: alloc$1(0),
1937
+ epoch: alloc$1(0),
1938
+ shareX: alloc$1(0),
1939
+ shareY: alloc$1(0),
1940
+ nullifier: alloc$1(0),
1941
+ rlnIdentifier: alloc$1(0)
1879
1942
  };
1880
1943
  const end = length == null ? reader.len : reader.pos + length;
1881
1944
  while (reader.pos < end) {
1882
1945
  const tag = reader.uint32();
1883
1946
  switch (tag >>> 3) {
1884
- case 1:
1947
+ case 1: {
1885
1948
  obj.proof = reader.bytes();
1886
1949
  break;
1887
- case 2:
1950
+ }
1951
+ case 2: {
1888
1952
  obj.merkleRoot = reader.bytes();
1889
1953
  break;
1890
- case 3:
1954
+ }
1955
+ case 3: {
1891
1956
  obj.epoch = reader.bytes();
1892
1957
  break;
1893
- case 4:
1958
+ }
1959
+ case 4: {
1894
1960
  obj.shareX = reader.bytes();
1895
1961
  break;
1896
- case 5:
1962
+ }
1963
+ case 5: {
1897
1964
  obj.shareY = reader.bytes();
1898
1965
  break;
1899
- case 6:
1966
+ }
1967
+ case 6: {
1900
1968
  obj.nullifier = reader.bytes();
1901
1969
  break;
1902
- case 7:
1970
+ }
1971
+ case 7: {
1903
1972
  obj.rlnIdentifier = reader.bytes();
1904
1973
  break;
1905
- default:
1974
+ }
1975
+ default: {
1906
1976
  reader.skipType(tag & 7);
1907
1977
  break;
1978
+ }
1908
1979
  }
1909
1980
  }
1910
1981
  return obj;
@@ -1915,8 +1986,8 @@ var RateLimitProof$3;
1915
1986
  RateLimitProof.encode = (obj) => {
1916
1987
  return encodeMessage(obj, RateLimitProof.codec());
1917
1988
  };
1918
- RateLimitProof.decode = (buf) => {
1919
- return decodeMessage(buf, RateLimitProof.codec());
1989
+ RateLimitProof.decode = (buf, opts) => {
1990
+ return decodeMessage(buf, RateLimitProof.codec(), opts);
1920
1991
  };
1921
1992
  })(RateLimitProof$3 || (RateLimitProof$3 = {}));
1922
1993
  var WakuMessage$3;
@@ -1959,39 +2030,49 @@ var WakuMessage$3;
1959
2030
  if (opts.lengthDelimited !== false) {
1960
2031
  w.ldelim();
1961
2032
  }
1962
- }, (reader, length) => {
2033
+ }, (reader, length, opts = {}) => {
1963
2034
  const obj = {
1964
- payload: new Uint8Array(0),
2035
+ payload: alloc$1(0),
1965
2036
  contentTopic: ''
1966
2037
  };
1967
2038
  const end = length == null ? reader.len : reader.pos + length;
1968
2039
  while (reader.pos < end) {
1969
2040
  const tag = reader.uint32();
1970
2041
  switch (tag >>> 3) {
1971
- case 1:
2042
+ case 1: {
1972
2043
  obj.payload = reader.bytes();
1973
2044
  break;
1974
- case 2:
2045
+ }
2046
+ case 2: {
1975
2047
  obj.contentTopic = reader.string();
1976
2048
  break;
1977
- case 3:
2049
+ }
2050
+ case 3: {
1978
2051
  obj.version = reader.uint32();
1979
2052
  break;
1980
- case 10:
2053
+ }
2054
+ case 10: {
1981
2055
  obj.timestamp = reader.sint64();
1982
2056
  break;
1983
- case 11:
2057
+ }
2058
+ case 11: {
1984
2059
  obj.meta = reader.bytes();
1985
2060
  break;
1986
- case 21:
1987
- obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32());
2061
+ }
2062
+ case 21: {
2063
+ obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32(), {
2064
+ limits: opts.limits?.rateLimitProof
2065
+ });
1988
2066
  break;
1989
- case 31:
2067
+ }
2068
+ case 31: {
1990
2069
  obj.ephemeral = reader.bool();
1991
2070
  break;
1992
- default:
2071
+ }
2072
+ default: {
1993
2073
  reader.skipType(tag & 7);
1994
2074
  break;
2075
+ }
1995
2076
  }
1996
2077
  }
1997
2078
  return obj;
@@ -2002,8 +2083,8 @@ var WakuMessage$3;
2002
2083
  WakuMessage.encode = (obj) => {
2003
2084
  return encodeMessage(obj, WakuMessage.codec());
2004
2085
  };
2005
- WakuMessage.decode = (buf) => {
2006
- return decodeMessage(buf, WakuMessage.codec());
2086
+ WakuMessage.decode = (buf, opts) => {
2087
+ return decodeMessage(buf, WakuMessage.codec(), opts);
2007
2088
  };
2008
2089
  })(WakuMessage$3 || (WakuMessage$3 = {}));
2009
2090
 
@@ -2028,7 +2109,7 @@ var TopicOnlyMessage;
2028
2109
  if (opts.lengthDelimited !== false) {
2029
2110
  w.ldelim();
2030
2111
  }
2031
- }, (reader, length) => {
2112
+ }, (reader, length, opts = {}) => {
2032
2113
  const obj = {
2033
2114
  contentTopic: ''
2034
2115
  };
@@ -2036,12 +2117,14 @@ var TopicOnlyMessage;
2036
2117
  while (reader.pos < end) {
2037
2118
  const tag = reader.uint32();
2038
2119
  switch (tag >>> 3) {
2039
- case 2:
2120
+ case 2: {
2040
2121
  obj.contentTopic = reader.string();
2041
2122
  break;
2042
- default:
2123
+ }
2124
+ default: {
2043
2125
  reader.skipType(tag & 7);
2044
2126
  break;
2127
+ }
2045
2128
  }
2046
2129
  }
2047
2130
  return obj;
@@ -2052,8 +2135,8 @@ var TopicOnlyMessage;
2052
2135
  TopicOnlyMessage.encode = (obj) => {
2053
2136
  return encodeMessage(obj, TopicOnlyMessage.codec());
2054
2137
  };
2055
- TopicOnlyMessage.decode = (buf) => {
2056
- return decodeMessage(buf, TopicOnlyMessage.codec());
2138
+ TopicOnlyMessage.decode = (buf, opts) => {
2139
+ return decodeMessage(buf, TopicOnlyMessage.codec(), opts);
2057
2140
  };
2058
2141
  })(TopicOnlyMessage || (TopicOnlyMessage = {}));
2059
2142
 
@@ -2111,7 +2194,7 @@ var FilterSubscribeRequest;
2111
2194
  if (opts.lengthDelimited !== false) {
2112
2195
  w.ldelim();
2113
2196
  }
2114
- }, (reader, length) => {
2197
+ }, (reader, length, opts = {}) => {
2115
2198
  const obj = {
2116
2199
  requestId: '',
2117
2200
  filterSubscribeType: FilterSubscribeType.SUBSCRIBER_PING,
@@ -2121,21 +2204,29 @@ var FilterSubscribeRequest;
2121
2204
  while (reader.pos < end) {
2122
2205
  const tag = reader.uint32();
2123
2206
  switch (tag >>> 3) {
2124
- case 1:
2207
+ case 1: {
2125
2208
  obj.requestId = reader.string();
2126
2209
  break;
2127
- case 2:
2210
+ }
2211
+ case 2: {
2128
2212
  obj.filterSubscribeType = FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
2129
2213
  break;
2130
- case 10:
2214
+ }
2215
+ case 10: {
2131
2216
  obj.pubsubTopic = reader.string();
2132
2217
  break;
2133
- case 11:
2218
+ }
2219
+ case 11: {
2220
+ if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
2221
+ throw new CodeError('decode error - map field "contentTopics" had too many elements', 'ERR_MAX_LENGTH');
2222
+ }
2134
2223
  obj.contentTopics.push(reader.string());
2135
2224
  break;
2136
- default:
2225
+ }
2226
+ default: {
2137
2227
  reader.skipType(tag & 7);
2138
2228
  break;
2229
+ }
2139
2230
  }
2140
2231
  }
2141
2232
  return obj;
@@ -2146,8 +2237,8 @@ var FilterSubscribeRequest;
2146
2237
  FilterSubscribeRequest.encode = (obj) => {
2147
2238
  return encodeMessage(obj, FilterSubscribeRequest.codec());
2148
2239
  };
2149
- FilterSubscribeRequest.decode = (buf) => {
2150
- return decodeMessage(buf, FilterSubscribeRequest.codec());
2240
+ FilterSubscribeRequest.decode = (buf, opts) => {
2241
+ return decodeMessage(buf, FilterSubscribeRequest.codec(), opts);
2151
2242
  };
2152
2243
  })(FilterSubscribeRequest || (FilterSubscribeRequest = {}));
2153
2244
  var FilterSubscribeResponse$1;
@@ -2174,7 +2265,7 @@ var FilterSubscribeResponse$1;
2174
2265
  if (opts.lengthDelimited !== false) {
2175
2266
  w.ldelim();
2176
2267
  }
2177
- }, (reader, length) => {
2268
+ }, (reader, length, opts = {}) => {
2178
2269
  const obj = {
2179
2270
  requestId: '',
2180
2271
  statusCode: 0
@@ -2183,18 +2274,22 @@ var FilterSubscribeResponse$1;
2183
2274
  while (reader.pos < end) {
2184
2275
  const tag = reader.uint32();
2185
2276
  switch (tag >>> 3) {
2186
- case 1:
2277
+ case 1: {
2187
2278
  obj.requestId = reader.string();
2188
2279
  break;
2189
- case 10:
2280
+ }
2281
+ case 10: {
2190
2282
  obj.statusCode = reader.uint32();
2191
2283
  break;
2192
- case 11:
2284
+ }
2285
+ case 11: {
2193
2286
  obj.statusDesc = reader.string();
2194
2287
  break;
2195
- default:
2288
+ }
2289
+ default: {
2196
2290
  reader.skipType(tag & 7);
2197
2291
  break;
2292
+ }
2198
2293
  }
2199
2294
  }
2200
2295
  return obj;
@@ -2205,8 +2300,8 @@ var FilterSubscribeResponse$1;
2205
2300
  FilterSubscribeResponse.encode = (obj) => {
2206
2301
  return encodeMessage(obj, FilterSubscribeResponse.codec());
2207
2302
  };
2208
- FilterSubscribeResponse.decode = (buf) => {
2209
- return decodeMessage(buf, FilterSubscribeResponse.codec());
2303
+ FilterSubscribeResponse.decode = (buf, opts) => {
2304
+ return decodeMessage(buf, FilterSubscribeResponse.codec(), opts);
2210
2305
  };
2211
2306
  })(FilterSubscribeResponse$1 || (FilterSubscribeResponse$1 = {}));
2212
2307
  var MessagePush;
@@ -2229,21 +2324,26 @@ var MessagePush;
2229
2324
  if (opts.lengthDelimited !== false) {
2230
2325
  w.ldelim();
2231
2326
  }
2232
- }, (reader, length) => {
2327
+ }, (reader, length, opts = {}) => {
2233
2328
  const obj = {};
2234
2329
  const end = length == null ? reader.len : reader.pos + length;
2235
2330
  while (reader.pos < end) {
2236
2331
  const tag = reader.uint32();
2237
2332
  switch (tag >>> 3) {
2238
- case 1:
2239
- obj.wakuMessage = WakuMessage$2.codec().decode(reader, reader.uint32());
2333
+ case 1: {
2334
+ obj.wakuMessage = WakuMessage$2.codec().decode(reader, reader.uint32(), {
2335
+ limits: opts.limits?.wakuMessage
2336
+ });
2240
2337
  break;
2241
- case 2:
2338
+ }
2339
+ case 2: {
2242
2340
  obj.pubsubTopic = reader.string();
2243
2341
  break;
2244
- default:
2342
+ }
2343
+ default: {
2245
2344
  reader.skipType(tag & 7);
2246
2345
  break;
2346
+ }
2247
2347
  }
2248
2348
  }
2249
2349
  return obj;
@@ -2254,8 +2354,8 @@ var MessagePush;
2254
2354
  MessagePush.encode = (obj) => {
2255
2355
  return encodeMessage(obj, MessagePush.codec());
2256
2356
  };
2257
- MessagePush.decode = (buf) => {
2258
- return decodeMessage(buf, MessagePush.codec());
2357
+ MessagePush.decode = (buf, opts) => {
2358
+ return decodeMessage(buf, MessagePush.codec(), opts);
2259
2359
  };
2260
2360
  })(MessagePush || (MessagePush = {}));
2261
2361
  var RateLimitProof$2;
@@ -2298,44 +2398,52 @@ var RateLimitProof$2;
2298
2398
  if (opts.lengthDelimited !== false) {
2299
2399
  w.ldelim();
2300
2400
  }
2301
- }, (reader, length) => {
2401
+ }, (reader, length, opts = {}) => {
2302
2402
  const obj = {
2303
- proof: new Uint8Array(0),
2304
- merkleRoot: new Uint8Array(0),
2305
- epoch: new Uint8Array(0),
2306
- shareX: new Uint8Array(0),
2307
- shareY: new Uint8Array(0),
2308
- nullifier: new Uint8Array(0),
2309
- rlnIdentifier: new Uint8Array(0)
2403
+ proof: alloc$1(0),
2404
+ merkleRoot: alloc$1(0),
2405
+ epoch: alloc$1(0),
2406
+ shareX: alloc$1(0),
2407
+ shareY: alloc$1(0),
2408
+ nullifier: alloc$1(0),
2409
+ rlnIdentifier: alloc$1(0)
2310
2410
  };
2311
2411
  const end = length == null ? reader.len : reader.pos + length;
2312
2412
  while (reader.pos < end) {
2313
2413
  const tag = reader.uint32();
2314
2414
  switch (tag >>> 3) {
2315
- case 1:
2415
+ case 1: {
2316
2416
  obj.proof = reader.bytes();
2317
2417
  break;
2318
- case 2:
2418
+ }
2419
+ case 2: {
2319
2420
  obj.merkleRoot = reader.bytes();
2320
2421
  break;
2321
- case 3:
2422
+ }
2423
+ case 3: {
2322
2424
  obj.epoch = reader.bytes();
2323
2425
  break;
2324
- case 4:
2426
+ }
2427
+ case 4: {
2325
2428
  obj.shareX = reader.bytes();
2326
2429
  break;
2327
- case 5:
2430
+ }
2431
+ case 5: {
2328
2432
  obj.shareY = reader.bytes();
2329
2433
  break;
2330
- case 6:
2434
+ }
2435
+ case 6: {
2331
2436
  obj.nullifier = reader.bytes();
2332
2437
  break;
2333
- case 7:
2438
+ }
2439
+ case 7: {
2334
2440
  obj.rlnIdentifier = reader.bytes();
2335
2441
  break;
2336
- default:
2442
+ }
2443
+ default: {
2337
2444
  reader.skipType(tag & 7);
2338
2445
  break;
2446
+ }
2339
2447
  }
2340
2448
  }
2341
2449
  return obj;
@@ -2346,8 +2454,8 @@ var RateLimitProof$2;
2346
2454
  RateLimitProof.encode = (obj) => {
2347
2455
  return encodeMessage(obj, RateLimitProof.codec());
2348
2456
  };
2349
- RateLimitProof.decode = (buf) => {
2350
- return decodeMessage(buf, RateLimitProof.codec());
2457
+ RateLimitProof.decode = (buf, opts) => {
2458
+ return decodeMessage(buf, RateLimitProof.codec(), opts);
2351
2459
  };
2352
2460
  })(RateLimitProof$2 || (RateLimitProof$2 = {}));
2353
2461
  var WakuMessage$2;
@@ -2390,39 +2498,49 @@ var WakuMessage$2;
2390
2498
  if (opts.lengthDelimited !== false) {
2391
2499
  w.ldelim();
2392
2500
  }
2393
- }, (reader, length) => {
2501
+ }, (reader, length, opts = {}) => {
2394
2502
  const obj = {
2395
- payload: new Uint8Array(0),
2503
+ payload: alloc$1(0),
2396
2504
  contentTopic: ''
2397
2505
  };
2398
2506
  const end = length == null ? reader.len : reader.pos + length;
2399
2507
  while (reader.pos < end) {
2400
2508
  const tag = reader.uint32();
2401
2509
  switch (tag >>> 3) {
2402
- case 1:
2510
+ case 1: {
2403
2511
  obj.payload = reader.bytes();
2404
2512
  break;
2405
- case 2:
2513
+ }
2514
+ case 2: {
2406
2515
  obj.contentTopic = reader.string();
2407
2516
  break;
2408
- case 3:
2517
+ }
2518
+ case 3: {
2409
2519
  obj.version = reader.uint32();
2410
2520
  break;
2411
- case 10:
2521
+ }
2522
+ case 10: {
2412
2523
  obj.timestamp = reader.sint64();
2413
2524
  break;
2414
- case 11:
2525
+ }
2526
+ case 11: {
2415
2527
  obj.meta = reader.bytes();
2416
2528
  break;
2417
- case 21:
2418
- obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
2529
+ }
2530
+ case 21: {
2531
+ obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32(), {
2532
+ limits: opts.limits?.rateLimitProof
2533
+ });
2419
2534
  break;
2420
- case 31:
2535
+ }
2536
+ case 31: {
2421
2537
  obj.ephemeral = reader.bool();
2422
2538
  break;
2423
- default:
2539
+ }
2540
+ default: {
2424
2541
  reader.skipType(tag & 7);
2425
2542
  break;
2543
+ }
2426
2544
  }
2427
2545
  }
2428
2546
  return obj;
@@ -2433,8 +2551,8 @@ var WakuMessage$2;
2433
2551
  WakuMessage.encode = (obj) => {
2434
2552
  return encodeMessage(obj, WakuMessage.codec());
2435
2553
  };
2436
- WakuMessage.decode = (buf) => {
2437
- return decodeMessage(buf, WakuMessage.codec());
2554
+ WakuMessage.decode = (buf, opts) => {
2555
+ return decodeMessage(buf, WakuMessage.codec(), opts);
2438
2556
  };
2439
2557
  })(WakuMessage$2 || (WakuMessage$2 = {}));
2440
2558
 
@@ -2463,7 +2581,7 @@ var PushRequest;
2463
2581
  if (opts.lengthDelimited !== false) {
2464
2582
  w.ldelim();
2465
2583
  }
2466
- }, (reader, length) => {
2584
+ }, (reader, length, opts = {}) => {
2467
2585
  const obj = {
2468
2586
  pubsubTopic: ''
2469
2587
  };
@@ -2471,15 +2589,20 @@ var PushRequest;
2471
2589
  while (reader.pos < end) {
2472
2590
  const tag = reader.uint32();
2473
2591
  switch (tag >>> 3) {
2474
- case 1:
2592
+ case 1: {
2475
2593
  obj.pubsubTopic = reader.string();
2476
2594
  break;
2477
- case 2:
2478
- obj.message = WakuMessage$1.codec().decode(reader, reader.uint32());
2595
+ }
2596
+ case 2: {
2597
+ obj.message = WakuMessage$1.codec().decode(reader, reader.uint32(), {
2598
+ limits: opts.limits?.message
2599
+ });
2479
2600
  break;
2480
- default:
2601
+ }
2602
+ default: {
2481
2603
  reader.skipType(tag & 7);
2482
2604
  break;
2605
+ }
2483
2606
  }
2484
2607
  }
2485
2608
  return obj;
@@ -2490,8 +2613,8 @@ var PushRequest;
2490
2613
  PushRequest.encode = (obj) => {
2491
2614
  return encodeMessage(obj, PushRequest.codec());
2492
2615
  };
2493
- PushRequest.decode = (buf) => {
2494
- return decodeMessage(buf, PushRequest.codec());
2616
+ PushRequest.decode = (buf, opts) => {
2617
+ return decodeMessage(buf, PushRequest.codec(), opts);
2495
2618
  };
2496
2619
  })(PushRequest || (PushRequest = {}));
2497
2620
  var PushResponse;
@@ -2514,7 +2637,7 @@ var PushResponse;
2514
2637
  if (opts.lengthDelimited !== false) {
2515
2638
  w.ldelim();
2516
2639
  }
2517
- }, (reader, length) => {
2640
+ }, (reader, length, opts = {}) => {
2518
2641
  const obj = {
2519
2642
  isSuccess: false
2520
2643
  };
@@ -2522,15 +2645,18 @@ var PushResponse;
2522
2645
  while (reader.pos < end) {
2523
2646
  const tag = reader.uint32();
2524
2647
  switch (tag >>> 3) {
2525
- case 1:
2648
+ case 1: {
2526
2649
  obj.isSuccess = reader.bool();
2527
2650
  break;
2528
- case 2:
2651
+ }
2652
+ case 2: {
2529
2653
  obj.info = reader.string();
2530
2654
  break;
2531
- default:
2655
+ }
2656
+ default: {
2532
2657
  reader.skipType(tag & 7);
2533
2658
  break;
2659
+ }
2534
2660
  }
2535
2661
  }
2536
2662
  return obj;
@@ -2541,8 +2667,8 @@ var PushResponse;
2541
2667
  PushResponse.encode = (obj) => {
2542
2668
  return encodeMessage(obj, PushResponse.codec());
2543
2669
  };
2544
- PushResponse.decode = (buf) => {
2545
- return decodeMessage(buf, PushResponse.codec());
2670
+ PushResponse.decode = (buf, opts) => {
2671
+ return decodeMessage(buf, PushResponse.codec(), opts);
2546
2672
  };
2547
2673
  })(PushResponse || (PushResponse = {}));
2548
2674
  var PushRpc$1;
@@ -2569,7 +2695,7 @@ var PushRpc$1;
2569
2695
  if (opts.lengthDelimited !== false) {
2570
2696
  w.ldelim();
2571
2697
  }
2572
- }, (reader, length) => {
2698
+ }, (reader, length, opts = {}) => {
2573
2699
  const obj = {
2574
2700
  requestId: ''
2575
2701
  };
@@ -2577,18 +2703,26 @@ var PushRpc$1;
2577
2703
  while (reader.pos < end) {
2578
2704
  const tag = reader.uint32();
2579
2705
  switch (tag >>> 3) {
2580
- case 1:
2706
+ case 1: {
2581
2707
  obj.requestId = reader.string();
2582
2708
  break;
2583
- case 2:
2584
- obj.request = PushRequest.codec().decode(reader, reader.uint32());
2709
+ }
2710
+ case 2: {
2711
+ obj.request = PushRequest.codec().decode(reader, reader.uint32(), {
2712
+ limits: opts.limits?.request
2713
+ });
2585
2714
  break;
2586
- case 3:
2587
- obj.response = PushResponse.codec().decode(reader, reader.uint32());
2715
+ }
2716
+ case 3: {
2717
+ obj.response = PushResponse.codec().decode(reader, reader.uint32(), {
2718
+ limits: opts.limits?.response
2719
+ });
2588
2720
  break;
2589
- default:
2721
+ }
2722
+ default: {
2590
2723
  reader.skipType(tag & 7);
2591
2724
  break;
2725
+ }
2592
2726
  }
2593
2727
  }
2594
2728
  return obj;
@@ -2599,8 +2733,8 @@ var PushRpc$1;
2599
2733
  PushRpc.encode = (obj) => {
2600
2734
  return encodeMessage(obj, PushRpc.codec());
2601
2735
  };
2602
- PushRpc.decode = (buf) => {
2603
- return decodeMessage(buf, PushRpc.codec());
2736
+ PushRpc.decode = (buf, opts) => {
2737
+ return decodeMessage(buf, PushRpc.codec(), opts);
2604
2738
  };
2605
2739
  })(PushRpc$1 || (PushRpc$1 = {}));
2606
2740
  var RateLimitProof$1;
@@ -2643,44 +2777,52 @@ var RateLimitProof$1;
2643
2777
  if (opts.lengthDelimited !== false) {
2644
2778
  w.ldelim();
2645
2779
  }
2646
- }, (reader, length) => {
2780
+ }, (reader, length, opts = {}) => {
2647
2781
  const obj = {
2648
- proof: new Uint8Array(0),
2649
- merkleRoot: new Uint8Array(0),
2650
- epoch: new Uint8Array(0),
2651
- shareX: new Uint8Array(0),
2652
- shareY: new Uint8Array(0),
2653
- nullifier: new Uint8Array(0),
2654
- rlnIdentifier: new Uint8Array(0)
2782
+ proof: alloc$1(0),
2783
+ merkleRoot: alloc$1(0),
2784
+ epoch: alloc$1(0),
2785
+ shareX: alloc$1(0),
2786
+ shareY: alloc$1(0),
2787
+ nullifier: alloc$1(0),
2788
+ rlnIdentifier: alloc$1(0)
2655
2789
  };
2656
2790
  const end = length == null ? reader.len : reader.pos + length;
2657
2791
  while (reader.pos < end) {
2658
2792
  const tag = reader.uint32();
2659
2793
  switch (tag >>> 3) {
2660
- case 1:
2794
+ case 1: {
2661
2795
  obj.proof = reader.bytes();
2662
2796
  break;
2663
- case 2:
2797
+ }
2798
+ case 2: {
2664
2799
  obj.merkleRoot = reader.bytes();
2665
2800
  break;
2666
- case 3:
2801
+ }
2802
+ case 3: {
2667
2803
  obj.epoch = reader.bytes();
2668
2804
  break;
2669
- case 4:
2805
+ }
2806
+ case 4: {
2670
2807
  obj.shareX = reader.bytes();
2671
2808
  break;
2672
- case 5:
2809
+ }
2810
+ case 5: {
2673
2811
  obj.shareY = reader.bytes();
2674
2812
  break;
2675
- case 6:
2813
+ }
2814
+ case 6: {
2676
2815
  obj.nullifier = reader.bytes();
2677
2816
  break;
2678
- case 7:
2817
+ }
2818
+ case 7: {
2679
2819
  obj.rlnIdentifier = reader.bytes();
2680
2820
  break;
2681
- default:
2821
+ }
2822
+ default: {
2682
2823
  reader.skipType(tag & 7);
2683
2824
  break;
2825
+ }
2684
2826
  }
2685
2827
  }
2686
2828
  return obj;
@@ -2691,8 +2833,8 @@ var RateLimitProof$1;
2691
2833
  RateLimitProof.encode = (obj) => {
2692
2834
  return encodeMessage(obj, RateLimitProof.codec());
2693
2835
  };
2694
- RateLimitProof.decode = (buf) => {
2695
- return decodeMessage(buf, RateLimitProof.codec());
2836
+ RateLimitProof.decode = (buf, opts) => {
2837
+ return decodeMessage(buf, RateLimitProof.codec(), opts);
2696
2838
  };
2697
2839
  })(RateLimitProof$1 || (RateLimitProof$1 = {}));
2698
2840
  var WakuMessage$1;
@@ -2735,39 +2877,49 @@ var WakuMessage$1;
2735
2877
  if (opts.lengthDelimited !== false) {
2736
2878
  w.ldelim();
2737
2879
  }
2738
- }, (reader, length) => {
2880
+ }, (reader, length, opts = {}) => {
2739
2881
  const obj = {
2740
- payload: new Uint8Array(0),
2882
+ payload: alloc$1(0),
2741
2883
  contentTopic: ''
2742
2884
  };
2743
2885
  const end = length == null ? reader.len : reader.pos + length;
2744
2886
  while (reader.pos < end) {
2745
2887
  const tag = reader.uint32();
2746
2888
  switch (tag >>> 3) {
2747
- case 1:
2889
+ case 1: {
2748
2890
  obj.payload = reader.bytes();
2749
2891
  break;
2750
- case 2:
2892
+ }
2893
+ case 2: {
2751
2894
  obj.contentTopic = reader.string();
2752
2895
  break;
2753
- case 3:
2896
+ }
2897
+ case 3: {
2754
2898
  obj.version = reader.uint32();
2755
2899
  break;
2756
- case 10:
2900
+ }
2901
+ case 10: {
2757
2902
  obj.timestamp = reader.sint64();
2758
2903
  break;
2759
- case 11:
2904
+ }
2905
+ case 11: {
2760
2906
  obj.meta = reader.bytes();
2761
2907
  break;
2762
- case 21:
2763
- obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32());
2908
+ }
2909
+ case 21: {
2910
+ obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32(), {
2911
+ limits: opts.limits?.rateLimitProof
2912
+ });
2764
2913
  break;
2765
- case 31:
2914
+ }
2915
+ case 31: {
2766
2916
  obj.ephemeral = reader.bool();
2767
2917
  break;
2768
- default:
2918
+ }
2919
+ default: {
2769
2920
  reader.skipType(tag & 7);
2770
2921
  break;
2922
+ }
2771
2923
  }
2772
2924
  }
2773
2925
  return obj;
@@ -2778,8 +2930,8 @@ var WakuMessage$1;
2778
2930
  WakuMessage.encode = (obj) => {
2779
2931
  return encodeMessage(obj, WakuMessage.codec());
2780
2932
  };
2781
- WakuMessage.decode = (buf) => {
2782
- return decodeMessage(buf, WakuMessage.codec());
2933
+ WakuMessage.decode = (buf, opts) => {
2934
+ return decodeMessage(buf, WakuMessage.codec(), opts);
2783
2935
  };
2784
2936
  })(WakuMessage$1 || (WakuMessage$1 = {}));
2785
2937
 
@@ -2816,9 +2968,9 @@ var Index;
2816
2968
  if (opts.lengthDelimited !== false) {
2817
2969
  w.ldelim();
2818
2970
  }
2819
- }, (reader, length) => {
2971
+ }, (reader, length, opts = {}) => {
2820
2972
  const obj = {
2821
- digest: new Uint8Array(0),
2973
+ digest: alloc$1(0),
2822
2974
  receiverTime: 0n,
2823
2975
  senderTime: 0n,
2824
2976
  pubsubTopic: ''
@@ -2827,21 +2979,26 @@ var Index;
2827
2979
  while (reader.pos < end) {
2828
2980
  const tag = reader.uint32();
2829
2981
  switch (tag >>> 3) {
2830
- case 1:
2982
+ case 1: {
2831
2983
  obj.digest = reader.bytes();
2832
2984
  break;
2833
- case 2:
2985
+ }
2986
+ case 2: {
2834
2987
  obj.receiverTime = reader.sint64();
2835
2988
  break;
2836
- case 3:
2989
+ }
2990
+ case 3: {
2837
2991
  obj.senderTime = reader.sint64();
2838
2992
  break;
2839
- case 4:
2993
+ }
2994
+ case 4: {
2840
2995
  obj.pubsubTopic = reader.string();
2841
2996
  break;
2842
- default:
2997
+ }
2998
+ default: {
2843
2999
  reader.skipType(tag & 7);
2844
3000
  break;
3001
+ }
2845
3002
  }
2846
3003
  }
2847
3004
  return obj;
@@ -2852,8 +3009,8 @@ var Index;
2852
3009
  Index.encode = (obj) => {
2853
3010
  return encodeMessage(obj, Index.codec());
2854
3011
  };
2855
- Index.decode = (buf) => {
2856
- return decodeMessage(buf, Index.codec());
3012
+ Index.decode = (buf, opts) => {
3013
+ return decodeMessage(buf, Index.codec(), opts);
2857
3014
  };
2858
3015
  })(Index || (Index = {}));
2859
3016
  var PagingInfo;
@@ -2894,24 +3051,30 @@ var PagingInfo;
2894
3051
  if (opts.lengthDelimited !== false) {
2895
3052
  w.ldelim();
2896
3053
  }
2897
- }, (reader, length) => {
3054
+ }, (reader, length, opts = {}) => {
2898
3055
  const obj = {};
2899
3056
  const end = length == null ? reader.len : reader.pos + length;
2900
3057
  while (reader.pos < end) {
2901
3058
  const tag = reader.uint32();
2902
3059
  switch (tag >>> 3) {
2903
- case 1:
3060
+ case 1: {
2904
3061
  obj.pageSize = reader.uint64();
2905
3062
  break;
2906
- case 2:
2907
- obj.cursor = Index.codec().decode(reader, reader.uint32());
3063
+ }
3064
+ case 2: {
3065
+ obj.cursor = Index.codec().decode(reader, reader.uint32(), {
3066
+ limits: opts.limits?.cursor
3067
+ });
2908
3068
  break;
2909
- case 3:
3069
+ }
3070
+ case 3: {
2910
3071
  obj.direction = PagingInfo.Direction.codec().decode(reader);
2911
3072
  break;
2912
- default:
3073
+ }
3074
+ default: {
2913
3075
  reader.skipType(tag & 7);
2914
3076
  break;
3077
+ }
2915
3078
  }
2916
3079
  }
2917
3080
  return obj;
@@ -2922,8 +3085,8 @@ var PagingInfo;
2922
3085
  PagingInfo.encode = (obj) => {
2923
3086
  return encodeMessage(obj, PagingInfo.codec());
2924
3087
  };
2925
- PagingInfo.decode = (buf) => {
2926
- return decodeMessage(buf, PagingInfo.codec());
3088
+ PagingInfo.decode = (buf, opts) => {
3089
+ return decodeMessage(buf, PagingInfo.codec(), opts);
2927
3090
  };
2928
3091
  })(PagingInfo || (PagingInfo = {}));
2929
3092
  var ContentFilter;
@@ -2942,7 +3105,7 @@ var ContentFilter;
2942
3105
  if (opts.lengthDelimited !== false) {
2943
3106
  w.ldelim();
2944
3107
  }
2945
- }, (reader, length) => {
3108
+ }, (reader, length, opts = {}) => {
2946
3109
  const obj = {
2947
3110
  contentTopic: ''
2948
3111
  };
@@ -2950,12 +3113,14 @@ var ContentFilter;
2950
3113
  while (reader.pos < end) {
2951
3114
  const tag = reader.uint32();
2952
3115
  switch (tag >>> 3) {
2953
- case 1:
3116
+ case 1: {
2954
3117
  obj.contentTopic = reader.string();
2955
3118
  break;
2956
- default:
3119
+ }
3120
+ default: {
2957
3121
  reader.skipType(tag & 7);
2958
3122
  break;
3123
+ }
2959
3124
  }
2960
3125
  }
2961
3126
  return obj;
@@ -2966,8 +3131,8 @@ var ContentFilter;
2966
3131
  ContentFilter.encode = (obj) => {
2967
3132
  return encodeMessage(obj, ContentFilter.codec());
2968
3133
  };
2969
- ContentFilter.decode = (buf) => {
2970
- return decodeMessage(buf, ContentFilter.codec());
3134
+ ContentFilter.decode = (buf, opts) => {
3135
+ return decodeMessage(buf, ContentFilter.codec(), opts);
2971
3136
  };
2972
3137
  })(ContentFilter || (ContentFilter = {}));
2973
3138
  var HistoryQuery;
@@ -3004,7 +3169,7 @@ var HistoryQuery;
3004
3169
  if (opts.lengthDelimited !== false) {
3005
3170
  w.ldelim();
3006
3171
  }
3007
- }, (reader, length) => {
3172
+ }, (reader, length, opts = {}) => {
3008
3173
  const obj = {
3009
3174
  contentFilters: []
3010
3175
  };
@@ -3012,24 +3177,37 @@ var HistoryQuery;
3012
3177
  while (reader.pos < end) {
3013
3178
  const tag = reader.uint32();
3014
3179
  switch (tag >>> 3) {
3015
- case 2:
3180
+ case 2: {
3016
3181
  obj.pubsubTopic = reader.string();
3017
3182
  break;
3018
- case 3:
3019
- obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32()));
3183
+ }
3184
+ case 3: {
3185
+ if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
3186
+ throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
3187
+ }
3188
+ obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32(), {
3189
+ limits: opts.limits?.contentFilters$
3190
+ }));
3020
3191
  break;
3021
- case 4:
3022
- obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
3192
+ }
3193
+ case 4: {
3194
+ obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
3195
+ limits: opts.limits?.pagingInfo
3196
+ });
3023
3197
  break;
3024
- case 5:
3198
+ }
3199
+ case 5: {
3025
3200
  obj.startTime = reader.sint64();
3026
3201
  break;
3027
- case 6:
3202
+ }
3203
+ case 6: {
3028
3204
  obj.endTime = reader.sint64();
3029
3205
  break;
3030
- default:
3206
+ }
3207
+ default: {
3031
3208
  reader.skipType(tag & 7);
3032
3209
  break;
3210
+ }
3033
3211
  }
3034
3212
  }
3035
3213
  return obj;
@@ -3040,8 +3218,8 @@ var HistoryQuery;
3040
3218
  HistoryQuery.encode = (obj) => {
3041
3219
  return encodeMessage(obj, HistoryQuery.codec());
3042
3220
  };
3043
- HistoryQuery.decode = (buf) => {
3044
- return decodeMessage(buf, HistoryQuery.codec());
3221
+ HistoryQuery.decode = (buf, opts) => {
3222
+ return decodeMessage(buf, HistoryQuery.codec(), opts);
3045
3223
  };
3046
3224
  })(HistoryQuery || (HistoryQuery = {}));
3047
3225
  var HistoryResponse;
@@ -3085,7 +3263,7 @@ var HistoryResponse;
3085
3263
  if (opts.lengthDelimited !== false) {
3086
3264
  w.ldelim();
3087
3265
  }
3088
- }, (reader, length) => {
3266
+ }, (reader, length, opts = {}) => {
3089
3267
  const obj = {
3090
3268
  messages: [],
3091
3269
  error: HistoryError.NONE
@@ -3094,18 +3272,29 @@ var HistoryResponse;
3094
3272
  while (reader.pos < end) {
3095
3273
  const tag = reader.uint32();
3096
3274
  switch (tag >>> 3) {
3097
- case 2:
3098
- obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32()));
3275
+ case 2: {
3276
+ if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
3277
+ throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
3278
+ }
3279
+ obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32(), {
3280
+ limits: opts.limits?.messages$
3281
+ }));
3099
3282
  break;
3100
- case 3:
3101
- obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
3283
+ }
3284
+ case 3: {
3285
+ obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
3286
+ limits: opts.limits?.pagingInfo
3287
+ });
3102
3288
  break;
3103
- case 4:
3289
+ }
3290
+ case 4: {
3104
3291
  obj.error = HistoryResponse.HistoryError.codec().decode(reader);
3105
3292
  break;
3106
- default:
3293
+ }
3294
+ default: {
3107
3295
  reader.skipType(tag & 7);
3108
3296
  break;
3297
+ }
3109
3298
  }
3110
3299
  }
3111
3300
  return obj;
@@ -3116,8 +3305,8 @@ var HistoryResponse;
3116
3305
  HistoryResponse.encode = (obj) => {
3117
3306
  return encodeMessage(obj, HistoryResponse.codec());
3118
3307
  };
3119
- HistoryResponse.decode = (buf) => {
3120
- return decodeMessage(buf, HistoryResponse.codec());
3308
+ HistoryResponse.decode = (buf, opts) => {
3309
+ return decodeMessage(buf, HistoryResponse.codec(), opts);
3121
3310
  };
3122
3311
  })(HistoryResponse || (HistoryResponse = {}));
3123
3312
  var HistoryRpc$1;
@@ -3144,7 +3333,7 @@ var HistoryRpc$1;
3144
3333
  if (opts.lengthDelimited !== false) {
3145
3334
  w.ldelim();
3146
3335
  }
3147
- }, (reader, length) => {
3336
+ }, (reader, length, opts = {}) => {
3148
3337
  const obj = {
3149
3338
  requestId: ''
3150
3339
  };
@@ -3152,18 +3341,26 @@ var HistoryRpc$1;
3152
3341
  while (reader.pos < end) {
3153
3342
  const tag = reader.uint32();
3154
3343
  switch (tag >>> 3) {
3155
- case 1:
3344
+ case 1: {
3156
3345
  obj.requestId = reader.string();
3157
3346
  break;
3158
- case 2:
3159
- obj.query = HistoryQuery.codec().decode(reader, reader.uint32());
3347
+ }
3348
+ case 2: {
3349
+ obj.query = HistoryQuery.codec().decode(reader, reader.uint32(), {
3350
+ limits: opts.limits?.query
3351
+ });
3160
3352
  break;
3161
- case 3:
3162
- obj.response = HistoryResponse.codec().decode(reader, reader.uint32());
3353
+ }
3354
+ case 3: {
3355
+ obj.response = HistoryResponse.codec().decode(reader, reader.uint32(), {
3356
+ limits: opts.limits?.response
3357
+ });
3163
3358
  break;
3164
- default:
3359
+ }
3360
+ default: {
3165
3361
  reader.skipType(tag & 7);
3166
3362
  break;
3363
+ }
3167
3364
  }
3168
3365
  }
3169
3366
  return obj;
@@ -3174,8 +3371,8 @@ var HistoryRpc$1;
3174
3371
  HistoryRpc.encode = (obj) => {
3175
3372
  return encodeMessage(obj, HistoryRpc.codec());
3176
3373
  };
3177
- HistoryRpc.decode = (buf) => {
3178
- return decodeMessage(buf, HistoryRpc.codec());
3374
+ HistoryRpc.decode = (buf, opts) => {
3375
+ return decodeMessage(buf, HistoryRpc.codec(), opts);
3179
3376
  };
3180
3377
  })(HistoryRpc$1 || (HistoryRpc$1 = {}));
3181
3378
  var RateLimitProof;
@@ -3218,44 +3415,52 @@ var RateLimitProof;
3218
3415
  if (opts.lengthDelimited !== false) {
3219
3416
  w.ldelim();
3220
3417
  }
3221
- }, (reader, length) => {
3418
+ }, (reader, length, opts = {}) => {
3222
3419
  const obj = {
3223
- proof: new Uint8Array(0),
3224
- merkleRoot: new Uint8Array(0),
3225
- epoch: new Uint8Array(0),
3226
- shareX: new Uint8Array(0),
3227
- shareY: new Uint8Array(0),
3228
- nullifier: new Uint8Array(0),
3229
- rlnIdentifier: new Uint8Array(0)
3420
+ proof: alloc$1(0),
3421
+ merkleRoot: alloc$1(0),
3422
+ epoch: alloc$1(0),
3423
+ shareX: alloc$1(0),
3424
+ shareY: alloc$1(0),
3425
+ nullifier: alloc$1(0),
3426
+ rlnIdentifier: alloc$1(0)
3230
3427
  };
3231
3428
  const end = length == null ? reader.len : reader.pos + length;
3232
3429
  while (reader.pos < end) {
3233
3430
  const tag = reader.uint32();
3234
3431
  switch (tag >>> 3) {
3235
- case 1:
3432
+ case 1: {
3236
3433
  obj.proof = reader.bytes();
3237
3434
  break;
3238
- case 2:
3435
+ }
3436
+ case 2: {
3239
3437
  obj.merkleRoot = reader.bytes();
3240
3438
  break;
3241
- case 3:
3439
+ }
3440
+ case 3: {
3242
3441
  obj.epoch = reader.bytes();
3243
3442
  break;
3244
- case 4:
3443
+ }
3444
+ case 4: {
3245
3445
  obj.shareX = reader.bytes();
3246
3446
  break;
3247
- case 5:
3447
+ }
3448
+ case 5: {
3248
3449
  obj.shareY = reader.bytes();
3249
3450
  break;
3250
- case 6:
3451
+ }
3452
+ case 6: {
3251
3453
  obj.nullifier = reader.bytes();
3252
3454
  break;
3253
- case 7:
3455
+ }
3456
+ case 7: {
3254
3457
  obj.rlnIdentifier = reader.bytes();
3255
3458
  break;
3256
- default:
3459
+ }
3460
+ default: {
3257
3461
  reader.skipType(tag & 7);
3258
3462
  break;
3463
+ }
3259
3464
  }
3260
3465
  }
3261
3466
  return obj;
@@ -3266,8 +3471,8 @@ var RateLimitProof;
3266
3471
  RateLimitProof.encode = (obj) => {
3267
3472
  return encodeMessage(obj, RateLimitProof.codec());
3268
3473
  };
3269
- RateLimitProof.decode = (buf) => {
3270
- return decodeMessage(buf, RateLimitProof.codec());
3474
+ RateLimitProof.decode = (buf, opts) => {
3475
+ return decodeMessage(buf, RateLimitProof.codec(), opts);
3271
3476
  };
3272
3477
  })(RateLimitProof || (RateLimitProof = {}));
3273
3478
  var WakuMessage;
@@ -3310,39 +3515,49 @@ var WakuMessage;
3310
3515
  if (opts.lengthDelimited !== false) {
3311
3516
  w.ldelim();
3312
3517
  }
3313
- }, (reader, length) => {
3518
+ }, (reader, length, opts = {}) => {
3314
3519
  const obj = {
3315
- payload: new Uint8Array(0),
3520
+ payload: alloc$1(0),
3316
3521
  contentTopic: ''
3317
3522
  };
3318
3523
  const end = length == null ? reader.len : reader.pos + length;
3319
3524
  while (reader.pos < end) {
3320
3525
  const tag = reader.uint32();
3321
3526
  switch (tag >>> 3) {
3322
- case 1:
3527
+ case 1: {
3323
3528
  obj.payload = reader.bytes();
3324
3529
  break;
3325
- case 2:
3530
+ }
3531
+ case 2: {
3326
3532
  obj.contentTopic = reader.string();
3327
3533
  break;
3328
- case 3:
3534
+ }
3535
+ case 3: {
3329
3536
  obj.version = reader.uint32();
3330
3537
  break;
3331
- case 10:
3538
+ }
3539
+ case 10: {
3332
3540
  obj.timestamp = reader.sint64();
3333
3541
  break;
3334
- case 11:
3542
+ }
3543
+ case 11: {
3335
3544
  obj.meta = reader.bytes();
3336
3545
  break;
3337
- case 21:
3338
- obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
3546
+ }
3547
+ case 21: {
3548
+ obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32(), {
3549
+ limits: opts.limits?.rateLimitProof
3550
+ });
3339
3551
  break;
3340
- case 31:
3552
+ }
3553
+ case 31: {
3341
3554
  obj.ephemeral = reader.bool();
3342
3555
  break;
3343
- default:
3556
+ }
3557
+ default: {
3344
3558
  reader.skipType(tag & 7);
3345
3559
  break;
3560
+ }
3346
3561
  }
3347
3562
  }
3348
3563
  return obj;
@@ -3353,8 +3568,8 @@ var WakuMessage;
3353
3568
  WakuMessage.encode = (obj) => {
3354
3569
  return encodeMessage(obj, WakuMessage.codec());
3355
3570
  };
3356
- WakuMessage.decode = (buf) => {
3357
- return decodeMessage(buf, WakuMessage.codec());
3571
+ WakuMessage.decode = (buf, opts) => {
3572
+ return decodeMessage(buf, WakuMessage.codec(), opts);
3358
3573
  };
3359
3574
  })(WakuMessage || (WakuMessage = {}));
3360
3575
 
@@ -3379,18 +3594,20 @@ var PeerInfo;
3379
3594
  if (opts.lengthDelimited !== false) {
3380
3595
  w.ldelim();
3381
3596
  }
3382
- }, (reader, length) => {
3597
+ }, (reader, length, opts = {}) => {
3383
3598
  const obj = {};
3384
3599
  const end = length == null ? reader.len : reader.pos + length;
3385
3600
  while (reader.pos < end) {
3386
3601
  const tag = reader.uint32();
3387
3602
  switch (tag >>> 3) {
3388
- case 1:
3603
+ case 1: {
3389
3604
  obj.enr = reader.bytes();
3390
3605
  break;
3391
- default:
3606
+ }
3607
+ default: {
3392
3608
  reader.skipType(tag & 7);
3393
3609
  break;
3610
+ }
3394
3611
  }
3395
3612
  }
3396
3613
  return obj;
@@ -3401,8 +3618,8 @@ var PeerInfo;
3401
3618
  PeerInfo.encode = (obj) => {
3402
3619
  return encodeMessage(obj, PeerInfo.codec());
3403
3620
  };
3404
- PeerInfo.decode = (buf) => {
3405
- return decodeMessage(buf, PeerInfo.codec());
3621
+ PeerInfo.decode = (buf, opts) => {
3622
+ return decodeMessage(buf, PeerInfo.codec(), opts);
3406
3623
  };
3407
3624
  })(PeerInfo || (PeerInfo = {}));
3408
3625
  var PeerExchangeQuery;
@@ -3421,18 +3638,20 @@ var PeerExchangeQuery;
3421
3638
  if (opts.lengthDelimited !== false) {
3422
3639
  w.ldelim();
3423
3640
  }
3424
- }, (reader, length) => {
3641
+ }, (reader, length, opts = {}) => {
3425
3642
  const obj = {};
3426
3643
  const end = length == null ? reader.len : reader.pos + length;
3427
3644
  while (reader.pos < end) {
3428
3645
  const tag = reader.uint32();
3429
3646
  switch (tag >>> 3) {
3430
- case 1:
3647
+ case 1: {
3431
3648
  obj.numPeers = reader.uint64();
3432
3649
  break;
3433
- default:
3650
+ }
3651
+ default: {
3434
3652
  reader.skipType(tag & 7);
3435
3653
  break;
3654
+ }
3436
3655
  }
3437
3656
  }
3438
3657
  return obj;
@@ -3443,8 +3662,8 @@ var PeerExchangeQuery;
3443
3662
  PeerExchangeQuery.encode = (obj) => {
3444
3663
  return encodeMessage(obj, PeerExchangeQuery.codec());
3445
3664
  };
3446
- PeerExchangeQuery.decode = (buf) => {
3447
- return decodeMessage(buf, PeerExchangeQuery.codec());
3665
+ PeerExchangeQuery.decode = (buf, opts) => {
3666
+ return decodeMessage(buf, PeerExchangeQuery.codec(), opts);
3448
3667
  };
3449
3668
  })(PeerExchangeQuery || (PeerExchangeQuery = {}));
3450
3669
  var PeerExchangeResponse;
@@ -3465,7 +3684,7 @@ var PeerExchangeResponse;
3465
3684
  if (opts.lengthDelimited !== false) {
3466
3685
  w.ldelim();
3467
3686
  }
3468
- }, (reader, length) => {
3687
+ }, (reader, length, opts = {}) => {
3469
3688
  const obj = {
3470
3689
  peerInfos: []
3471
3690
  };
@@ -3473,12 +3692,19 @@ var PeerExchangeResponse;
3473
3692
  while (reader.pos < end) {
3474
3693
  const tag = reader.uint32();
3475
3694
  switch (tag >>> 3) {
3476
- case 1:
3477
- obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32()));
3695
+ case 1: {
3696
+ if (opts.limits?.peerInfos != null && obj.peerInfos.length === opts.limits.peerInfos) {
3697
+ throw new CodeError('decode error - map field "peerInfos" had too many elements', 'ERR_MAX_LENGTH');
3698
+ }
3699
+ obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32(), {
3700
+ limits: opts.limits?.peerInfos$
3701
+ }));
3478
3702
  break;
3479
- default:
3703
+ }
3704
+ default: {
3480
3705
  reader.skipType(tag & 7);
3481
3706
  break;
3707
+ }
3482
3708
  }
3483
3709
  }
3484
3710
  return obj;
@@ -3489,8 +3715,8 @@ var PeerExchangeResponse;
3489
3715
  PeerExchangeResponse.encode = (obj) => {
3490
3716
  return encodeMessage(obj, PeerExchangeResponse.codec());
3491
3717
  };
3492
- PeerExchangeResponse.decode = (buf) => {
3493
- return decodeMessage(buf, PeerExchangeResponse.codec());
3718
+ PeerExchangeResponse.decode = (buf, opts) => {
3719
+ return decodeMessage(buf, PeerExchangeResponse.codec(), opts);
3494
3720
  };
3495
3721
  })(PeerExchangeResponse || (PeerExchangeResponse = {}));
3496
3722
  var PeerExchangeRPC;
@@ -3513,21 +3739,28 @@ var PeerExchangeRPC;
3513
3739
  if (opts.lengthDelimited !== false) {
3514
3740
  w.ldelim();
3515
3741
  }
3516
- }, (reader, length) => {
3742
+ }, (reader, length, opts = {}) => {
3517
3743
  const obj = {};
3518
3744
  const end = length == null ? reader.len : reader.pos + length;
3519
3745
  while (reader.pos < end) {
3520
3746
  const tag = reader.uint32();
3521
3747
  switch (tag >>> 3) {
3522
- case 1:
3523
- obj.query = PeerExchangeQuery.codec().decode(reader, reader.uint32());
3748
+ case 1: {
3749
+ obj.query = PeerExchangeQuery.codec().decode(reader, reader.uint32(), {
3750
+ limits: opts.limits?.query
3751
+ });
3524
3752
  break;
3525
- case 2:
3526
- obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32());
3753
+ }
3754
+ case 2: {
3755
+ obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32(), {
3756
+ limits: opts.limits?.response
3757
+ });
3527
3758
  break;
3528
- default:
3759
+ }
3760
+ default: {
3529
3761
  reader.skipType(tag & 7);
3530
3762
  break;
3763
+ }
3531
3764
  }
3532
3765
  }
3533
3766
  return obj;
@@ -3538,8 +3771,8 @@ var PeerExchangeRPC;
3538
3771
  PeerExchangeRPC.encode = (obj) => {
3539
3772
  return encodeMessage(obj, PeerExchangeRPC.codec());
3540
3773
  };
3541
- PeerExchangeRPC.decode = (buf) => {
3542
- return decodeMessage(buf, PeerExchangeRPC.codec());
3774
+ PeerExchangeRPC.decode = (buf, opts) => {
3775
+ return decodeMessage(buf, PeerExchangeRPC.codec(), opts);
3543
3776
  };
3544
3777
  })(PeerExchangeRPC || (PeerExchangeRPC = {}));
3545
3778
 
@@ -3570,7 +3803,7 @@ var WakuMetadataRequest;
3570
3803
  if (opts.lengthDelimited !== false) {
3571
3804
  w.ldelim();
3572
3805
  }
3573
- }, (reader, length) => {
3806
+ }, (reader, length, opts = {}) => {
3574
3807
  const obj = {
3575
3808
  shards: []
3576
3809
  };
@@ -3578,15 +3811,21 @@ var WakuMetadataRequest;
3578
3811
  while (reader.pos < end) {
3579
3812
  const tag = reader.uint32();
3580
3813
  switch (tag >>> 3) {
3581
- case 1:
3814
+ case 1: {
3582
3815
  obj.clusterId = reader.uint32();
3583
3816
  break;
3584
- case 2:
3817
+ }
3818
+ case 2: {
3819
+ if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
3820
+ throw new CodeError('decode error - map field "shards" had too many elements', 'ERR_MAX_LENGTH');
3821
+ }
3585
3822
  obj.shards.push(reader.uint32());
3586
3823
  break;
3587
- default:
3824
+ }
3825
+ default: {
3588
3826
  reader.skipType(tag & 7);
3589
3827
  break;
3828
+ }
3590
3829
  }
3591
3830
  }
3592
3831
  return obj;
@@ -3597,8 +3836,8 @@ var WakuMetadataRequest;
3597
3836
  WakuMetadataRequest.encode = (obj) => {
3598
3837
  return encodeMessage(obj, WakuMetadataRequest.codec());
3599
3838
  };
3600
- WakuMetadataRequest.decode = (buf) => {
3601
- return decodeMessage(buf, WakuMetadataRequest.codec());
3839
+ WakuMetadataRequest.decode = (buf, opts) => {
3840
+ return decodeMessage(buf, WakuMetadataRequest.codec(), opts);
3602
3841
  };
3603
3842
  })(WakuMetadataRequest || (WakuMetadataRequest = {}));
3604
3843
  var WakuMetadataResponse;
@@ -3623,7 +3862,7 @@ var WakuMetadataResponse;
3623
3862
  if (opts.lengthDelimited !== false) {
3624
3863
  w.ldelim();
3625
3864
  }
3626
- }, (reader, length) => {
3865
+ }, (reader, length, opts = {}) => {
3627
3866
  const obj = {
3628
3867
  shards: []
3629
3868
  };
@@ -3631,15 +3870,21 @@ var WakuMetadataResponse;
3631
3870
  while (reader.pos < end) {
3632
3871
  const tag = reader.uint32();
3633
3872
  switch (tag >>> 3) {
3634
- case 1:
3873
+ case 1: {
3635
3874
  obj.clusterId = reader.uint32();
3636
3875
  break;
3637
- case 2:
3876
+ }
3877
+ case 2: {
3878
+ if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
3879
+ throw new CodeError('decode error - map field "shards" had too many elements', 'ERR_MAX_LENGTH');
3880
+ }
3638
3881
  obj.shards.push(reader.uint32());
3639
3882
  break;
3640
- default:
3883
+ }
3884
+ default: {
3641
3885
  reader.skipType(tag & 7);
3642
3886
  break;
3887
+ }
3643
3888
  }
3644
3889
  }
3645
3890
  return obj;
@@ -3650,13 +3895,13 @@ var WakuMetadataResponse;
3650
3895
  WakuMetadataResponse.encode = (obj) => {
3651
3896
  return encodeMessage(obj, WakuMetadataResponse.codec());
3652
3897
  };
3653
- WakuMetadataResponse.decode = (buf) => {
3654
- return decodeMessage(buf, WakuMetadataResponse.codec());
3898
+ WakuMetadataResponse.decode = (buf, opts) => {
3899
+ return decodeMessage(buf, WakuMetadataResponse.codec(), opts);
3655
3900
  };
3656
3901
  })(WakuMetadataResponse || (WakuMetadataResponse = {}));
3657
3902
 
3658
3903
  const log = new Logger("message:version-0");
3659
- const OneMillion = BigInt(1000000);
3904
+ const OneMillion = BigInt(1_000_000);
3660
3905
  const Version = 0;
3661
3906
  class DecodedMessage {
3662
3907
  pubsubTopic;