libp2p 0.36.0 → 0.36.2-199395d

package/src/errors.ts

@@ -0,0 +1,71 @@
+export enum messages {
+  NOT_STARTED_YET = 'The libp2p node is not started yet',
+  DHT_DISABLED = 'DHT is not available',
+  CONN_ENCRYPTION_REQUIRED = 'At least one connection encryption module is required',
+  ERR_TRANSPORTS_REQUIRED = 'At least one transport module is required',
+  ERR_PROTECTOR_REQUIRED = 'Private network is enforced, but no protector was provided',
+  NOT_FOUND = 'Not found'
+}
+
+export enum codes {
+  DHT_DISABLED = 'ERR_DHT_DISABLED',
+  PUBSUB_NOT_STARTED = 'ERR_PUBSUB_NOT_STARTED',
+  DHT_NOT_STARTED = 'ERR_DHT_NOT_STARTED',
+  CONN_ENCRYPTION_REQUIRED = 'ERR_CONN_ENCRYPTION_REQUIRED',
+  ERR_TRANSPORTS_REQUIRED = 'ERR_TRANSPORTS_REQUIRED',
+  ERR_PROTECTOR_REQUIRED = 'ERR_PROTECTOR_REQUIRED',
+  ERR_PEER_DIAL_INTERCEPTED = 'ERR_PEER_DIAL_INTERCEPTED',
+  ERR_CONNECTION_INTERCEPTED = 'ERR_CONNECTION_INTERCEPTED',
+  ERR_INVALID_PROTOCOLS_FOR_STREAM = 'ERR_INVALID_PROTOCOLS_FOR_STREAM',
+  ERR_CONNECTION_ENDED = 'ERR_CONNECTION_ENDED',
+  ERR_CONNECTION_FAILED = 'ERR_CONNECTION_FAILED',
+  ERR_NODE_NOT_STARTED = 'ERR_NODE_NOT_STARTED',
+  ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',
+  ERR_TOO_MANY_ADDRESSES = 'ERR_TOO_MANY_ADDRESSES',
+  ERR_NO_VALID_ADDRESSES = 'ERR_NO_VALID_ADDRESSES',
+  ERR_RELAYED_DIAL = 'ERR_RELAYED_DIAL',
+  ERR_DIALED_SELF = 'ERR_DIALED_SELF',
+  ERR_DISCOVERED_SELF = 'ERR_DISCOVERED_SELF',
+  ERR_DUPLICATE_TRANSPORT = 'ERR_DUPLICATE_TRANSPORT',
+  ERR_ENCRYPTION_FAILED = 'ERR_ENCRYPTION_FAILED',
+  ERR_HOP_REQUEST_FAILED = 'ERR_HOP_REQUEST_FAILED',
+  ERR_INVALID_KEY = 'ERR_INVALID_KEY',
+  ERR_INVALID_MESSAGE = 'ERR_INVALID_MESSAGE',
+  ERR_INVALID_PARAMETERS = 'ERR_INVALID_PARAMETERS',
+  ERR_INVALID_PEER = 'ERR_INVALID_PEER',
+  ERR_MUXER_UNAVAILABLE = 'ERR_MUXER_UNAVAILABLE',
+  ERR_NOT_FOUND = 'ERR_NOT_FOUND',
+  ERR_TIMEOUT = 'ERR_TIMEOUT',
+  ERR_TRANSPORT_UNAVAILABLE = 'ERR_TRANSPORT_UNAVAILABLE',
+  ERR_TRANSPORT_DIAL_FAILED = 'ERR_TRANSPORT_DIAL_FAILED',
+  ERR_UNSUPPORTED_PROTOCOL = 'ERR_UNSUPPORTED_PROTOCOL',
+  ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED = 'ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED',
+  ERR_INVALID_MULTIADDR = 'ERR_INVALID_MULTIADDR',
+  ERR_SIGNATURE_NOT_VALID = 'ERR_SIGNATURE_NOT_VALID',
+  ERR_FIND_SELF = 'ERR_FIND_SELF',
+  ERR_NO_ROUTERS_AVAILABLE = 'ERR_NO_ROUTERS_AVAILABLE',
+  ERR_CONNECTION_NOT_MULTIPLEXED = 'ERR_CONNECTION_NOT_MULTIPLEXED',
+  ERR_NO_DIAL_TOKENS = 'ERR_NO_DIAL_TOKENS',
+  ERR_KEYCHAIN_REQUIRED = 'ERR_KEYCHAIN_REQUIRED',
+  ERR_INVALID_CMS = 'ERR_INVALID_CMS',
+  ERR_MISSING_KEYS = 'ERR_MISSING_KEYS',
+  ERR_NO_KEY = 'ERR_NO_KEY',
+  ERR_INVALID_KEY_NAME = 'ERR_INVALID_KEY_NAME',
+  ERR_INVALID_KEY_TYPE = 'ERR_INVALID_KEY_TYPE',
+  ERR_KEY_ALREADY_EXISTS = 'ERR_KEY_ALREADY_EXISTS',
+  ERR_INVALID_KEY_SIZE = 'ERR_INVALID_KEY_SIZE',
+  ERR_KEY_NOT_FOUND = 'ERR_KEY_NOT_FOUND',
+  ERR_OLD_KEY_NAME_INVALID = 'ERR_OLD_KEY_NAME_INVALID',
+  ERR_NEW_KEY_NAME_INVALID = 'ERR_NEW_KEY_NAME_INVALID',
+  ERR_PASSWORD_REQUIRED = 'ERR_PASSWORD_REQUIRED',
+  ERR_PEM_REQUIRED = 'ERR_PEM_REQUIRED',
+  ERR_CANNOT_READ_KEY = 'ERR_CANNOT_READ_KEY',
+  ERR_MISSING_PRIVATE_KEY = 'ERR_MISSING_PRIVATE_KEY',
+  ERR_MISSING_PUBLIC_KEY = 'ERR_MISSING_PUBLIC_KEY',
+  ERR_INVALID_OLD_PASS_TYPE = 'ERR_INVALID_OLD_PASS_TYPE',
+  ERR_INVALID_NEW_PASS_TYPE = 'ERR_INVALID_NEW_PASS_TYPE',
+  ERR_INVALID_PASS_LENGTH = 'ERR_INVALID_PASS_LENGTH',
+  ERR_NOT_IMPLEMENTED = 'ERR_NOT_IMPLEMENTED',
+  ERR_WRONG_PING_ACK = 'ERR_WRONG_PING_ACK',
+  ERR_INVALID_RECORD = 'ERR_INVALID_RECORD'
+}

package/src/fetch/README.md

@@ -12,7 +12,7 @@ The fetch protocol is a simple protocol for requesting a value corresponding to
 ## Usage
 
 ```javascript
-const Libp2p = require('libp2p')
+import { createLibp2p } from 'libp2p'
 
 /**
  * Given a key (as a string) returns a value (as a Uint8Array), or null if the key isn't found.

package/src/fetch/constants.ts

@@ -0,0 +1,3 @@
+
+// https://github.com/libp2p/specs/tree/master/fetch#wire-protocol
+export const PROTOCOL = '/libp2p/fetch/0.0.1'

package/src/fetch/{index.js → index.ts}

@@ -1,24 +1,30 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:fetch'), {
-  error: debug('libp2p:fetch:err')
-})
-const errCode = require('err-code')
-const { codes } = require('../errors')
-const lp = require('it-length-prefixed')
-const { FetchRequest, FetchResponse } = require('./proto')
-// @ts-ignore it-handshake does not export types
-const handshake = require('it-handshake')
-const { PROTOCOL } = require('./constants')
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import { codes } from '../errors.js'
+import * as lp from 'it-length-prefixed'
+import { FetchRequest, FetchResponse } from './pb/proto.js'
+import { handshake } from 'it-handshake'
+import { PROTOCOL } from './constants.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Startable } from '@libp2p/interfaces'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:fetch')
+
+export interface FetchInit {
+  protocolPrefix: string
+}
 
-/**
- * @typedef {import('../')} Libp2p
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- * @typedef {(key: string) => Promise<Uint8Array | null>} LookupFunction
- */
+export interface HandleMessageOptions {
+  stream: Stream
+  protocol: string
+}
+
+export interface LookupFunction {
+  (key: string): Promise<Uint8Array | null>
+}
 
 /**
  * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
@@ -26,36 +32,54 @@ const { PROTOCOL } = require('./constants')
  * a given key.  Each lookup function must act on a distinct part of the overall key space, defined
  * by a fixed prefix that all keys that should be routed to that lookup function will start with.
  */
-class FetchProtocol {
-  /**
-   * @param {Libp2p} libp2p
-   */
-  constructor (libp2p) {
-    this._lookupFunctions = new Map() // Maps key prefix to value lookup function
-    this._libp2p = libp2p
+export class FetchService implements Startable {
+  private readonly components: Components
+  private readonly lookupFunctions: Map<string, LookupFunction>
+  private readonly protocol: string
+  private started: boolean
+
+  constructor (components: Components, init: FetchInit) {
+    this.started = false
+    this.components = components
+    this.protocol = PROTOCOL
+    this.lookupFunctions = new Map() // Maps key prefix to value lookup function
     this.handleMessage = this.handleMessage.bind(this)
   }
 
+  async start () {
+    await this.components.getRegistrar().handle(this.protocol, (data) => {
+      void this.handleMessage(data).catch(err => {
+        log.error(err)
+      })
+    })
+    this.started = true
+  }
+
+  async stop () {
+    await this.components.getRegistrar().unhandle(this.protocol)
+    this.started = false
+  }
+
+  isStarted () {
+    return this.started
+  }
+
   /**
-   * Sends a request to fetch the value associated with the given key from the given peer.
-   *
-   * @param {PeerId|Multiaddr} peer
-   * @param {string} key
-   * @returns {Promise<Uint8Array | null>}
+   * Sends a request to fetch the value associated with the given key from the given peer
    */
-  async fetch (peer, key) {
-    // @ts-ignore multiaddr might not have toB58String
-    log('dialing %s to %s', this._protocol, peer.toB58String ? peer.toB58String() : peer)
+  async fetch (peer: PeerId, key: string): Promise<Uint8Array | null> {
+    log('dialing %s to %p', this.protocol, peer)
 
-    const connection = await this._libp2p.dial(peer)
-    const { stream } = await connection.newStream(FetchProtocol.PROTOCOL)
+    const connection = await this.components.getDialer().dial(peer)
+    const { stream } = await connection.newStream([this.protocol])
     const shake = handshake(stream)
 
     // send message
     const request = new FetchRequest({ identifier: key })
-    shake.write(lp.encode.single(FetchRequest.encode(request).finish()))
+    shake.write(lp.encode.single(FetchRequest.encode(request).finish()).slice())
 
     // read response
+    // @ts-expect-error fromReader returns a Source which has no .next method
     const response = FetchResponse.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
     switch (response.status) {
       case (FetchResponse.StatusCode.OK): {
@@ -78,21 +102,18 @@ class FetchProtocol {
    * Invoked when a fetch request is received.  Reads the request message off the given stream and
    * responds based on looking up the key in the request via the lookup callback that corresponds
    * to the key's prefix.
-   *
-   * @param {object} options
-   * @param {MuxedStream} options.stream
-   * @param {string} options.protocol
    */
-  async handleMessage (options) {
-    const { stream } = options
+  async handleMessage (data: IncomingStreamData) {
+    const { stream } = data
     const shake = handshake(stream)
+    // @ts-expect-error fromReader returns a Source which has no .next method
     const request = FetchRequest.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
 
     let response
     const lookup = this._getLookupFunction(request.identifier)
-    if (lookup) {
+    if (lookup != null) {
       const data = await lookup(request.identifier)
-      if (data) {
+      if (data != null) {
         response = new FetchResponse({ status: FetchResponse.StatusCode.OK, data })
       } else {
         response = new FetchResponse({ status: FetchResponse.StatusCode.NOT_FOUND })
@@ -102,58 +123,46 @@ class FetchProtocol {
       response = new FetchResponse({ status: FetchResponse.StatusCode.ERROR, data: errmsg })
     }
 
-    shake.write(lp.encode.single(FetchResponse.encode(response).finish()))
+    shake.write(lp.encode.single(FetchResponse.encode(response).finish()).slice())
   }
 
   /**
    * Given a key, finds the appropriate function for looking up its corresponding value, based on
    * the key's prefix.
-   *
-   * @param {string} key
    */
-  _getLookupFunction (key) {
-    for (const prefix of this._lookupFunctions.keys()) {
+  _getLookupFunction (key: string) {
+    for (const prefix of this.lookupFunctions.keys()) {
       if (key.startsWith(prefix)) {
-        return this._lookupFunctions.get(prefix)
+        return this.lookupFunctions.get(prefix)
       }
     }
-    return null
   }
 
   /**
    * Registers a new lookup callback that can map keys to values, for a given set of keys that
-   * share the same prefix.
-   *
-   * @param {string} prefix
-   * @param {LookupFunction} lookup
+   * share the same prefix
    */
-  registerLookupFunction (prefix, lookup) {
-    if (this._lookupFunctions.has(prefix)) {
+  registerLookupFunction (prefix: string, lookup: LookupFunction) {
+    if (this.lookupFunctions.has(prefix)) {
       throw errCode(new Error("Fetch protocol handler for key prefix '" + prefix + "' already registered"), codes.ERR_KEY_ALREADY_EXISTS)
     }
-    this._lookupFunctions.set(prefix, lookup)
+
+    this.lookupFunctions.set(prefix, lookup)
   }
 
   /**
    * Registers a new lookup callback that can map keys to values, for a given set of keys that
    * share the same prefix.
-   *
-   * @param {string} prefix
-   * @param {LookupFunction} [lookup]
    */
-  unregisterLookupFunction (prefix, lookup) {
+  unregisterLookupFunction (prefix: string, lookup?: LookupFunction) {
     if (lookup != null) {
-      const existingLookup = this._lookupFunctions.get(prefix)
+      const existingLookup = this.lookupFunctions.get(prefix)
 
       if (existingLookup !== lookup) {
         return
       }
     }
 
-    this._lookupFunctions.delete(prefix)
+    this.lookupFunctions.delete(prefix)
   }
 }
-
-FetchProtocol.PROTOCOL = PROTOCOL
-
-exports = module.exports = FetchProtocol

package/src/fetch/pb/proto.js

@@ -0,0 +1,331 @@
+/*eslint-disable*/
+import $protobuf from "protobufjs/minimal.js";
+
+// Common aliases
+const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+const $root = $protobuf.roots["libp2p-fetch"] || ($protobuf.roots["libp2p-fetch"] = {});
+
+export const FetchRequest = $root.FetchRequest = (() => {
+
+    /**
+     * Properties of a FetchRequest.
+     * @exports IFetchRequest
+     * @interface IFetchRequest
+     * @property {string|null} [identifier] FetchRequest identifier
+     */
+
+    /**
+     * Constructs a new FetchRequest.
+     * @exports FetchRequest
+     * @classdesc Represents a FetchRequest.
+     * @implements IFetchRequest
+     * @constructor
+     * @param {IFetchRequest=} [p] Properties to set
+     */
+    function FetchRequest(p) {
+        if (p)
+            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
+                if (p[ks[i]] != null)
+                    this[ks[i]] = p[ks[i]];
+    }
+
+    /**
+     * FetchRequest identifier.
+     * @member {string} identifier
+     * @memberof FetchRequest
+     * @instance
+     */
+    FetchRequest.prototype.identifier = "";
+
+    /**
+     * Encodes the specified FetchRequest message. Does not implicitly {@link FetchRequest.verify|verify} messages.
+     * @function encode
+     * @memberof FetchRequest
+     * @static
+     * @param {IFetchRequest} m FetchRequest message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    FetchRequest.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.identifier != null && Object.hasOwnProperty.call(m, "identifier"))
+            w.uint32(10).string(m.identifier);
+        return w;
+    };
+
+    /**
+     * Decodes a FetchRequest message from the specified reader or buffer.
+     * @function decode
+     * @memberof FetchRequest
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {FetchRequest} FetchRequest
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    FetchRequest.decode = function decode(r, l) {
+        if (!(r instanceof $Reader))
+            r = $Reader.create(r);
+        var c = l === undefined ? r.len : r.pos + l, m = new $root.FetchRequest();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.identifier = r.string();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a FetchRequest message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof FetchRequest
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {FetchRequest} FetchRequest
+     */
+    FetchRequest.fromObject = function fromObject(d) {
+        if (d instanceof $root.FetchRequest)
+            return d;
+        var m = new $root.FetchRequest();
+        if (d.identifier != null) {
+            m.identifier = String(d.identifier);
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a FetchRequest message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof FetchRequest
+     * @static
+     * @param {FetchRequest} m FetchRequest
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    FetchRequest.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.defaults) {
+            d.identifier = "";
+        }
+        if (m.identifier != null && m.hasOwnProperty("identifier")) {
+            d.identifier = m.identifier;
+        }
+        return d;
+    };
+
+    /**
+     * Converts this FetchRequest to JSON.
+     * @function toJSON
+     * @memberof FetchRequest
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    FetchRequest.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return FetchRequest;
+})();
+
+export const FetchResponse = $root.FetchResponse = (() => {
+
+    /**
+     * Properties of a FetchResponse.
+     * @exports IFetchResponse
+     * @interface IFetchResponse
+     * @property {FetchResponse.StatusCode|null} [status] FetchResponse status
+     * @property {Uint8Array|null} [data] FetchResponse data
+     */
+
+    /**
+     * Constructs a new FetchResponse.
+     * @exports FetchResponse
+     * @classdesc Represents a FetchResponse.
+     * @implements IFetchResponse
+     * @constructor
+     * @param {IFetchResponse=} [p] Properties to set
+     */
+    function FetchResponse(p) {
+        if (p)
+            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
+                if (p[ks[i]] != null)
+                    this[ks[i]] = p[ks[i]];
+    }
+
+    /**
+     * FetchResponse status.
+     * @member {FetchResponse.StatusCode} status
+     * @memberof FetchResponse
+     * @instance
+     */
+    FetchResponse.prototype.status = 0;
+
+    /**
+     * FetchResponse data.
+     * @member {Uint8Array} data
+     * @memberof FetchResponse
+     * @instance
+     */
+    FetchResponse.prototype.data = $util.newBuffer([]);
+
+    /**
+     * Encodes the specified FetchResponse message. Does not implicitly {@link FetchResponse.verify|verify} messages.
+     * @function encode
+     * @memberof FetchResponse
+     * @static
+     * @param {IFetchResponse} m FetchResponse message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    FetchResponse.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.status != null && Object.hasOwnProperty.call(m, "status"))
+            w.uint32(8).int32(m.status);
+        if (m.data != null && Object.hasOwnProperty.call(m, "data"))
+            w.uint32(18).bytes(m.data);
+        return w;
+    };
+
+    /**
+     * Decodes a FetchResponse message from the specified reader or buffer.
+     * @function decode
+     * @memberof FetchResponse
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {FetchResponse} FetchResponse
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    FetchResponse.decode = function decode(r, l) {
+        if (!(r instanceof $Reader))
+            r = $Reader.create(r);
+        var c = l === undefined ? r.len : r.pos + l, m = new $root.FetchResponse();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.status = r.int32();
+                break;
+            case 2:
+                m.data = r.bytes();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a FetchResponse message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof FetchResponse
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {FetchResponse} FetchResponse
+     */
+    FetchResponse.fromObject = function fromObject(d) {
+        if (d instanceof $root.FetchResponse)
+            return d;
+        var m = new $root.FetchResponse();
+        switch (d.status) {
+        case "OK":
+        case 0:
+            m.status = 0;
+            break;
+        case "NOT_FOUND":
+        case 1:
+            m.status = 1;
+            break;
+        case "ERROR":
+        case 2:
+            m.status = 2;
+            break;
+        }
+        if (d.data != null) {
+            if (typeof d.data === "string")
+                $util.base64.decode(d.data, m.data = $util.newBuffer($util.base64.length(d.data)), 0);
+            else if (d.data.length)
+                m.data = d.data;
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a FetchResponse message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof FetchResponse
+     * @static
+     * @param {FetchResponse} m FetchResponse
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    FetchResponse.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.defaults) {
+            d.status = o.enums === String ? "OK" : 0;
+            if (o.bytes === String)
+                d.data = "";
+            else {
+                d.data = [];
+                if (o.bytes !== Array)
+                    d.data = $util.newBuffer(d.data);
+            }
+        }
+        if (m.status != null && m.hasOwnProperty("status")) {
+            d.status = o.enums === String ? $root.FetchResponse.StatusCode[m.status] : m.status;
+        }
+        if (m.data != null && m.hasOwnProperty("data")) {
+            d.data = o.bytes === String ? $util.base64.encode(m.data, 0, m.data.length) : o.bytes === Array ? Array.prototype.slice.call(m.data) : m.data;
+        }
+        return d;
+    };
+
+    /**
+     * Converts this FetchResponse to JSON.
+     * @function toJSON
+     * @memberof FetchResponse
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    FetchResponse.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * StatusCode enum.
+     * @name FetchResponse.StatusCode
+     * @enum {number}
+     * @property {number} OK=0 OK value
+     * @property {number} NOT_FOUND=1 NOT_FOUND value
+     * @property {number} ERROR=2 ERROR value
+     */
+    FetchResponse.StatusCode = (function() {
+        const valuesById = {}, values = Object.create(valuesById);
+        values[valuesById[0] = "OK"] = 0;
+        values[valuesById[1] = "NOT_FOUND"] = 1;
+        values[valuesById[2] = "ERROR"] = 2;
+        return values;
+    })();
+
+    return FetchResponse;
+})();
+
+export { $root as default };