From 10602b9ac44e76f3d51312eff5da91ffc3f60806 Mon Sep 17 00:00:00 2001 From: Jacob Heun Date: Mon, 29 Jul 2019 15:22:53 +0200 Subject: [PATCH] refactor: testing refactor switch merge (#1) * chore: update contributors * chore: release version v0.29.0 * fix: move emitters to last thing in the method (#218) * fix: move emitters to last thing in the method * fix: setImmediate everything * chore: update contributors * chore: release version v0.29.1 * fix: move 'pull-stream' from devDependencies to dependencies (#220) 'pull-stream' package is needed in dependencies because it is used in './src/limit-dialer/queue.js'. * chore: update deps * chore: update contributors * chore: release version v0.29.2 * feat: dial to PeerId and/or Multiaddr in addition to PeerInfo (#222) * chore: update deps * feat: support dial to peerId and/or multiaddr in adition to peerInfo * chore: update CI * chore: update contributors * chore: release version v0.30.0 * chore: no sauce * chore: update deps * chore: update contributors * chore: release version v0.31.0 * fix: use the right callback * chore: update deps * chore: update contributors * chore: release version v0.31.1 * feat: increase maxListeners to Infinity (#226) * feat: increase maxListeners to Infinity https://github.com/ipfs/js-ipfs-bitswap/pull/142#discussion_r135128237 * fix linting * chore: update deps * chore: update contributors * chore: release version v0.31.2 * feat: p2p addrs situation (#229) * chore: update gitignore and CI * chore: update deps * test: update tests to new p2p-webrtc-star multiaddr format * chore: update contributors * chore: release version v0.32.0 * chore: update deps * chore: update contributors * chore: release version v0.32.1 * fix: remove unused protocol-buffers dep (#230) * chore: update contributors * chore: release version v0.32.2 * chore: update deps * chore: update contributors * chore: release version v0.32.3 * chore: update deps * fix: increase dial timeout * chore: update contributors * chore: release version v0.32.4 * feat: Circuit Relay (#224) * chore: update deps * chore: update contributors * chore: release version v0.33.0 * fix: don't dial on relay if not enabled (#234) * chore: update deps * chore: fix package.json * chore: update contributors * chore: release version v0.33.1 * chore: update deps * fix: don't dial circuit if no transports available (#236) * chore: update contributors * chore: release version v0.33.2 * fix: circuit dialing * feat: fix circuit dialing * chore: upgrade deps * chore: update circle ci config * chore: adding missing dev dependency * fix: removing unused dependency * test: adding tests * fix: remove unused dep * chore: updating CI files (#238) * chore: update contributors * chore: release version v0.34.0 * chore: use latest SECIO API * chore: update deps * feat: use latest secio API * chore: update deps * chore: update contributors * chore: release version v0.35.0 * chore: update deps * chore: update contributors * chore: release version v0.35.1 * docs: update name references and API touches * chore: update name references * refactor: update name to switch, make it a class and rename start and stop methods * test: refactor tcp transport tests to avoid code duplication * test: reuse same test code for Websockets, remove code duplication * test: update aegir pre and post hooks * chore: use pre-push instead * test: update and deduplicate code on stream muxing tests * test: restructure test suits * test: refactor swarm-no-muxing tests * test: refactor circuit-relay tests * test: refactor browser tests too * style: fix linting * fix: enableCircuitRelay is async and therefore needs a callback * fix: transports.add does not need to be async at all * docs: fix badges * test: Linux does not like that we use multiple sockets with port 0 * test: fix test * chore: update contributors * chore: release version v0.36.0 * chore: update deps * chore: update contributors * chore: release version v0.36.1 * feat: use mplex, update CI * docs: typo * feat: observe traffic and expose statistics (#243) * chore: update deps * chore: update contributors * chore: release version v0.37.0 * fix: for when handler func is not defined * fix: for when peerinfo resolves to undefined * chore: update contributors * chore: release version v0.37.1 * chore: update deps * chore: update contributors * chore: release version v0.37.2 * fix: one more observer edge case * chore: update deps * chore: fix linting * test: fix transport tests before all step by increasing the timeout * chore: update contributors * chore: release version v0.37.3 * chore: update deps Chore which i think fixes this issue also https://github.com/libp2p/js-libp2p-switch/issues/235 * fix: revert version back to the current release fix for https://github.com/libp2p/js-libp2p-switch/pull/249/files#r178832198 * chore: update deps * chore: update deps * chore: update contributors * chore: update deps * test: timeout * chore: update contributors * chore: release version v0.39.0 * chore: update deps * chore: update contributors * chore: update deps * chore: update contributors * chore: release version v0.39.2 * feat: improve circuit err messages (#250) * feat: improve circuit err handling * feat: add test to to validate err when circuit not enabled * refactor: update files and add jsdocs to improve readability refactor: initial refactor of dial.js refactor: add more jsdocs to dial and clean up some code refactor: make get-peer-info more readable fix: jsdocs in dial docs: update some jsdocs refactor: make dial.js a bit easier to consume fix: fix linting docs: add more jsdocs and comments refactor: clean up dial methods and encryption order * test: add tests for get-peer-info * docs: remove answered todo comment answered at https://github.com/libp2p/js-libp2p-switch/pull/252#discussion_r184925161 * fix: dont create base conn when muxed exists * fix: tests and conflicts * chore: update deps * chore: update contributors * chore: release version v0.40.0 * test: fix require of multiplex * fix: libp2p/js-libp2p#189 Prevent self-dial * test: add selfdial test * chore: add lead maintainer * chore: update contributors * chore: update contributors * chore: release version v0.40.1 * fix: return on call to nextMuxer When the call to multistream.Dialer.select is unsuccessful, call nextMuxer to try select the next one in the list but do not continue executing callback afterwards. License: MIT Signed-off-by: Alan Shaw * fix: drop connection when stream ends unexpectedly Pull streams pass true in the error position when the sream ends. In https://github.com/multiformats/js-multistream-select/blob/5b19358b91850b528b3f93babd60d63ddcf56a99/src/select.js#L18-L21 ...we're getting lots of instances of pull-length-prefixed stream erroring early with `true` and it's passed back up to the dialer in https://github.com/libp2p/js-libp2p-switch/blob/fef2d11850379a4720bb9c736236a81a067dc901/src/dial.js#L238-L241 The `_createMuxedConnection` contains an assumption that any error that occurs when trying `_attemptMuxerUpgrade` is ok, and keeps the relveant baseConnecton in the cache. If the pull-stream has ended unexpectedly then keeping the connection arround starts causing the "already piped" errors when we try and use the it later. This PR adds a guard to avoid putting the connection back into the cache if the stream has ended. There is related work in an old PR to add a check for exactly this issue in pull-length-prefixed https://github.com/dignifiedquire/pull-length-prefixed/pull/8 ...but it's still open, so this PR adds a check for true in the error position at the site where the "already piped" errors were appearing. Once the PR on pull-length-prefixed is merged this check can be removed. It's not ideal to have it in this code as it is far removed from the source, but it fixes the issue for now. Arguably anywhere that `msDialer.handle` is called should do the same check, but we're not seeing this error occur anywhere else so to keep this PR small, I've left it as the minimal changeset to fix the issue. Of note, we had to add '/dns4/ws-star.discovery.libp2p.io/tcp/443/wss/p2p-websocket-star' to the swarm config to trigger the "already piped" errors. There is a minimal test app here https://github.com/tableflip/js-ipfs-already-piped-error Manual testing shows ~50 streams fail in the first 2 mins of running a node, and then things stabalise with ~90 active muxed connections after that. Fixes #235 Fixes https://github.com/ipfs/js-ipfs/issues/1366 See https://github.com/dignifiedquire/pull-length-prefixed/pull/8 License: MIT Signed-off-by: Oli Evans * fix: add utility methods to prevent already piped error * chore: update contributors * chore: release version v0.40.2 * fix: prevent undefined error during a mutual hangup * chore: update contributors * chore: release version v0.40.3 * feat: swap quick-lru by hashlru This removes the only dependency using generators in the ipfs/libp2p ecosystem. Next version of create-react-app will support ipfs out-of-box with this change. * chore: update contributors * chore: release version v0.40.4 * fix: stats - observer expects protocolTag * fix: re-enable stats tests in node * chore: Upgrade big.js to 5.1.2 * chore: Change require('big.js') to require('big.js').Big * chore: update contributors * chore: release version v0.40.5 * fix: no stats on multistream proto dial * fix: adjust test values * fix: handle error in protocol handshake * chore: update contributors * chore: release version v0.40.6 * chore: remove travis and circleci * Add private network support (#266) * feat: add support for private networks fix: update protector.protect usage chore: fix linting and update deps test: add secio to pnet tests docs: add private network info the readme chore: update pnet package version test: add skipped test back in and update it * fix: improve erroring around invalid peers docs: add some comments chore: update deps test: simplify identify test * chore: update contributors * chore: release version v0.40.7 * test: add sample network circuit relay tests (#275) * test: add sample network circuit relay tests * test: use ephemeral ports * chore: update deps chore: remove test pre-push chore: update test ports * chore: update contributors * chore: release version v0.40.8 * chore: update mplex and stats test numbers * feat: make switch a state machine (#278) * feat: add basic state machine functionality to switch * feat: make connections state machines * refactor: clean up logs * feat: add dialFSM to the switch * feat: add better support for closing connections * test: add tests for some uncovered lines * feat: add warning emitter for muxer upgrade failed * docs: update readme * chore: update contributors * chore: release version v0.41.0 * fix: ignore dial request when one is in progress (#283) * chore: update contributors * chore: release version v0.41.1 * fix: improve connection closing and error handling (#285) * fix: improve connection closing and error handling * test: improve identify test * chore: update deps * fix: only emit from connections if there is a listener * test: add more connection tests * chore: update libp2p-mplex * fix: dont dial an address that we have * fix: ensure circuit listens last on start * chore: update npm publish files * chore: update contributors * chore: release version v0.41.2 * fix: use retimer to avoid creating so many timers (#289) * use retimer to avoid scheduling so many timers * Fixed linting * fix: improve connection tracking and closing (#291) * chore: update deps * fix: check we have a proper transport before filtering addresses * fix: improve connection close on stop * fix: improve stat stopping * test: fix stats test * fix: improve tracking of open connections * chore: remove log * fix: stats stop in browser chore: fix linting and browser tests * fix: remove uneeded set peer info * fix: abort the base connection on close * fix: catch edge cases of dialTimeout calling back twice * fix: close all connections instead of checking peerbook peers * test: update dial fsm test waits * test: make parallel dial tests deterministic fix: improve logic around disconnecting fix: remove duplicate event handling logic * chore: fix lint * test: improve test reliability * chore: update contributors * chore: release version v0.41.3 * refactor: stat use for over forEach (#295) forEach is 10x slower than a regular for(;;) loop, and it should be avoided in hot code paths. * fix: avoid sync callback in async functions (#297) * fix: avoid sync callback in async functions * test: add error check * refactor: clean up async usage * chore: clean up * refactor: remove async waterfall usage on identify * chore: fix linting * chore: update contributors * chore: release version v0.41.4 * fix: peerBook undefined #299 * fix: reduce bundle size (#292) * fix: reduce bundle size * fix: use bignumber everywhere * chore: update deps * chore: update contributors * chore: release version v0.41.5 * fix: import async/setImmediate to avoid webpack errors (#303) * test: add pull-mplex to test suite (#305) * chore: use travis * chore: update dependencies * fix: dial in series until we have proper abort support (#306) refactor: simplify the circuit dial logic chore: remove travis windows cache refactor: clean up dial many error logic test: explicitly set correct address test(refactor): update order of echo logic and add after refactor: cleanup per feedback * chore: update contributors * chore: release version v0.41.6 * fix: peer disconnect event and improve logging performance (#309) * fix: only emit disconnects from muxed conns * fix: update disconnect logic * chore: clean up logging to prevent unneeded string formatting * chore: fix spelling * chore: update contributors * chore: release version v0.41.7 * feat: add basic dial queue to avoid many connections to peer (#310) BREAKING CHANGE: This adds a very basic dial queue peer peer. This will prevent multiple, simultaneous dial requests to the same peer from creating multiple connections. The requests will be queued per peer, and will leverage the same connection when possible. The breaking change here is that `.dial`, will no longer return a connection. js-libp2p, circuit relay, and kad-dht, which use `.dial` were not using the returned connection. So while this is a breaking change it should not break the existing libp2p stack. If custom applications are leveraging the returned connection, they will need to convert to only using the connection returned via the callback. * chore: dont log priviatized unless it actually happened * refactor: only get our addresses for filtering once * feat: update identify to include supported protocols (#311) * chore: update contributors * chore: release version v0.42.0 * fix: ensure dials always use the latest PeerInfo from the PeerBook (#312) * fix: ensure dials always use the latest PeerInfo from the PeerBook This fixes an issue where if dial is called with a new instance of PeerInfo, if it is the first dial to that peer, the queue was forever associated with that instance. This is currently the case when Circuit checks the HOP status of a potential relay. This ensures that whenever we dial, we are updating the peer book and using the latest PeerInfo in that dial request. * test: add test for get peer info * refactor: just use id with dialer queue * chore: update contributors * chore: release version v0.42.1 * fix: identify on dial (#313) * chore: update contributors * chore: release version v0.42.2 * feat: global dial queue (#314) * feat: add a general queue to limit all dials * fix: improve queue count logic and add better abort * feat: add a basic blacklist * fix: abort dial queue on error instead of stop * feat: add a crude priority lane * test: add test for blacklist error * fix: make blacklist and max dials configurable * refactor: blacklist after callback * test: improve testings around blacklisting * chore: update contributors * chore: release version v0.42.3 * fix: improve dial queue and parallel dials (#315) * feat: allow dialer queues to do many requests to a peer * fix: parallel dials and validate cancelled conns * feat: make dial timeout configurable * fix: allow already connected peers to dial immediately * refactor: add dial timeout to consts file * fix: keep better track of in progress queues * refactor: make dials race * chore: update contributors * chore: release version v0.42.4 * feat: limit the number of cold calls we can do (#316) * feat: limit the number of cold calls we can do * feat: add a backoff to blacklisting * refactor: make cold calls configurable * fix: make blacklist duration longer * fix: improve blacklisting * test: add some tests for queue * feat: add jitter to blacklist ttl * test: validate cold queue is removed * feat: purge old queues every hour * test: fix aegir post script node shutdown * fix: abort the cold call queue on manager abort * fix: improve queue cleanup and lower interval to 15 mins * fix: improve connection tracking (#318) * fix: centralize connection events and peer connects * fix: remove unneeded peerBook put * chore: update contributors * chore: release version v0.42.5 * fix: dont blacklist good peers (#319) * fix: revert to try each (#320) * chore: update contributors * chore: release version v0.42.6 * fix: missing queue (#323) * fix: improve stopping logic (#324) * chore: update contributors * chore: release version v0.42.7 * chore: add discourse badge (#327) * fix: dial self (#329) * feat: support a priority queue for dials (#325) * chore: update contributors * chore: release version v0.42.8 * fix: dont compare empty strings (#330) * chore: update contributors * chore: release version v0.42.9 * fix: resolve transport sort order in browsers (#333) * fix: resolve transport sort order in browsers * fix: update sort logic * fix: dont use peerinfo distinct (#334) * fix: dont use peerinfo distinct * refactor: remove unneeded code * refactor: clean up * refactor: fix feedback * chore: update contributors * chore: release version v0.42.10 * fix(stats): prevent 0ms timeDiff breaking movingAverage (#336) * stats - stat - prevent 0ms timeDiff breaking movingAverage * chore: remove commitlint * chore: update contributors * chore: release version v0.42.11 * fix: dont blindly add observed addresses to our list (#337) Until we can properly validate the observed address our peer tells us about, we shouldnt blindly add it to our address list. Until we have better NAT management we cant reliably validate that we're adding an appropriate address for ourselves. * fix: clear blacklist for peer when connection is established (#340) * chore: update contributors * chore: release version v0.42.12 * refactor: move switch into src/switch * refactor: cleanup switch and move tests into test dir --- package.json | 2 +- src/switch/README.md | 448 +++++++++ src/switch/connection/base.js | 126 +++ src/switch/connection/handler.js | 47 + src/switch/connection/incoming.js | 115 +++ src/switch/connection/index.js | 498 ++++++++++ src/switch/connection/manager.js | 289 ++++++ src/switch/constants.js | 12 + src/switch/dialer/index.js | 119 +++ src/switch/dialer/queue.js | 280 ++++++ src/switch/dialer/queueManager.js | 220 +++++ src/switch/errors.js | 20 + src/switch/get-peer-info.js | 49 + src/switch/index.js | 274 ++++++ src/switch/limit-dialer/index.js | 88 ++ src/switch/limit-dialer/queue.js | 109 +++ src/switch/observe-connection.js | 44 + src/switch/observer.js | 48 + src/switch/package.json | 114 +++ src/switch/plaintext.js | 20 + src/switch/protocol-muxer.js | 48 + src/switch/stats/index.js | 150 +++ src/switch/stats/old-peers.js | 15 + src/switch/stats/stat.js | 239 +++++ src/switch/transport.js | 272 ++++++ src/switch/utils.js | 60 ++ test/switch/browser.js | 12 + test/switch/circuit-relay.node.js | 366 +++++++ test/switch/connection.node.js | 452 +++++++++ test/switch/constructor.spec.js | 15 + test/switch/dial-fsm.node.js | 405 ++++++++ test/switch/dialSelf.spec.js | 85 ++ test/switch/dialer.spec.js | 230 +++++ test/switch/get-peer-info.spec.js | 102 ++ test/switch/identify.node.js | 173 ++++ test/switch/limit-dialer.node.js | 93 ++ test/switch/node.js | 14 + test/switch/pnet.node.js | 152 +++ test/switch/secio.node.js | 116 +++ test/switch/stats.node.js | 280 ++++++ test/switch/stream-muxers.node.js | 155 +++ .../swarm-muxing+webrtc-star.browser.js | 145 +++ .../switch/swarm-muxing+websockets.browser.js | 74 ++ test/switch/swarm-muxing.node.js | 248 +++++ test/switch/swarm-no-muxing.node.js | 90 ++ test/switch/switch.spec.js | 37 + test/switch/t-webrtc-star.browser.js | 83 ++ test/switch/test-data/id-1.json | 5 + test/switch/test-data/id-2.json | 5 + test/switch/test-data/ids.json | 904 ++++++++++++++++++ test/switch/transport-manager.spec.js | 290 ++++++ test/switch/transports.browser.js | 52 + test/switch/transports.node.js | 237 +++++ test/switch/utils.js | 76 ++ 54 files changed, 8601 insertions(+), 1 deletion(-) create mode 100644 src/switch/README.md create mode 100644 src/switch/connection/base.js create mode 100644 src/switch/connection/handler.js create mode 100644 src/switch/connection/incoming.js create mode 100644 src/switch/connection/index.js create mode 100644 src/switch/connection/manager.js create mode 100644 src/switch/constants.js create mode 100644 src/switch/dialer/index.js create mode 100644 src/switch/dialer/queue.js create mode 100644 src/switch/dialer/queueManager.js create mode 100644 src/switch/errors.js create mode 100644 src/switch/get-peer-info.js create mode 100644 src/switch/index.js create mode 100644 src/switch/limit-dialer/index.js create mode 100644 src/switch/limit-dialer/queue.js create mode 100644 src/switch/observe-connection.js create mode 100644 src/switch/observer.js create mode 100644 src/switch/package.json create mode 100644 src/switch/plaintext.js create mode 100644 src/switch/protocol-muxer.js create mode 100644 src/switch/stats/index.js create mode 100644 src/switch/stats/old-peers.js create mode 100644 src/switch/stats/stat.js create mode 100644 src/switch/transport.js create mode 100644 src/switch/utils.js create mode 100644 test/switch/browser.js create mode 100644 test/switch/circuit-relay.node.js create mode 100644 test/switch/connection.node.js create mode 100644 test/switch/constructor.spec.js create mode 100644 test/switch/dial-fsm.node.js create mode 100644 test/switch/dialSelf.spec.js create mode 100644 test/switch/dialer.spec.js create mode 100644 test/switch/get-peer-info.spec.js create mode 100644 test/switch/identify.node.js create mode 100644 test/switch/limit-dialer.node.js create mode 100644 test/switch/node.js create mode 100644 test/switch/pnet.node.js create mode 100644 test/switch/secio.node.js create mode 100644 test/switch/stats.node.js create mode 100644 test/switch/stream-muxers.node.js create mode 100644 test/switch/swarm-muxing+webrtc-star.browser.js create mode 100644 test/switch/swarm-muxing+websockets.browser.js create mode 100644 test/switch/swarm-muxing.node.js create mode 100644 test/switch/swarm-no-muxing.node.js create mode 100644 test/switch/switch.spec.js create mode 100644 test/switch/t-webrtc-star.browser.js create mode 100644 test/switch/test-data/id-1.json create mode 100644 test/switch/test-data/id-2.json create mode 100644 test/switch/test-data/ids.json create mode 100644 test/switch/transport-manager.spec.js create mode 100644 test/switch/transports.browser.js create mode 100644 test/switch/transports.node.js create mode 100644 test/switch/utils.js diff --git a/package.json b/package.json index 71e18a3e92..a05a54a605 100644 --- a/package.json +++ b/package.json @@ -50,7 +50,7 @@ "libp2p-connection-manager": "^0.1.0", "libp2p-floodsub": "^0.16.1", "libp2p-ping": "^0.8.5", - "libp2p-switch": "^0.42.12", + "libp2p-switch": "./src/switch", "libp2p-websockets": "^0.12.2", "mafmt": "^6.0.7", "multiaddr": "^6.1.0", diff --git a/src/switch/README.md b/src/switch/README.md new file mode 100644 index 0000000000..728adde233 --- /dev/null +++ b/src/switch/README.md @@ -0,0 +1,448 @@ +libp2p-switch JavaScript implementation +====================================== + +[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io) +[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) +[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs) +[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io) +[![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-switch)](https://travis-ci.com/libp2p/js-libp2p-switch) +[![codecov](https://codecov.io/gh/libp2p/js-libp2p-switch/branch/master/graph/badge.svg)](https://codecov.io/gh/libp2p/js-libp2p-switch) +[![Dependency Status](https://david-dm.org/libp2p/js-libp2p-switch.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-switch) +[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard) +![](https://img.shields.io/badge/npm-%3E%3D3.0.0-orange.svg?style=flat-square) +![](https://img.shields.io/badge/Node.js-%3E%3D6.0.0-orange.svg?style=flat-square) + +> libp2p-switch is a dialer machine, it leverages the multiple libp2p transports, stream muxers, crypto channels and other connection upgrades to dial to peers in the libp2p network. It also supports Protocol Multiplexing through a multicodec and multistream-select handshake. + +libp2p-switch is used by [libp2p](https://github.com/libp2p/js-libp2p) but it can be also used as a standalone module. + +## Lead Maintainer + +[Jacob Heun](https://github.com/jacobheun) + +## Table of Contents + +- [Install](#install) +- [Usage](#usage) + - [Create a libp2p switch](#create-a-libp2p-switch) +- [API](#api) + - [`switch.connection`](#switchconnection) + - [`switch.dial(peer, protocol, callback)`](#switchdialpeer-protocol-callback) + - [`switch.dialFSM(peer, protocol, callback)`](#switchdialfsmpeer-protocol-callback) + - [`switch.handle(protocol, handlerFunc, matchFunc)`](#switchhandleprotocol-handlerfunc-matchfunc) + - [`switch.hangUp(peer, callback)`](#switchhanguppeer-callback) + - [`switch.start(callback)`](#switchstartcallback) + - [`switch.stop(callback)`](#switchstopcallback) + - [`switch.stats`](#stats-api) + - [`switch.unhandle(protocol)`](#switchunhandleprotocol) + - [Internal Transports API](#internal-transports-api) +- [Design Notes](#design-notes) + - [Multitransport](#multitransport) + - [Connection upgrades](#connection-upgrades) + - [Identify](#identify) + - [Notes](#notes) +- [Contribute](#contribute) +- [License](#license) + +## Install + +```bash +> npm install libp2p-switch --save +``` + +## Usage + +### Create a libp2p Switch + +```JavaScript +const switch = require('libp2p-switch') + +const sw = new switch(peerInfo , peerBook [, options]) +``` + +If defined, `options` should be an object with the following keys and respective values: + +- `blacklistTTL`: - number of ms a peer should not be dialable to after it errors. Each successive blacklisting will increase the ttl from the base value. Defaults to 5 minutes +- `blackListAttempts`: - number of blacklists before a peer +is permanently blacklisted. Defaults to 5. +- `maxParallelDials`: - number of concurrent dials the switch should allow. Defaults to `100` +- `maxColdCalls`: - number of queued cold calls that are allowed. Defaults to `50` +- `dialTimeout`: - number of ms a dial to a peer should be allowed to run. Defaults to `30000` (30 seconds) +- `stats`: an object with the following keys and respective values: + - `maxOldPeersRetention`: maximum old peers retention. For when peers disconnect and keeping the stats around in case they reconnect. Defaults to `100`. + - `computeThrottleMaxQueueSize`: maximum queue size to perform stats computation throttling. Defaults to `1000`. + - `computeThrottleTimeout`: Throttle timeout, in miliseconds. Defaults to `2000`, + - `movingAverageIntervals`: Array containin the intervals, in miliseconds, for which moving averages are calculated. Defaults to: + + ```js + [ + 60 * 1000, // 1 minute + 5 * 60 * 1000, // 5 minutes + 15 * 60 * 1000 // 15 minutes + ] + ``` + +### Private Networks + +libp2p-switch supports private networking. In order to enabled private networks, the `switch.protector` must be +set and must contain a `protect` method. You can see an example of this in the [private network +tests]([./test/pnet.node.js]). + +## API + +- peerInfo is a [PeerInfo](https://github.com/libp2p/js-peer-info) object that has the peer information. +- peerBook is a [PeerBook](https://github.com/libp2p/js-peer-book) object that stores all the known peers. + +### `switch.connection` + +##### `switch.connection.addUpgrade()` + +A connection upgrade must be able to receive and return something that implements the [interface-connection](https://github.com/libp2p/interface-connection) specification. + +> **WIP** + +##### `switch.connection.addStreamMuxer(muxer)` + +Upgrading a connection to use a stream muxer is still considered an upgrade, but a special case since once this connection is applied, the returned obj will implement the [interface-stream-muxer](https://github.com/libp2p/interface-stream-muxer) spec. + +- `muxer` + +##### `switch.connection.reuse()` + +Enable the identify protocol. + +##### `switch.connection.crypto([tag, encrypt])` + +Enable a specified crypto protocol. By default no encryption is used, aka `plaintext`. If called with no arguments it resets to use `plaintext`. + +You can use for example [libp2p-secio](https://github.com/libp2p/js-libp2p-secio) like this + +```js +const secio = require('libp2p-secio') +switch.connection.crypto(secio.tag, secio.encrypt) +``` + +##### `switch.connection.enableCircuitRelay(options, callback)` + +Enable circuit relaying. + +- `options` + - enabled - activates relay dialing and listening functionality + - hop - an object with two properties + - enabled - enables circuit relaying + - active - is it an active or passive relay (default false) +- `callback` + +### `switch.dial(peer, protocol, callback)` + +dial uses the best transport (whatever works first, in the future we can have some criteria), and jump starts the connection until the point where we have to negotiate the protocol. If a muxer is available, then drop the muxer onto that connection. Good to warm up connections or to check for connectivity. If we have already a muxer for that peerInfo, then do nothing. + +- `peer`: can be an instance of [PeerInfo][], [PeerId][] or [multiaddr][] +- `protocol` +- `callback` + +### `switch.dialFSM(peer, protocol, callback)` + +works like dial, but calls back with a [Connection State Machine](#connection-state-machine) + +- `peer`: can be an instance of [PeerInfo][], [PeerId][] or [multiaddr][] +- `protocol`: String that defines the protocol (e.g '/ipfs/bitswap/1.1.0') to be used +- `callback`: Function with signature `function (err, connFSM) {}` where `connFSM` is a [Connection State Machine](#connection-state-machine) + +#### Connection State Machine +Connection state machines emit a number of events that can be used to determine the current state of the connection +and to received the underlying connection that can be used to transfer data. + +### `switch.dialer.connect(peer, options, callback)` + +a low priority dial to the provided peer. Calls to `dial` and `dialFSM` will take priority. This should be used when an application only wishes to establish connections to new peers, such as during peer discovery when there is a low peer count. Currently, anything greater than the HIGH_PRIORITY (10) will be placed into the cold call queue, and anything less than or equal to the HIGH_PRIORITY will be added to the normal queue. + +- `peer`: can be an instance of [PeerInfo][], [PeerId][] or [multiaddr][] +- `options`: Optional +- `options.priority`: Number of the priority of the dial, defaults to 20. +- `options.useFSM`: Boolean of whether or not to callback with a [Connection State Machine](#connection-state-machine) +- `callback`: Function with signature `function (err, connFSM) {}` where `connFSM` is a [Connection State Machine](#connection-state-machine) + +##### Events +- `error`: emitted whenever a fatal error occurs with the connection; the error will be emitted. +- `error:upgrade_failed`: emitted whenever the connection fails to upgrade with a muxer, this is not fatal. +- `error:connection_attempt_failed`: emitted whenever a dial attempt fails for a given transport. An array of errors is emitted. +- `connection`: emitted whenever a useable connection has been established; the underlying [Connection](https://github.com/libp2p/interface-connection) will be emitted. +- `close`: emitted when the connection has closed. + +### `switch.handle(protocol, handlerFunc, matchFunc)` + +Handle a new protocol. + +- `protocol` +- `handlerFunc` - function called when we receive a dial on `protocol. Signature must be `function (protocol, conn) {}` +- `matchFunc` - matchFunc for multistream-select + +### `switch.hangUp(peer, callback)` + +Hang up the muxed connection we have with the peer. + +- `peer`: can be an instance of [PeerInfo][], [PeerId][] or [multiaddr][] +- `callback` + +### `switch.on('error', (err) => {})` + +Emitted when the switch encounters an error. + +- `err`: instance of [Error][] + +### `switch.on('peer-mux-established', (peer) => {})` + +- `peer`: is instance of [PeerInfo][] that has info of the peer we have just established a muxed connection with. + +### `switch.on('peer-mux-closed', (peer) => {})` + +- `peer`: is instance of [PeerInfo][] that has info of the peer we have just closed a muxed connection with. + +### `switch.on('connection:start', (peer) => {})` +This will be triggered anytime a new connection is created. + +- `peer`: is instance of [PeerInfo][] that has info of the peer we have just started a connection with. + +### `switch.on('connection:end', (peer) => {})` +This will be triggered anytime an existing connection, regardless of state, is removed from the switch's internal connection tracking. + +- `peer`: is instance of [PeerInfo][] that has info of the peer we have just closed a connection with. + +### `switch.on('start', () => {})` + +Emitted when the switch has successfully started. + +### `switch.on('stop', () => {})` + +Emitted when the switch has successfully stopped. + +### `switch.start(callback)` + +Start listening on all added transports that are available on the current `peerInfo`. + +### `switch.stop(callback)` + +Close all the listeners and muxers. + +- `callback` + +### Stats API + +##### `switch.stats.emit('update')` + +Every time any stat value changes, this object emits an `update` event. + +#### Global stats + +##### `switch.stats.global.snapshot` + +Should return a stats snapshot, which is an object containing the following keys and respective values: + +- dataSent: amount of bytes sent, [Big](https://github.com/MikeMcl/big.js#readme) number +- dataReceived: amount of bytes received, [Big](https://github.com/MikeMcl/big.js#readme) number + +##### `switch.stats.global.movingAverages` + +Returns an object containing the following keys: + +- dataSent +- dataReceived + +Each one of them contains an object that has a key for each interval (`60000`, `300000` and `900000` miliseconds). + +Each one of these values is [an exponential moving-average instance](https://github.com/pgte/moving-average#readme). + +#### Per-transport stats + +##### `switch.stats.transports()` + +Returns an array containing the tags (string) for each observed transport. + +##### `switch.stats.forTransport(transportTag).snapshot` + +Should return a stats snapshot, which is an object containing the following keys and respective values: + +- dataSent: amount of bytes sent, [Big](https://github.com/MikeMcl/big.js#readme) number +- dataReceived: amount of bytes received, [Big](https://github.com/MikeMcl/big.js#readme) number + +##### `switch.stats.forTransport(transportTag).movingAverages` + +Returns an object containing the following keys: + + dataSent + dataReceived + +Each one of them contains an object that has a key for each interval (`60000`, `300000` and `900000` miliseconds). + +Each one of these values is [an exponential moving-average instance](https://github.com/pgte/moving-average#readme). + +#### Per-protocol stats + +##### `switch.stats.protocols()` + +Returns an array containing the tags (string) for each observed protocol. + +##### `switch.stats.forProtocol(protocolTag).snapshot` + +Should return a stats snapshot, which is an object containing the following keys and respective values: + +- dataSent: amount of bytes sent, [Big](https://github.com/MikeMcl/big.js#readme) number +- dataReceived: amount of bytes received, [Big](https://github.com/MikeMcl/big.js#readme) number + + +##### `switch.stats.forProtocol(protocolTag).movingAverages` + +Returns an object containing the following keys: + +- dataSent +- dataReceived + +Each one of them contains an object that has a key for each interval (`60000`, `300000` and `900000` miliseconds). + +Each one of these values is [an exponential moving-average instance](https://github.com/pgte/moving-average#readme). + +#### Per-peer stats + +##### `switch.stats.peers()` + +Returns an array containing the peerIDs (B58-encoded string) for each observed peer. + +##### `switch.stats.forPeer(peerId:String).snapshot` + +Should return a stats snapshot, which is an object containing the following keys and respective values: + +- dataSent: amount of bytes sent, [Big](https://github.com/MikeMcl/big.js#readme) number +- dataReceived: amount of bytes received, [Big](https://github.com/MikeMcl/big.js#readme) number + + +##### `switch.stats.forPeer(peerId:String).movingAverages` + +Returns an object containing the following keys: + +- dataSent +- dataReceived + +Each one of them contains an object that has a key for each interval (`60000`, `300000` and `900000` miliseconds). + +Each one of these values is [an exponential moving-average instance](https://github.com/pgte/moving-average#readme). + +#### Stats update interval + +Stats are not updated in real-time. Instead, measurements are buffered and stats are updated at an interval. The maximum interval can be defined through the `Switch` constructor option `stats.computeThrottleTimeout`, defined in miliseconds. + +### `switch.unhandle(protocol)` + +Unhandle a protocol. + +- `protocol` + +### Internal Transports API + +##### `switch.transport.add(key, transport, options)` + +libp2p-switch expects transports that implement [interface-transport](https://github.com/libp2p/interface-transport). For example [libp2p-tcp](https://github.com/libp2p/js-libp2p-tcp). + +- `key` - the transport identifier. +- `transport` - +- `options` - + +##### `switch.transport.dial(key, multiaddrs, callback)` + +Dial to a peer on a specific transport. + +- `key` +- `multiaddrs` +- `callback` + +##### `switch.transport.listen(key, options, handler, callback)` + +Set a transport to start listening mode. + +- `key` +- `options` +- `handler` +- `callback` + +##### `switch.transport.close(key, callback)` + +Close the listeners of a given transport. + +- `key` +- `callback` + +## Design Notes + +### Multitransport + +libp2p is designed to support multiple transports at the same time. While peers are identified by their ID (which are generated from their public keys), the addresses of each pair may vary, depending the device where they are being run or the network in which they are accessible through. + +In order for a transport to be supported, it has to follow the [interface-transport](https://github.com/libp2p/interface-transport) spec. + +### Connection upgrades + +Each connection in libp2p follows the [interface-connection](https://github.com/libp2p/interface-connection) spec. This design decision enables libp2p to have upgradable transports. + +We think of `upgrade` as a very important notion when we are talking about connections, we can see mechanisms like: stream multiplexing, congestion control, encrypted channels, multipath, simulcast, etc, as `upgrades` to a connection. A connection can be a simple and with no guarantees, drop a packet on the network with a destination thing, a transport in the other hand can be a connection and or a set of different upgrades that are mounted on top of each other, giving extra functionality to that connection and therefore `upgrading` it. + +Types of upgrades to a connection: + +- encrypted channel (with TLS for e.g) +- congestion flow (some transports don't have it by default) +- multipath (open several connections and abstract it as a single connection) +- simulcast (still really thinking this one through, it might be interesting to send a packet through different connections under some hard network circumstances) +- stream-muxer - this a special case, because once we upgrade a connection to a stream-muxer, we can open more streams (multiplex them) on a single stream, also enabling us to reuse the underlying dialed transport + +We also want to enable flexibility when it comes to upgrading a connection, for example, we might that all dialed transports pass through the encrypted channel upgrade, but not the congestion flow, specially when a transport might have already some underlying properties (UDP vs TCP vs WebRTC vs every other transport protocol) + +### Identify + +Identify is a protocol that switchs mounts on top of itself, to identify the connections between any two peers. E.g: + +- a) peer A dials a conn to peer B +- b) that conn gets upgraded to a stream multiplexer that both peers agree +- c) peer B executes de identify protocol +- d) peer B now can open streams to peer A, knowing which is the +identity of peer A + +In addition to this, we also share the "observed addresses" by the other peer, which is extremely useful information for different kinds of network topologies. + +### Notes + +To avoid the confusion between connection, stream, transport, and other names that represent an abstraction of data flow between two points, we use terms as: + +- connection - something that implements the transversal expectations of a stream between two peers, including the benefits of using a stream plus having a way to do half duplex, full duplex +- transport - something that as a dial/listen interface and return objs that implement a connection interface + +### This module uses `pull-streams` + +We expose a streaming interface based on `pull-streams`, rather then on the Node.js core streams implementation (aka Node.js streams). `pull-streams` offers us a better mechanism for error handling and flow control guarantees. If you would like to know more about why we did this, see the discussion at this [issue](https://github.com/ipfs/js-ipfs/issues/362). + +You can learn more about pull-streams at: + +- [The history of Node.js streams, nodebp April 2014](https://www.youtube.com/watch?v=g5ewQEuXjsQ) +- [The history of streams, 2016](http://dominictarr.com/post/145135293917/history-of-streams) +- [pull-streams, the simple streaming primitive](http://dominictarr.com/post/149248845122/pull-streams-pull-streams-are-a-very-simple) +- [pull-streams documentation](https://pull-stream.github.io/) + +#### Converting `pull-streams` to Node.js Streams + +If you are a Node.js streams user, you can convert a pull-stream to a Node.js stream using the module [`pull-stream-to-stream`](https://github.com/pull-stream/pull-stream-to-stream), giving you an instance of a Node.js stream that is linked to the pull-stream. For example: + +```js +const pullToStream = require('pull-stream-to-stream') + +const nodeStreamInstance = pullToStream(pullStreamInstance) +// nodeStreamInstance is an instance of a Node.js Stream +``` + +To learn more about this utility, visit https://pull-stream.github.io/#pull-stream-to-stream. + + +## Contribute + +This module is actively under development. Please check out the issues and submit PRs! + +## License + +MIT © Protocol Labs diff --git a/src/switch/connection/base.js b/src/switch/connection/base.js new file mode 100644 index 0000000000..36f7842815 --- /dev/null +++ b/src/switch/connection/base.js @@ -0,0 +1,126 @@ +'use strict' + +const EventEmitter = require('events').EventEmitter +const debug = require('debug') +const withIs = require('class-is') + +class BaseConnection extends EventEmitter { + constructor ({ _switch, name }) { + super() + + this.switch = _switch + this.ourPeerInfo = this.switch._peerInfo + this.log = debug(`libp2p:conn:${name}`) + this.log.error = debug(`libp2p:conn:${name}:error`) + } + + /** + * Puts the state into its disconnecting flow + * + * @param {Error} err Will be emitted if provided + * @returns {void} + */ + close (err) { + if (this._state._state === 'DISCONNECTING') return + this.log('closing connection to %s', this.theirB58Id) + if (err && this._events.error) { + this.emit('error', err) + } + this._state('disconnect') + } + + emit (eventName, ...args) { + if (eventName === 'error' && !this._events.error) { + this.log.error(...args) + } else { + super.emit(eventName, ...args) + } + } + + /** + * Gets the current state of the connection + * + * @returns {string} The current state of the connection + */ + getState () { + return this._state._state + } + + /** + * Puts the state into encrypting mode + * + * @returns {void} + */ + encrypt () { + this._state('encrypt') + } + + /** + * Puts the state into privatizing mode + * + * @returns {void} + */ + protect () { + this._state('privatize') + } + + /** + * Puts the state into muxing mode + * + * @returns {void} + */ + upgrade () { + this._state('upgrade') + } + + /** + * Event handler for disconnected. + * + * @fires BaseConnection#close + * @returns {void} + */ + _onDisconnected () { + this.switch.connection.remove(this) + this.log('disconnected from %s', this.theirB58Id) + this.emit('close') + this.removeAllListeners() + } + + /** + * Event handler for privatized + * + * @fires BaseConnection#private + * @returns {void} + */ + _onPrivatized () { + this.emit('private', this.conn) + } + + /** + * Wraps this.conn with the Switch.protector for private connections + * + * @private + * @fires ConnectionFSM#error + * @returns {void} + */ + _onPrivatizing () { + if (!this.switch.protector) { + return this._state('done') + } + + this.conn = this.switch.protector.protect(this.conn, (err) => { + if (err) { + return this.close(err) + } + + this.log('successfully privatized conn to %s', this.theirB58Id) + this.conn.setPeerInfo(this.theirPeerInfo) + this._state('done') + }) + } +} + +module.exports = withIs(BaseConnection, { + className: 'BaseConnection', + symbolName: 'libp2p-switch/BaseConnection' +}) diff --git a/src/switch/connection/handler.js b/src/switch/connection/handler.js new file mode 100644 index 0000000000..abed6126cb --- /dev/null +++ b/src/switch/connection/handler.js @@ -0,0 +1,47 @@ +'use strict' + +const debug = require('debug') +const IncomingConnection = require('./incoming') +const observeConn = require('../observe-connection') + +function listener (_switch) { + const log = debug(`libp2p:switch:listener`) + + /** + * Takes a transport key and returns a connection handler function + * + * @param {string} transportKey The key of the transport to handle connections for + * @param {function} handler A custom handler to use + * @returns {function(Connection)} A connection handler function + */ + return function (transportKey, handler) { + /** + * Takes a base connection and manages listening behavior + * + * @param {Connection} conn The connection to manage + * @returns {void} + */ + return function (conn) { + log('received incoming connection for transport %s', transportKey) + conn.getPeerInfo((_, peerInfo) => { + // Add a transport level observer, if needed + const connection = transportKey ? observeConn(transportKey, null, conn, _switch.observer) : conn + const connFSM = new IncomingConnection({ connection, _switch, transportKey, peerInfo }) + + connFSM.once('error', (err) => log(err)) + connFSM.once('private', (_conn) => { + // Use the custom handler, if it was provided + if (handler) { + return handler(_conn) + } + connFSM.encrypt() + }) + connFSM.once('encrypted', () => connFSM.upgrade()) + + connFSM.protect() + }) + } + } +} + +module.exports = listener diff --git a/src/switch/connection/incoming.js b/src/switch/connection/incoming.js new file mode 100644 index 0000000000..10ddfce62e --- /dev/null +++ b/src/switch/connection/incoming.js @@ -0,0 +1,115 @@ +'use strict' + +const FSM = require('fsm-event') +const multistream = require('multistream-select') +const withIs = require('class-is') + +const BaseConnection = require('./base') + +class IncomingConnectionFSM extends BaseConnection { + constructor ({ connection, _switch, transportKey, peerInfo }) { + super({ + _switch, + name: `inc:${_switch._peerInfo.id.toB58String().slice(0, 8)}` + }) + this.conn = connection + this.theirPeerInfo = peerInfo || null + this.theirB58Id = this.theirPeerInfo ? this.theirPeerInfo.id.toB58String() : null + this.ourPeerInfo = this.switch._peerInfo + this.transportKey = transportKey + this.protocolMuxer = this.switch.protocolMuxer(this.transportKey) + this.msListener = new multistream.Listener() + + this._state = FSM('DIALED', { + DISCONNECTED: { + disconnect: 'DISCONNECTED' + }, + DIALED: { // Base connection to peer established + privatize: 'PRIVATIZING', + encrypt: 'ENCRYPTING' + }, + PRIVATIZING: { // Protecting the base connection + done: 'PRIVATIZED', + disconnect: 'DISCONNECTING' + }, + PRIVATIZED: { // Base connection is protected + encrypt: 'ENCRYPTING' + }, + ENCRYPTING: { // Encrypting the base connection + done: 'ENCRYPTED', + disconnect: 'DISCONNECTING' + }, + ENCRYPTED: { // Upgrading could not happen, the connection is encrypted and waiting + upgrade: 'UPGRADING', + disconnect: 'DISCONNECTING' + }, + UPGRADING: { // Attempting to upgrade the connection with muxers + done: 'MUXED' + }, + MUXED: { + disconnect: 'DISCONNECTING' + }, + DISCONNECTING: { // Shutting down the connection + done: 'DISCONNECTED' + } + }) + + this._state.on('DISCONNECTED', () => this._onDisconnected()) + this._state.on('PRIVATIZING', () => this._onPrivatizing()) + this._state.on('PRIVATIZED', () => this._onPrivatized()) + this._state.on('ENCRYPTING', () => this._onEncrypting()) + this._state.on('ENCRYPTED', () => { + this.log('successfully encrypted connection to %s', this.theirB58Id || 'unknown peer') + this.emit('encrypted', this.conn) + }) + this._state.on('UPGRADING', () => this._onUpgrading()) + this._state.on('MUXED', () => { + this.log('successfully muxed connection to %s', this.theirB58Id || 'unknown peer') + this.emit('muxed', this.conn) + }) + this._state.on('DISCONNECTING', () => { + this._state('done') + }) + } + + /** + * Attempts to encrypt `this.conn` with the Switch's crypto. + * + * @private + * @fires IncomingConnectionFSM#error + * @returns {void} + */ + _onEncrypting () { + this.log('encrypting connection via %s', this.switch.crypto.tag) + + this.msListener.addHandler(this.switch.crypto.tag, (protocol, _conn) => { + this.conn = this.switch.crypto.encrypt(this.ourPeerInfo.id, _conn, undefined, (err) => { + if (err) { + return this.close(err) + } + this.conn.getPeerInfo((_, peerInfo) => { + this.theirPeerInfo = peerInfo + this._state('done') + }) + }) + }, null) + + // Start handling the connection + this.msListener.handle(this.conn, (err) => { + if (err) { + this.emit('crypto handshaking failed', err) + } + }) + } + + _onUpgrading () { + this.log('adding the protocol muxer to the connection') + this.protocolMuxer(this.conn, this.msListener) + this._state('done') + } +} + +module.exports = withIs(IncomingConnectionFSM, { + className: 'IncomingConnectionFSM', + symbolName: 'libp2p-switch/IncomingConnectionFSM' +}) diff --git a/src/switch/connection/index.js b/src/switch/connection/index.js new file mode 100644 index 0000000000..a2df251a2d --- /dev/null +++ b/src/switch/connection/index.js @@ -0,0 +1,498 @@ +'use strict' + +const FSM = require('fsm-event') +const Circuit = require('libp2p-circuit') +const multistream = require('multistream-select') +const withIs = require('class-is') +const BaseConnection = require('./base') +const parallel = require('async/parallel') +const nextTick = require('async/nextTick') +const identify = require('libp2p-identify') +const errCode = require('err-code') +const { msHandle, msSelect, identifyDialer } = require('../utils') + +const observeConnection = require('../observe-connection') +const { + CONNECTION_FAILED, + DIAL_SELF, + INVALID_STATE_TRANSITION, + NO_TRANSPORTS_REGISTERED, + maybeUnexpectedEnd +} = require('../errors') + +/** + * @typedef {Object} ConnectionOptions + * @property {Switch} _switch Our switch instance + * @property {PeerInfo} peerInfo The PeerInfo of the peer to dial + * @property {Muxer} muxer Optional - A muxed connection + * @property {Connection} conn Optional - The base connection + * @property {string} type Optional - identify the connection as incoming or outgoing. Defaults to out. + */ + +/** + * ConnectionFSM handles the complex logic of managing a connection + * between peers. ConnectionFSM is internally composed of a state machine + * to help improve the usability and debuggability of connections. The + * state machine also helps to improve the ability to handle dial backoff, + * coalescing dials and dial locks. + */ +class ConnectionFSM extends BaseConnection { + /** + * @param {ConnectionOptions} connectionOptions + * @constructor + */ + constructor ({ _switch, peerInfo, muxer, conn, type = 'out' }) { + super({ + _switch, + name: `${type}:${_switch._peerInfo.id.toB58String().slice(0, 8)}` + }) + + this.theirPeerInfo = peerInfo + this.theirB58Id = this.theirPeerInfo.id.toB58String() + + this.conn = conn // The base connection + this.muxer = muxer // The upgraded/muxed connection + + let startState = 'DISCONNECTED' + if (this.muxer) { + startState = 'MUXED' + } + + this._state = FSM(startState, { + DISCONNECTED: { // No active connections exist for the peer + dial: 'DIALING', + disconnect: 'DISCONNECTED', + done: 'DISCONNECTED' + }, + DIALING: { // Creating an initial connection + abort: 'ABORTED', + // emit events for different transport dials? + done: 'DIALED', + error: 'ERRORED', + disconnect: 'DISCONNECTING' + }, + DIALED: { // Base connection to peer established + encrypt: 'ENCRYPTING', + privatize: 'PRIVATIZING' + }, + PRIVATIZING: { // Protecting the base connection + done: 'PRIVATIZED', + abort: 'ABORTED', + disconnect: 'DISCONNECTING' + }, + PRIVATIZED: { // Base connection is protected + encrypt: 'ENCRYPTING' + }, + ENCRYPTING: { // Encrypting the base connection + done: 'ENCRYPTED', + error: 'ERRORED', + disconnect: 'DISCONNECTING' + }, + ENCRYPTED: { // Upgrading could not happen, the connection is encrypted and waiting + upgrade: 'UPGRADING', + disconnect: 'DISCONNECTING' + }, + UPGRADING: { // Attempting to upgrade the connection with muxers + stop: 'CONNECTED', // If we cannot mux, stop upgrading + done: 'MUXED', + error: 'ERRORED', + disconnect: 'DISCONNECTING' + }, + MUXED: { + disconnect: 'DISCONNECTING' + }, + CONNECTED: { // A non muxed connection is established + disconnect: 'DISCONNECTING' + }, + DISCONNECTING: { // Shutting down the connection + done: 'DISCONNECTED', + disconnect: 'DISCONNECTING' + }, + ABORTED: { }, // A severe event occurred + ERRORED: { // An error occurred, but future dials may be allowed + disconnect: 'DISCONNECTING' // There could be multiple options here, but this is a likely action + } + }) + + this._state.on('DISCONNECTED', () => this._onDisconnected()) + this._state.on('DIALING', () => this._onDialing()) + this._state.on('DIALED', () => this._onDialed()) + this._state.on('PRIVATIZING', () => this._onPrivatizing()) + this._state.on('PRIVATIZED', () => this._onPrivatized()) + this._state.on('ENCRYPTING', () => this._onEncrypting()) + this._state.on('ENCRYPTED', () => { + this.log('successfully encrypted connection to %s', this.theirB58Id) + this.emit('encrypted', this.conn) + }) + this._state.on('UPGRADING', () => this._onUpgrading()) + this._state.on('MUXED', () => { + this.log('successfully muxed connection to %s', this.theirB58Id) + delete this.switch.conns[this.theirB58Id] + this.emit('muxed', this.muxer) + }) + this._state.on('CONNECTED', () => { + this.log('unmuxed connection opened to %s', this.theirB58Id) + this.emit('unmuxed', this.conn) + }) + this._state.on('DISCONNECTING', () => this._onDisconnecting()) + this._state.on('ABORTED', () => this._onAborted()) + this._state.on('ERRORED', () => this._onErrored()) + this._state.on('error', (err) => this._onStateError(err)) + } + + /** + * Puts the state into dialing mode + * + * @fires ConnectionFSM#Error May emit a DIAL_SELF error + * @returns {void} + */ + dial () { + if (this.theirB58Id === this.ourPeerInfo.id.toB58String()) { + return this.emit('error', DIAL_SELF()) + } else if (this.getState() === 'DIALING') { + return this.log('attempted to dial while already dialing, ignoring') + } + + this._state('dial') + } + + /** + * Initiates a handshake for the given protocol + * + * @param {string} protocol The protocol to negotiate + * @param {function(Error, Connection)} callback + * @returns {void} + */ + shake (protocol, callback) { + // If there is no protocol set yet, don't perform the handshake + if (!protocol) { + return callback(null, null) + } + + if (this.muxer && this.muxer.newStream) { + return this.muxer.newStream((err, stream) => { + if (err) { + return callback(err, null) + } + + this.log('created new stream to %s', this.theirB58Id) + this._protocolHandshake(protocol, stream, callback) + }) + } + + this._protocolHandshake(protocol, this.conn, callback) + } + + /** + * Puts the state into muxing mode + * + * @returns {void} + */ + upgrade () { + this._state('upgrade') + } + + /** + * Event handler for dialing. Transitions state when successful. + * + * @private + * @fires ConnectionFSM#error + * @returns {void} + */ + _onDialing () { + this.log('dialing %s', this.theirB58Id) + + if (!this.switch.hasTransports()) { + return this.close(NO_TRANSPORTS_REGISTERED()) + } + + const tKeys = this.switch.availableTransports(this.theirPeerInfo) + + const circuitEnabled = Boolean(this.switch.transports[Circuit.tag]) + + if (circuitEnabled && !tKeys.includes(Circuit.tag)) { + tKeys.push(Circuit.tag) + } + + const nextTransport = (key) => { + let transport = key + if (!transport) { + if (!circuitEnabled) { + return this.close( + CONNECTION_FAILED(`Circuit not enabled and all transports failed to dial peer ${this.theirB58Id}!`) + ) + } + + return this.close( + CONNECTION_FAILED(`No available transports to dial peer ${this.theirB58Id}!`) + ) + } + + if (transport === Circuit.tag) { + this.theirPeerInfo.multiaddrs.add(`/p2p-circuit/p2p/${this.theirB58Id}`) + } + + this.log('dialing transport %s', transport) + this.switch.transport.dial(transport, this.theirPeerInfo, (errors, _conn) => { + if (errors) { + this.emit('error:connection_attempt_failed', errors) + this.log(errors) + return nextTransport(tKeys.shift()) + } + + this.conn = observeConnection(transport, null, _conn, this.switch.observer) + this._state('done') + }) + } + + nextTransport(tKeys.shift()) + } + + /** + * Once a connection has been successfully dialed, the connection + * will be privatized or encrypted depending on the presence of the + * Switch.protector. + * + * @returns {void} + */ + _onDialed () { + this.log('successfully dialed %s', this.theirB58Id) + + this.emit('connected', this.conn) + } + + /** + * Event handler for disconnecting. Handles any needed cleanup + * + * @returns {void} + */ + _onDisconnecting () { + this.log('disconnecting from %s', this.theirB58Id, Boolean(this.muxer)) + + delete this.switch.conns[this.theirB58Id] + + let tasks = [] + + // Clean up stored connections + if (this.muxer) { + tasks.push((cb) => { + this.muxer.end(() => { + delete this.muxer + cb() + }) + }) + } + + // If we have the base connection, abort it + // Ignore abort errors, since we're closing + if (this.conn) { + try { + this.conn.source.abort() + } catch (_) { } + delete this.conn + } + + parallel(tasks, () => { + this._state('done') + }) + } + + /** + * Attempts to encrypt `this.conn` with the Switch's crypto. + * + * @private + * @fires ConnectionFSM#error + * @returns {void} + */ + _onEncrypting () { + const msDialer = new multistream.Dialer() + msDialer.handle(this.conn, (err) => { + if (err) { + return this.close(maybeUnexpectedEnd(err)) + } + + this.log('selecting crypto %s to %s', this.switch.crypto.tag, this.theirB58Id) + + msDialer.select(this.switch.crypto.tag, (err, _conn) => { + if (err) { + return this.close(maybeUnexpectedEnd(err)) + } + + const observedConn = observeConnection(null, this.switch.crypto.tag, _conn, this.switch.observer) + const encryptedConn = this.switch.crypto.encrypt(this.ourPeerInfo.id, observedConn, this.theirPeerInfo.id, (err) => { + if (err) { + return this.close(err) + } + + this.conn = encryptedConn + this.conn.setPeerInfo(this.theirPeerInfo) + this._state('done') + }) + }) + }) + } + + /** + * Iterates over each Muxer on the Switch and attempts to upgrade + * the given `connection`. Successful muxed connections will be stored + * on the Switch.muxedConns with `b58Id` as their key for future reference. + * + * @private + * @returns {void} + */ + _onUpgrading () { + const muxers = Object.keys(this.switch.muxers) + this.log('upgrading connection to %s', this.theirB58Id) + + if (muxers.length === 0) { + return this._state('stop') + } + + const msDialer = new multistream.Dialer() + msDialer.handle(this.conn, (err) => { + if (err) { + return this._didUpgrade(err) + } + + // 1. try to handshake in one of the muxers available + // 2. if succeeds + // - add the muxedConn to the list of muxedConns + // - add incomming new streams to connHandler + const nextMuxer = (key) => { + this.log('selecting %s', key) + msDialer.select(key, (err, _conn) => { + if (err) { + if (muxers.length === 0) { + return this._didUpgrade(err) + } + + return nextMuxer(muxers.shift()) + } + + // observe muxed connections + const conn = observeConnection(null, key, _conn, this.switch.observer) + + this.muxer = this.switch.muxers[key].dialer(conn) + + this.muxer.once('close', () => { + this.close() + }) + + // For incoming streams, in case identify is on + this.muxer.on('stream', (conn) => { + this.log('new stream created via muxer to %s', this.theirB58Id) + conn.setPeerInfo(this.theirPeerInfo) + this.switch.protocolMuxer(null)(conn) + }) + + this._didUpgrade(null) + + // Run identify on the connection + if (this.switch.identify) { + this._identify((err, results) => { + if (err) { + return this.close(err) + } + this.theirPeerInfo = this.switch._peerBook.put(results.peerInfo) + }) + } + }) + } + + nextMuxer(muxers.shift()) + }) + } + + /** + * Runs the identify protocol on the connection + * @private + * @param {function(error, { PeerInfo })} callback + * @returns {void} + */ + _identify (callback) { + if (!this.muxer) { + return nextTick(callback, errCode('The connection was already closed', 'ERR_CONNECTION_CLOSED')) + } + this.muxer.newStream(async (err, conn) => { + if (err) return callback(err) + const ms = new multistream.Dialer() + let results + try { + await msHandle(ms, conn) + const msConn = await msSelect(ms, identify.multicodec) + results = await identifyDialer(msConn, this.theirPeerInfo) + } catch (err) { + return callback(err) + } + callback(null, results) + }) + } + + /** + * Analyses the given error, if it exists, to determine where the state machine + * needs to go. + * + * @param {Error} err + * @returns {void} + */ + _didUpgrade (err) { + if (err) { + this.log('Error upgrading connection:', err) + this.switch.conns[this.theirB58Id] = this + this.emit('error:upgrade_failed', err) + // Cant upgrade, hold the encrypted connection + return this._state('stop') + } + + // move the state machine forward + this._state('done') + } + + /** + * Performs the protocol handshake for the given protocol + * over the given connection. The resulting error or connection + * will be returned via the callback. + * + * @private + * @param {string} protocol + * @param {Connection} connection + * @param {function(Error, Connection)} callback + * @returns {void} + */ + _protocolHandshake (protocol, connection, callback) { + const msDialer = new multistream.Dialer() + msDialer.handle(connection, (err) => { + if (err) { + return callback(err, null) + } + + msDialer.select(protocol, (err, _conn) => { + if (err) { + this.log('could not perform protocol handshake:', err) + return callback(err, null) + } + + const conn = observeConnection(null, protocol, _conn, this.switch.observer) + this.log('successfully performed handshake of %s to %s', protocol, this.theirB58Id) + this.emit('connection', conn) + callback(null, conn) + }) + }) + } + + /** + * Event handler for state transition errors + * + * @param {Error} err + * @returns {void} + */ + _onStateError (err) { + this.emit('error', INVALID_STATE_TRANSITION(err)) + this.log(err) + } +} + +module.exports = withIs(ConnectionFSM, { + className: 'ConnectionFSM', + symbolName: 'libp2p-switch/ConnectionFSM' +}) diff --git a/src/switch/connection/manager.js b/src/switch/connection/manager.js new file mode 100644 index 0000000000..42d9749bee --- /dev/null +++ b/src/switch/connection/manager.js @@ -0,0 +1,289 @@ +'use strict' + +const identify = require('libp2p-identify') +const multistream = require('multistream-select') +const debug = require('debug') +const log = debug('libp2p:switch:conn-manager') +const once = require('once') +const ConnectionFSM = require('../connection') +const { msHandle, msSelect, identifyDialer } = require('../utils') + +const Circuit = require('libp2p-circuit') + +const plaintext = require('../plaintext') + +/** + * Contains methods for binding handlers to the Switch + * in order to better manage its connections. + */ +class ConnectionManager { + constructor (_switch) { + this.switch = _switch + this.connections = {} + } + + /** + * Adds the connection for tracking if it's not already added + * @private + * @param {ConnectionFSM} connection + * @returns {void} + */ + add (connection) { + this.connections[connection.theirB58Id] = this.connections[connection.theirB58Id] || [] + // Only add it if it's not there + if (!this.get(connection)) { + this.connections[connection.theirB58Id].push(connection) + this.switch.emit('connection:start', connection.theirPeerInfo) + if (connection.getState() === 'MUXED') { + this.switch.emit('peer-mux-established', connection.theirPeerInfo) + // Clear the blacklist of the peer + this.switch.dialer.clearBlacklist(connection.theirPeerInfo) + } else { + connection.once('muxed', () => { + this.switch.emit('peer-mux-established', connection.theirPeerInfo) + // Clear the blacklist of the peer + this.switch.dialer.clearBlacklist(connection.theirPeerInfo) + }) + } + } + } + + /** + * Gets the connection from the list if it exists + * @private + * @param {ConnectionFSM} connection + * @returns {ConnectionFSM|null} The found connection or null + */ + get (connection) { + if (!this.connections[connection.theirB58Id]) return null + + for (let i = 0; i < this.connections[connection.theirB58Id].length; i++) { + if (this.connections[connection.theirB58Id][i] === connection) { + return this.connections[connection.theirB58Id][i] + } + } + return null + } + + /** + * Gets a connection associated with the given peer + * @private + * @param {string} peerId The peers id + * @returns {ConnectionFSM|null} The found connection or null + */ + getOne (peerId) { + if (this.connections[peerId]) { + // Only return muxed connections + for (var i = 0; i < this.connections[peerId].length; i++) { + if (this.connections[peerId][i].getState() === 'MUXED') { + return this.connections[peerId][i] + } + } + } + return null + } + + /** + * Removes the connection from tracking + * @private + * @param {ConnectionFSM} connection The connection to remove + * @returns {void} + */ + remove (connection) { + // No record of the peer, disconnect it + if (!this.connections[connection.theirB58Id]) { + if (connection.theirPeerInfo) { + connection.theirPeerInfo.disconnect() + this.switch.emit('peer-mux-closed', connection.theirPeerInfo) + } + return + } + + for (let i = 0; i < this.connections[connection.theirB58Id].length; i++) { + if (this.connections[connection.theirB58Id][i] === connection) { + this.connections[connection.theirB58Id].splice(i, 1) + break + } + } + + // The peer is fully disconnected + if (this.connections[connection.theirB58Id].length === 0) { + delete this.connections[connection.theirB58Id] + connection.theirPeerInfo.disconnect() + this.switch.emit('peer-mux-closed', connection.theirPeerInfo) + } + + // A tracked connection was closed, let the world know + this.switch.emit('connection:end', connection.theirPeerInfo) + } + + /** + * Returns all connections being tracked + * @private + * @returns {ConnectionFSM[]} + */ + getAll () { + let connections = [] + for (const conns of Object.values(this.connections)) { + connections = [...connections, ...conns] + } + return connections + } + + /** + * Returns all connections being tracked for a given peer id + * @private + * @param {string} peerId Stringified peer id + * @returns {ConnectionFSM[]} + */ + getAllById (peerId) { + return this.connections[peerId] || [] + } + + /** + * Adds a listener for the given `muxer` and creates a handler for it + * leveraging the Switch.protocolMuxer handler factory + * + * @param {Muxer} muxer + * @returns {void} + */ + addStreamMuxer (muxer) { + // for dialing + this.switch.muxers[muxer.multicodec] = muxer + + // for listening + this.switch.handle(muxer.multicodec, (protocol, conn) => { + const muxedConn = muxer.listener(conn) + + muxedConn.on('stream', this.switch.protocolMuxer(null)) + + // If identify is enabled + // 1. overload getPeerInfo + // 2. call getPeerInfo + // 3. add this conn to the pool + if (this.switch.identify) { + // Get the peer info from the crypto exchange + conn.getPeerInfo((err, cryptoPI) => { + if (err || !cryptoPI) { + log('crypto peerInfo wasnt found') + } + + // overload peerInfo to use Identify instead + conn.getPeerInfo = async (callback) => { + const conn = muxedConn.newStream() + const ms = new multistream.Dialer() + callback = once(callback) + + let results + try { + await msHandle(ms, conn) + const msConn = await msSelect(ms, identify.multicodec) + results = await identifyDialer(msConn, cryptoPI) + } catch (err) { + return muxedConn.end(() => { + callback(err, null) + }) + } + + const { peerInfo } = results + + if (peerInfo) { + conn.setPeerInfo(peerInfo) + } + callback(null, peerInfo) + } + + conn.getPeerInfo((err, peerInfo) => { + /* eslint no-warning-comments: off */ + if (err) { + return log('identify not successful') + } + const b58Str = peerInfo.id.toB58String() + peerInfo = this.switch._peerBook.put(peerInfo) + + const connection = new ConnectionFSM({ + _switch: this.switch, + peerInfo, + muxer: muxedConn, + conn: conn, + type: 'inc' + }) + this.switch.connection.add(connection) + + // Only update if it's not already connected + if (!peerInfo.isConnected()) { + if (peerInfo.multiaddrs.size > 0) { + // with incomming conn and through identify, going to pick one + // of the available multiaddrs from the other peer as the one + // I'm connected to as we really can't be sure at the moment + // TODO add this consideration to the connection abstraction! + peerInfo.connect(peerInfo.multiaddrs.toArray()[0]) + } else { + // for the case of websockets in the browser, where peers have + // no addr, use just their IPFS id + peerInfo.connect(`/ipfs/${b58Str}`) + } + } + + muxedConn.once('close', () => { + connection.close() + }) + }) + }) + } + + return conn + }) + } + + /** + * Adds the `encrypt` handler for the given `tag` and also sets the + * Switch's crypto to passed `encrypt` function + * + * @param {String} tag + * @param {function(PeerID, Connection, PeerId, Callback)} encrypt + * @returns {void} + */ + crypto (tag, encrypt) { + if (!tag && !encrypt) { + tag = plaintext.tag + encrypt = plaintext.encrypt + } + + this.switch.crypto = { tag, encrypt } + } + + /** + * If config.enabled is true, a Circuit relay will be added to the + * available Switch transports. + * + * @param {any} config + * @returns {void} + */ + enableCircuitRelay (config) { + config = config || {} + + if (config.enabled) { + if (!config.hop) { + Object.assign(config, { hop: { enabled: false, active: false } }) + } + + this.switch.transport.add(Circuit.tag, new Circuit(this.switch, config)) + } + } + + /** + * Sets identify to true on the Switch and performs handshakes + * for libp2p-identify leveraging the Switch's muxer. + * + * @returns {void} + */ + reuse () { + this.switch.identify = true + this.switch.handle(identify.multicodec, (protocol, conn) => { + identify.listener(conn, this.switch._peerInfo) + }) + } +} + +module.exports = ConnectionManager diff --git a/src/switch/constants.js b/src/switch/constants.js new file mode 100644 index 0000000000..f0b6496ded --- /dev/null +++ b/src/switch/constants.js @@ -0,0 +1,12 @@ +'use strict' + +module.exports = { + BLACK_LIST_TTL: 5 * 60 * 1e3, // How long before an errored peer can be dialed again + BLACK_LIST_ATTEMPTS: 5, // Num of unsuccessful dials before a peer is permanently blacklisted + DIAL_TIMEOUT: 30e3, // How long in ms a dial attempt is allowed to take + MAX_COLD_CALLS: 50, // How many dials w/o protocols that can be queued + MAX_PARALLEL_DIALS: 100, // Maximum allowed concurrent dials + QUARTER_HOUR: 15 * 60e3, + PRIORITY_HIGH: 10, + PRIORITY_LOW: 20 +} diff --git a/src/switch/dialer/index.js b/src/switch/dialer/index.js new file mode 100644 index 0000000000..8ee1ace71c --- /dev/null +++ b/src/switch/dialer/index.js @@ -0,0 +1,119 @@ +'use strict' + +const DialQueueManager = require('./queueManager') +const getPeerInfo = require('../get-peer-info') +const { + BLACK_LIST_ATTEMPTS, + BLACK_LIST_TTL, + MAX_COLD_CALLS, + MAX_PARALLEL_DIALS, + PRIORITY_HIGH, + PRIORITY_LOW +} = require('../constants') + +module.exports = function (_switch) { + const dialQueueManager = new DialQueueManager(_switch) + + _switch.state.on('STARTED:enter', start) + _switch.state.on('STOPPING:enter', stop) + + /** + * @param {DialRequest} dialRequest + * @returns {void} + */ + function _dial ({ peerInfo, protocol, options, callback }) { + if (typeof protocol === 'function') { + callback = protocol + protocol = null + } + + try { + peerInfo = getPeerInfo(peerInfo, _switch._peerBook) + } catch (err) { + return callback(err) + } + + // Add it to the queue, it will automatically get executed + dialQueueManager.add({ peerInfo, protocol, options, callback }) + } + + /** + * Starts the `DialQueueManager` + * + * @param {function} callback + */ + function start (callback) { + dialQueueManager.start() + callback() + } + + /** + * Aborts all dials that are queued. This should + * only be used when the Switch is being stopped + * + * @param {function} callback + */ + function stop (callback) { + dialQueueManager.stop() + callback() + } + + /** + * Clears the blacklist for a given peer + * @param {PeerInfo} peerInfo + */ + function clearBlacklist (peerInfo) { + dialQueueManager.clearBlacklist(peerInfo) + } + + /** + * Attempts to establish a connection to the given `peerInfo` at + * a lower priority than a standard dial. + * @param {PeerInfo} peerInfo + * @param {object} options + * @param {boolean} options.useFSM Whether or not to return a `ConnectionFSM`. Defaults to false. + * @param {number} options.priority Lowest priority goes first. Defaults to 20. + * @param {function(Error, Connection)} callback + */ + function connect (peerInfo, options, callback) { + if (typeof options === 'function') { + callback = options + options = null + } + options = { useFSM: false, priority: PRIORITY_LOW, ...options } + _dial({ peerInfo, protocol: null, options, callback }) + } + + /** + * Adds the dial request to the queue for the given `peerInfo` + * The request will be added with a high priority (10). + * @param {PeerInfo} peerInfo + * @param {string} protocol + * @param {function(Error, Connection)} callback + */ + function dial (peerInfo, protocol, callback) { + _dial({ peerInfo, protocol, options: { useFSM: false, priority: PRIORITY_HIGH }, callback }) + } + + /** + * Behaves like dial, except it calls back with a ConnectionFSM + * + * @param {PeerInfo} peerInfo + * @param {string} protocol + * @param {function(Error, ConnectionFSM)} callback + */ + function dialFSM (peerInfo, protocol, callback) { + _dial({ peerInfo, protocol, options: { useFSM: true, priority: PRIORITY_HIGH }, callback }) + } + + return { + connect, + dial, + dialFSM, + clearBlacklist, + BLACK_LIST_ATTEMPTS: isNaN(_switch._options.blackListAttempts) ? BLACK_LIST_ATTEMPTS : _switch._options.blackListAttempts, + BLACK_LIST_TTL: isNaN(_switch._options.blacklistTTL) ? BLACK_LIST_TTL : _switch._options.blacklistTTL, + MAX_COLD_CALLS: isNaN(_switch._options.maxColdCalls) ? MAX_COLD_CALLS : _switch._options.maxColdCalls, + MAX_PARALLEL_DIALS: isNaN(_switch._options.maxParallelDials) ? MAX_PARALLEL_DIALS : _switch._options.maxParallelDials + } +} diff --git a/src/switch/dialer/queue.js b/src/switch/dialer/queue.js new file mode 100644 index 0000000000..8279adc3ec --- /dev/null +++ b/src/switch/dialer/queue.js @@ -0,0 +1,280 @@ +'use strict' + +const ConnectionFSM = require('../connection') +const { DIAL_ABORTED, ERR_BLACKLISTED } = require('../errors') +const nextTick = require('async/nextTick') +const once = require('once') +const debug = require('debug') +const log = debug('libp2p:switch:dial') +log.error = debug('libp2p:switch:dial:error') + +/** + * Components required to execute a dial + * @typedef {Object} DialRequest + * @property {PeerInfo} peerInfo - The peer to dial to + * @property {string} [protocol] - The protocol to create a stream for + * @property {object} options + * @property {boolean} options.useFSM - If `callback` should return a ConnectionFSM + * @property {number} options.priority - The priority of the dial + * @property {function(Error, Connection|ConnectionFSM)} callback + */ + +/** + * @typedef {Object} NewConnection + * @property {ConnectionFSM} connectionFSM + * @property {boolean} didCreate + */ + +/** + * Attempts to create a new connection or stream (when muxed), + * via negotiation of the given `protocol`. If no `protocol` is + * provided, no action will be taken and `callback` will be called + * immediately with no error or values. + * + * @param {object} options + * @param {string} options.protocol + * @param {ConnectionFSM} options.connection + * @param {function(Error, Connection)} options.callback + * @returns {void} + */ +function createConnectionWithProtocol ({ protocol, connection, callback }) { + if (!protocol) { + return callback() + } + connection.shake(protocol, (err, conn) => { + if (!conn) { + return callback(err) + } + + conn.setPeerInfo(connection.theirPeerInfo) + callback(null, conn) + }) +} + +/** + * A convenience array wrapper for controlling + * a per peer queue + * + * @returns {Queue} + */ +class Queue { + /** + * @constructor + * @param {string} peerId + * @param {Switch} _switch + * @param {function(string)} onStopped Called when the queue stops + */ + constructor (peerId, _switch, onStopped) { + this.id = peerId + this.switch = _switch + this._queue = [] + this.blackListed = null + this.blackListCount = 0 + this.isRunning = false + this.onStopped = onStopped + } + get length () { + return this._queue.length + } + + /** + * Adds the dial request to the queue. The queue is not automatically started + * @param {string} protocol + * @param {boolean} useFSM If callback should use a ConnectionFSM instead + * @param {function(Error, Connection)} callback + * @returns {void} + */ + add (protocol, useFSM, callback) { + if (!this.isDialAllowed()) { + return nextTick(callback, ERR_BLACKLISTED()) + } + this._queue.push({ protocol, useFSM, callback }) + } + + /** + * Determines whether or not dialing is currently allowed + * @returns {boolean} + */ + isDialAllowed () { + if (this.blackListed) { + // If the blacklist ttl has passed, reset it + if (Date.now() > this.blackListed) { + this.blackListed = null + return true + } + // Dial is not allowed + return false + } + return true + } + + /** + * Starts the queue. If the queue was started `true` will be returned. + * If the queue was already running `false` is returned. + * @returns {boolean} + */ + start () { + if (!this.isRunning) { + log('starting dial queue to %s', this.id) + this.isRunning = true + this._run() + return true + } + return false + } + + /** + * Stops the queue + */ + stop () { + if (this.isRunning) { + log('stopping dial queue to %s', this.id) + this.isRunning = false + this.onStopped(this.id) + } + } + + /** + * Stops the queue and errors the callback for each dial request + */ + abort () { + while (this.length > 0) { + let dial = this._queue.shift() + dial.callback(DIAL_ABORTED()) + } + this.stop() + } + + /** + * Marks the queue as blacklisted. The queue will be immediately aborted. + * @returns {void} + */ + blacklist () { + this.blackListCount++ + + if (this.blackListCount >= this.switch.dialer.BLACK_LIST_ATTEMPTS) { + this.blackListed = Infinity + return + } + + let ttl = this.switch.dialer.BLACK_LIST_TTL * Math.pow(this.blackListCount, 3) + const minTTL = ttl * 0.9 + const maxTTL = ttl * 1.1 + + // Add a random jitter of 20% to the ttl + ttl = Math.floor(Math.random() * (maxTTL - minTTL) + minTTL) + + this.blackListed = Date.now() + ttl + this.abort() + } + + /** + * Attempts to find a muxed connection for the given peer. If one + * isn't found, a new one will be created. + * + * Returns an array containing two items. The ConnectionFSM and wether + * or not the ConnectionFSM was just created. The latter can be used + * to determine dialing needs. + * + * @private + * @param {PeerInfo} peerInfo + * @returns {NewConnection} + */ + _getOrCreateConnection (peerInfo) { + let connectionFSM = this.switch.connection.getOne(this.id) + let didCreate = false + + if (!connectionFSM) { + connectionFSM = new ConnectionFSM({ + _switch: this.switch, + peerInfo, + muxer: null, + conn: null + }) + + this.switch.connection.add(connectionFSM) + + // Add control events and start the dialer + connectionFSM.once('connected', () => connectionFSM.protect()) + connectionFSM.once('private', () => connectionFSM.encrypt()) + connectionFSM.once('encrypted', () => connectionFSM.upgrade()) + + didCreate = true + } + + return { connectionFSM, didCreate } + } + + /** + * Executes the next dial in the queue for the given peer + * @private + * @returns {void} + */ + _run () { + // If we have no items in the queue or we're stopped, exit + if (this.length < 1 || !this.isRunning) { + log('stopping the queue for %s', this.id) + return this.stop() + } + + const next = once(() => { + log('starting next dial to %s', this.id) + this._run() + }) + + const peerInfo = this.switch._peerBook.get(this.id) + let queuedDial = this._queue.shift() + let { connectionFSM, didCreate } = this._getOrCreateConnection(peerInfo) + + // If the dial expects a ConnectionFSM, we can provide that back now + if (queuedDial.useFSM) { + nextTick(queuedDial.callback, null, connectionFSM) + } + + // If we can handshake protocols, get a new stream and call run again + if (['MUXED', 'CONNECTED'].includes(connectionFSM.getState())) { + queuedDial.connection = connectionFSM + createConnectionWithProtocol(queuedDial) + next() + return + } + + // If we error, error the queued dial + // In the future, it may be desired to error the other queued dials, + // depending on the error. + connectionFSM.once('error', (err) => { + queuedDial.callback(err) + // Dont blacklist peers we have identified and that we are connected to + if (peerInfo.protocols.size > 0 && peerInfo.isConnected()) { + return + } + this.blacklist() + }) + + connectionFSM.once('close', () => { + next() + }) + + // If we're not muxed yet, add listeners + connectionFSM.once('muxed', () => { + this.blackListCount = 0 // reset blacklisting on good connections + queuedDial.connection = connectionFSM + createConnectionWithProtocol(queuedDial) + next() + }) + + connectionFSM.once('unmuxed', () => { + this.blackListCount = 0 + queuedDial.connection = connectionFSM + createConnectionWithProtocol(queuedDial) + next() + }) + + // If we have a new connection, start dialing + if (didCreate) { + connectionFSM.dial() + } + } +} + +module.exports = Queue diff --git a/src/switch/dialer/queueManager.js b/src/switch/dialer/queueManager.js new file mode 100644 index 0000000000..52355f6b82 --- /dev/null +++ b/src/switch/dialer/queueManager.js @@ -0,0 +1,220 @@ +'use strict' + +const once = require('once') +const Queue = require('./queue') +const { DIAL_ABORTED } = require('../errors') +const nextTick = require('async/nextTick') +const retimer = require('retimer') +const { QUARTER_HOUR, PRIORITY_HIGH } = require('../constants') +const debug = require('debug') +const log = debug('libp2p:switch:dial:manager') +const noop = () => {} + +class DialQueueManager { + /** + * @constructor + * @param {Switch} _switch + */ + constructor (_switch) { + this._queue = new Set() + this._coldCallQueue = new Set() + this._dialingQueues = new Set() + this._queues = {} + this.switch = _switch + this._cleanInterval = retimer(this._clean.bind(this), QUARTER_HOUR) + this.start() + } + + /** + * Runs through all queues, aborts and removes them if they + * are no longer valid. A queue that is blacklisted indefinitely, + * is considered no longer valid. + * @private + */ + _clean () { + const queues = Object.values(this._queues) + queues.forEach(dialQueue => { + // Clear if the queue has reached max blacklist + if (dialQueue.blackListed === Infinity) { + dialQueue.abort() + delete this._queues[dialQueue.id] + return + } + + // Keep track of blacklisted queues + if (dialQueue.blackListed) return + + // Clear if peer is no longer active + // To avoid reallocating memory, dont delete queues of + // connected peers, as these are highly likely to leverage the + // queues in the immediate term + if (!dialQueue.isRunning && dialQueue.length < 1) { + let isConnected = false + try { + const peerInfo = this.switch._peerBook.get(dialQueue.id) + isConnected = Boolean(peerInfo.isConnected()) + } catch (_) { + // If we get an error, that means the peerbook doesnt have the peer + } + + if (!isConnected) { + dialQueue.abort() + delete this._queues[dialQueue.id] + } + } + }) + + this._cleanInterval.reschedule(QUARTER_HOUR) + } + + /** + * Allows the `DialQueueManager` to execute dials + */ + start () { + this.isRunning = true + } + + /** + * Iterates over all items in the DialerQueue + * and executes there callback with an error. + * + * This causes the entire DialerQueue to be drained + */ + stop () { + this.isRunning = false + // Clear the general queue + this._queue.clear() + // Clear the cold call queue + this._coldCallQueue.clear() + + this._cleanInterval.clear() + + // Abort the individual peer queues + const queues = Object.values(this._queues) + queues.forEach(dialQueue => { + dialQueue.abort() + delete this._queues[dialQueue.id] + }) + } + + /** + * Adds the `dialRequest` to the queue and ensures queue is running + * + * @param {DialRequest} dialRequest + * @returns {void} + */ + add ({ peerInfo, protocol, options, callback }) { + callback = callback ? once(callback) : noop + + // Add the dial to its respective queue + const targetQueue = this.getQueue(peerInfo) + + // Cold Call + if (options.priority > PRIORITY_HIGH) { + // If we have too many cold calls, abort the dial immediately + if (this._coldCallQueue.size >= this.switch.dialer.MAX_COLD_CALLS) { + return nextTick(callback, DIAL_ABORTED()) + } + + if (this._queue.has(targetQueue.id)) { + return nextTick(callback, DIAL_ABORTED()) + } + } + + targetQueue.add(protocol, options.useFSM, callback) + + // If we're already connected to the peer, start the queue now + // While it might cause queues to go over the max parallel amount, + // it avoids blocking peers we're already connected to + if (peerInfo.isConnected()) { + targetQueue.start() + return + } + + // If dialing is not allowed, abort + if (!targetQueue.isDialAllowed()) { + return + } + + // Add the id to its respective queue set if the queue isn't running + if (!targetQueue.isRunning) { + if (options.priority <= PRIORITY_HIGH) { + this._queue.add(targetQueue.id) + this._coldCallQueue.delete(targetQueue.id) + // Only add it to the cold queue if it's not in the normal queue + } else { + this._coldCallQueue.add(targetQueue.id) + } + } + + this.run() + } + + /** + * Will execute up to `MAX_PARALLEL_DIALS` dials + */ + run () { + if (!this.isRunning) return + + if (this._dialingQueues.size < this.switch.dialer.MAX_PARALLEL_DIALS) { + let nextQueue = { done: true } + // Check the queue first and fall back to the cold call queue + if (this._queue.size > 0) { + nextQueue = this._queue.values().next() + this._queue.delete(nextQueue.value) + } else if (this._coldCallQueue.size > 0) { + nextQueue = this._coldCallQueue.values().next() + this._coldCallQueue.delete(nextQueue.value) + } + + if (nextQueue.done) { + return + } + + let targetQueue = this._queues[nextQueue.value] + + if (!targetQueue) { + log('missing queue %s, maybe it was aborted?', nextQueue.value) + return + } + + this._dialingQueues.add(targetQueue.id) + targetQueue.start() + } + } + + /** + * Will remove the `peerInfo` from the dial blacklist + * @param {PeerInfo} peerInfo + */ + clearBlacklist (peerInfo) { + const queue = this.getQueue(peerInfo) + queue.blackListed = null + queue.blackListCount = 0 + } + + /** + * A handler for when dialing queues stop. This will trigger + * `run()` in order to keep the queue processing. + * @private + * @param {string} id peer id of the queue that stopped + */ + _onQueueStopped (id) { + this._dialingQueues.delete(id) + this.run() + } + + /** + * Returns the `Queue` for the given `peerInfo` + * @param {PeerInfo} peerInfo + * @returns {Queue} + */ + getQueue (peerInfo) { + const id = peerInfo.id.toB58String() + + this._queues[id] = this._queues[id] || new Queue(id, this.switch, this._onQueueStopped.bind(this)) + return this._queues[id] + } +} + +module.exports = DialQueueManager diff --git a/src/switch/errors.js b/src/switch/errors.js new file mode 100644 index 0000000000..73e0cb953d --- /dev/null +++ b/src/switch/errors.js @@ -0,0 +1,20 @@ +'use strict' + +const errCode = require('err-code') + +module.exports = { + CONNECTION_FAILED: (err) => errCode(err, 'CONNECTION_FAILED'), + DIAL_ABORTED: () => errCode('Dial was aborted', 'DIAL_ABORTED'), + ERR_BLACKLISTED: () => errCode('Dial is currently blacklisted for this peer', 'ERR_BLACKLISTED'), + DIAL_SELF: () => errCode('A node cannot dial itself', 'DIAL_SELF'), + INVALID_STATE_TRANSITION: (err) => errCode(err, 'INVALID_STATE_TRANSITION'), + NO_TRANSPORTS_REGISTERED: () => errCode('No transports registered, dial not possible', 'NO_TRANSPORTS_REGISTERED'), + PROTECTOR_REQUIRED: () => errCode('No protector provided with private network enforced', 'PROTECTOR_REQUIRED'), + UNEXPECTED_END: () => errCode('Unexpected end of input from reader.', 'UNEXPECTED_END'), + maybeUnexpectedEnd: (err) => { + if (err === true) { + return module.exports.UNEXPECTED_END() + } + return err + } +} diff --git a/src/switch/get-peer-info.js b/src/switch/get-peer-info.js new file mode 100644 index 0000000000..68f38f3403 --- /dev/null +++ b/src/switch/get-peer-info.js @@ -0,0 +1,49 @@ +'use strict' + +const PeerId = require('peer-id') +const PeerInfo = require('peer-info') +const multiaddr = require('multiaddr') + +/** + * Helper method to check the data type of peer and convert it to PeerInfo + * + * @param {PeerInfo|Multiaddr|PeerId} peer + * @param {PeerBook} peerBook + * @throws {InvalidPeerType} + * @returns {PeerInfo} + */ +function getPeerInfo (peer, peerBook) { + let peerInfo + + // Already a PeerInfo instance, + // add to the peer book and return the latest value + if (PeerInfo.isPeerInfo(peer)) { + return peerBook.put(peer) + } + + // Attempt to convert from Multiaddr instance (not string) + if (multiaddr.isMultiaddr(peer)) { + const peerIdB58Str = peer.getPeerId() + try { + peerInfo = peerBook.get(peerIdB58Str) + } catch (err) { + peerInfo = new PeerInfo(PeerId.createFromB58String(peerIdB58Str)) + } + peerInfo.multiaddrs.add(peer) + return peerInfo + } + + // Attempt to convert from PeerId + if (PeerId.isPeerId(peer)) { + const peerIdB58Str = peer.toB58String() + try { + return peerBook.get(peerIdB58Str) + } catch (err) { + throw new Error(`Couldnt get PeerInfo for ${peerIdB58Str}`) + } + } + + throw new Error('peer type not recognized') +} + +module.exports = getPeerInfo diff --git a/src/switch/index.js b/src/switch/index.js new file mode 100644 index 0000000000..f463d4d4c3 --- /dev/null +++ b/src/switch/index.js @@ -0,0 +1,274 @@ +'use strict' + +const FSM = require('fsm-event') +const EventEmitter = require('events').EventEmitter +const each = require('async/each') +const eachSeries = require('async/eachSeries') +const series = require('async/series') +const Circuit = require('libp2p-circuit') +const TransportManager = require('./transport') +const ConnectionManager = require('./connection/manager') +const getPeerInfo = require('./get-peer-info') +const getDialer = require('./dialer') +const connectionHandler = require('./connection/handler') +const ProtocolMuxer = require('./protocol-muxer') +const plaintext = require('./plaintext') +const Observer = require('./observer') +const Stats = require('./stats') +const assert = require('assert') +const Errors = require('./errors') +const debug = require('debug') +const log = debug('libp2p:switch') +log.error = debug('libp2p:switch:error') + +/** + * @fires Switch#stop Triggered when the switch has stopped + * @fires Switch#start Triggered when the switch has started + * @fires Switch#error Triggered whenever an error occurs + */ +class Switch extends EventEmitter { + constructor (peerInfo, peerBook, options) { + super() + assert(peerInfo, 'You must provide a `peerInfo`') + assert(peerBook, 'You must provide a `peerBook`') + + this._peerInfo = peerInfo + this._peerBook = peerBook + this._options = options || {} + + this.setMaxListeners(Infinity) + // transports -- + // { key: transport }; e.g { tcp: } + this.transports = {} + + // connections -- + // { peerIdB58: { conn: }} + this.conns = {} + + // { protocol: handler } + this.protocols = {} + + // { muxerCodec: } e.g { '/spdy/0.3.1': spdy } + this.muxers = {} + + // is the Identify protocol enabled? + this.identify = false + + // Crypto details + this.crypto = plaintext + + this.protector = this._options.protector || null + + this.transport = new TransportManager(this) + this.connection = new ConnectionManager(this) + + this.observer = Observer(this) + this.stats = Stats(this.observer, this._options.stats) + this.protocolMuxer = ProtocolMuxer(this.protocols, this.observer) + + // All purpose connection handler for managing incoming connections + this._connectionHandler = connectionHandler(this) + + // Setup the internal state + this.state = new FSM('STOPPED', { + STOPPED: { + start: 'STARTING', + stop: 'STOPPING' // ensures that any transports that were manually started are stopped + }, + STARTING: { + done: 'STARTED', + stop: 'STOPPING' + }, + STARTED: { + stop: 'STOPPING', + start: 'STARTED' + }, + STOPPING: { + stop: 'STOPPING', + done: 'STOPPED' + } + }) + this.state.on('STARTING', () => { + log('The switch is starting') + this._onStarting() + }) + this.state.on('STOPPING', () => { + log('The switch is stopping') + this._onStopping() + }) + this.state.on('STARTED', () => { + log('The switch has started') + this.emit('start') + }) + this.state.on('STOPPED', () => { + log('The switch has stopped') + this.emit('stop') + }) + this.state.on('error', (err) => { + log.error(err) + this.emit('error', err) + }) + + // higher level (public) API + this.dialer = getDialer(this) + this.dial = this.dialer.dial + this.dialFSM = this.dialer.dialFSM + } + + /** + * Returns a list of the transports peerInfo has addresses for + * + * @param {PeerInfo} peerInfo + * @returns {Array} + */ + availableTransports (peerInfo) { + const myAddrs = peerInfo.multiaddrs.toArray() + const myTransports = Object.keys(this.transports) + + // Only listen on transports we actually have addresses for + return myTransports.filter((ts) => this.transports[ts].filter(myAddrs).length > 0) + // push Circuit to be the last proto to be dialed, and alphabetize the others + .sort((a, b) => { + if (a === Circuit.tag) return 1 + if (b === Circuit.tag) return -1 + return a < b ? -1 : 1 + }) + } + + /** + * Adds the `handlerFunc` and `matchFunc` to the Switch's protocol + * handler list for the given `protocol`. If the `matchFunc` returns + * true for a protocol check, the `handlerFunc` will be called. + * + * @param {string} protocol + * @param {function(string, Connection)} handlerFunc + * @param {function(string, string, function(Error, boolean))} matchFunc + * @returns {void} + */ + handle (protocol, handlerFunc, matchFunc) { + this.protocols[protocol] = { + handlerFunc: handlerFunc, + matchFunc: matchFunc + } + this._peerInfo.protocols.add(protocol) + } + + /** + * Removes the given protocol from the Switch's protocol list + * + * @param {string} protocol + * @returns {void} + */ + unhandle (protocol) { + if (this.protocols[protocol]) { + delete this.protocols[protocol] + } + this._peerInfo.protocols.delete(protocol) + } + + /** + * If a muxed Connection exists for the given peer, it will be closed + * and its reference on the Switch will be removed. + * + * @param {PeerInfo|Multiaddr|PeerId} peer + * @param {function()} callback + * @returns {void} + */ + hangUp (peer, callback) { + const peerInfo = getPeerInfo(peer, this._peerBook) + const key = peerInfo.id.toB58String() + const conns = [...this.connection.getAllById(key)] + each(conns, (conn, cb) => { + conn.once('close', cb) + conn.close() + }, callback) + } + + /** + * Returns whether or not the switch has any transports + * + * @returns {boolean} + */ + hasTransports () { + const transports = Object.keys(this.transports).filter((t) => t !== Circuit.tag) + return transports && transports.length > 0 + } + + /** + * Issues a start on the Switch state. + * + * @param {function} callback deprecated: Listening for the `error` and `start` events are recommended + * @returns {void} + */ + start (callback = () => {}) { + // Add once listener for deprecated callback support + this.once('start', callback) + + this.state('start') + } + + /** + * Issues a stop on the Switch state. + * + * @param {function} callback deprecated: Listening for the `error` and `stop` events are recommended + * @returns {void} + */ + stop (callback = () => {}) { + // Add once listener for deprecated callback support + this.once('stop', callback) + + this.state('stop') + } + + /** + * A listener that will start any necessary services and listeners + * + * @private + * @returns {void} + */ + _onStarting () { + this.stats.start() + eachSeries(this.availableTransports(this._peerInfo), (ts, cb) => { + // Listen on the given transport + this.transport.listen(ts, {}, null, cb) + }, (err) => { + if (err) { + log.error(err) + this.emit('error', err) + return this.state('stop') + } + this.state('done') + }) + } + + /** + * A listener that will turn off all running services and listeners + * + * @private + * @returns {void} + */ + _onStopping () { + this.stats.stop() + series([ + (cb) => { + each(this.transports, (transport, cb) => { + each(transport.listeners, (listener, cb) => { + listener.close((err) => { + if (err) log.error(err) + cb() + }) + }, cb) + }, cb) + }, + (cb) => each(this.connection.getAll(), (conn, cb) => { + conn.once('close', cb) + conn.close() + }, cb) + ], (_) => { + this.state('done') + }) + } +} + +module.exports = Switch +module.exports.errors = Errors diff --git a/src/switch/limit-dialer/index.js b/src/switch/limit-dialer/index.js new file mode 100644 index 0000000000..d911a75dd2 --- /dev/null +++ b/src/switch/limit-dialer/index.js @@ -0,0 +1,88 @@ +'use strict' + +const tryEach = require('async/tryEach') +const debug = require('debug') + +const log = debug('libp2p:switch:dialer') + +const DialQueue = require('./queue') + +/** + * Track dials per peer and limited them. + */ +class LimitDialer { + /** + * Create a new dialer. + * + * @param {number} perPeerLimit + * @param {number} dialTimeout + */ + constructor (perPeerLimit, dialTimeout) { + log('create: %s peer limit, %s dial timeout', perPeerLimit, dialTimeout) + this.perPeerLimit = perPeerLimit + this.dialTimeout = dialTimeout + this.queues = new Map() + } + + /** + * Dial a list of multiaddrs on the given transport. + * + * @param {PeerId} peer + * @param {SwarmTransport} transport + * @param {Array} addrs + * @param {function(Error, Connection)} callback + * @returns {void} + */ + dialMany (peer, transport, addrs, callback) { + log('dialMany:start') + // we use a token to track if we want to cancel following dials + const token = { cancel: false } + + let errors = [] + const tasks = addrs.map((m) => { + return (cb) => this.dialSingle(peer, transport, m, token, (err, result) => { + if (err) { + errors.push(err) + return cb(err) + } + return cb(null, result) + }) + }) + + tryEach(tasks, (_, result) => { + if (result && result.conn) { + log('dialMany:success') + return callback(null, result) + } + + log('dialMany:error') + callback(errors) + }) + } + + /** + * Dial a single multiaddr on the given transport. + * + * @param {PeerId} peer + * @param {SwarmTransport} transport + * @param {Multiaddr} addr + * @param {CancelToken} token + * @param {function(Error, Connection)} callback + * @returns {void} + */ + dialSingle (peer, transport, addr, token, callback) { + const ps = peer.toB58String() + log('dialSingle: %s:%s', ps, addr.toString()) + let q + if (this.queues.has(ps)) { + q = this.queues.get(ps) + } else { + q = new DialQueue(this.perPeerLimit, this.dialTimeout) + this.queues.set(ps, q) + } + + q.push(transport, addr, token, callback) + } +} + +module.exports = LimitDialer diff --git a/src/switch/limit-dialer/queue.js b/src/switch/limit-dialer/queue.js new file mode 100644 index 0000000000..344997adf9 --- /dev/null +++ b/src/switch/limit-dialer/queue.js @@ -0,0 +1,109 @@ +'use strict' + +const Connection = require('interface-connection').Connection +const pull = require('pull-stream/pull') +const empty = require('pull-stream/sources/empty') +const timeout = require('async/timeout') +const queue = require('async/queue') +const debug = require('debug') +const once = require('once') + +const log = debug('libp2p:switch:dialer:queue') +log.error = debug('libp2p:switch:dialer:queue:error') + +/** + * Queue up the amount of dials to a given peer. + */ +class DialQueue { + /** + * Create a new dial queue. + * + * @param {number} limit + * @param {number} dialTimeout + */ + constructor (limit, dialTimeout) { + this.dialTimeout = dialTimeout + + this.queue = queue((task, cb) => { + this._doWork(task.transport, task.addr, task.token, cb) + }, limit) + } + + /** + * The actual work done by the queue. + * + * @param {SwarmTransport} transport + * @param {Multiaddr} addr + * @param {CancelToken} token + * @param {function(Error, Connection)} callback + * @returns {void} + * @private + */ + _doWork (transport, addr, token, callback) { + callback = once(callback) + log('work:start') + this._dialWithTimeout(transport, addr, (err, conn) => { + if (err) { + log.error(`${transport.constructor.name}:work`, err) + return callback(err) + } + + if (token.cancel) { + log('work:cancel') + // clean up already done dials + pull(empty(), conn) + // If we can close the connection, do it + if (typeof conn.close === 'function') { + return conn.close((_) => callback(null)) + } + return callback(null) + } + + // one is enough + token.cancel = true + + log('work:success') + + const proxyConn = new Connection() + proxyConn.setInnerConn(conn) + callback(null, { multiaddr: addr, conn: conn }) + }) + } + + /** + * Dial the given transport, timing out with the set timeout. + * + * @param {SwarmTransport} transport + * @param {Multiaddr} addr + * @param {function(Error, Connection)} callback + * @returns {void} + * + * @private + */ + _dialWithTimeout (transport, addr, callback) { + timeout((cb) => { + const conn = transport.dial(addr, (err) => { + if (err) { + return cb(err) + } + + cb(null, conn) + }) + }, this.dialTimeout)(callback) + } + + /** + * Add new work to the queue. + * + * @param {SwarmTransport} transport + * @param {Multiaddr} addr + * @param {CancelToken} token + * @param {function(Error, Connection)} callback + * @returns {void} + */ + push (transport, addr, token, callback) { + this.queue.push({ transport, addr, token }, callback) + } +} + +module.exports = DialQueue diff --git a/src/switch/observe-connection.js b/src/switch/observe-connection.js new file mode 100644 index 0000000000..c6e928c04e --- /dev/null +++ b/src/switch/observe-connection.js @@ -0,0 +1,44 @@ +'use strict' + +const Connection = require('interface-connection').Connection +const pull = require('pull-stream/pull') + +/** + * Creates a pull stream to run the given Connection stream through + * the given Observer. This provides a way to more easily monitor connections + * and their metadata. A new Connection will be returned that contains + * has the attached Observer. + * + * @param {Transport} transport + * @param {string} protocol + * @param {Connection} connection + * @param {Observer} observer + * @returns {Connection} + */ +module.exports = (transport, protocol, connection, observer) => { + const peerInfo = new Promise((resolve, reject) => { + connection.getPeerInfo((err, peerInfo) => { + if (!err && peerInfo) { + resolve(peerInfo) + return + } + + const setPeerInfo = connection.setPeerInfo + connection.setPeerInfo = (pi) => { + setPeerInfo.call(connection, pi) + resolve(pi) + } + }) + }) + + const stream = { + source: pull( + connection, + observer.incoming(transport, protocol, peerInfo)), + sink: pull( + observer.outgoing(transport, protocol, peerInfo), + connection) + } + + return new Connection(stream, connection) +} diff --git a/src/switch/observer.js b/src/switch/observer.js new file mode 100644 index 0000000000..d117762869 --- /dev/null +++ b/src/switch/observer.js @@ -0,0 +1,48 @@ +'use strict' + +const map = require('pull-stream/throughs/map') +const EventEmitter = require('events') + +/** + * Takes a Switch and returns an Observer that can be used in conjunction with + * observe-connection.js. The returned Observer comes with `incoming` and + * `outgoing` properties that can be used in pull streams to emit all metadata + * for messages that pass through a Connection. + * + * @param {Switch} swtch + * @returns {EventEmitter} + */ +module.exports = (swtch) => { + const observer = Object.assign(new EventEmitter(), { + incoming: observe('in'), + outgoing: observe('out') + }) + + swtch.on('peer-mux-established', (peerInfo) => { + observer.emit('peer:connected', peerInfo.id.toB58String()) + }) + + swtch.on('peer-mux-closed', (peerInfo) => { + observer.emit('peer:closed', peerInfo.id.toB58String()) + }) + + return observer + + function observe (direction) { + return (transport, protocol, peerInfo) => { + return map((buffer) => { + willObserve(peerInfo, transport, protocol, direction, buffer.length) + return buffer + }) + } + } + + function willObserve (peerInfo, transport, protocol, direction, bufferLength) { + peerInfo.then((_peerInfo) => { + if (_peerInfo) { + const peerId = _peerInfo.id.toB58String() + observer.emit('message', peerId, transport, protocol, direction, bufferLength) + } + }) + } +} diff --git a/src/switch/package.json b/src/switch/package.json new file mode 100644 index 0000000000..7e62c692f3 --- /dev/null +++ b/src/switch/package.json @@ -0,0 +1,114 @@ +{ + "name": "libp2p-switch", + "version": "0.42.12", + "description": "libp2p switch implementation in JavaScript", + "leadMaintainer": "Jacob Heun ", + "main": "src/index.js", + "files": [ + "src", + "dist" + ], + "scripts": { + "lint": "aegir lint", + "build": "aegir build", + "test": "aegir test -t node -t browser", + "test:node": "aegir test -t node", + "test:browser": "aegir test -t browser", + "release": "aegir release -t node -t browser", + "release-minor": "aegir release --type minor -t node -t browser", + "release-major": "aegir release --type major -t node -t browser", + "coverage": "aegir coverage", + "coverage-publish": "aegir coverage --provider coveralls" + }, + "repository": { + "type": "git", + "url": "https://github.com/libp2p/js-libp2p-switch.git" + }, + "keywords": [ + "IPFS" + ], + "license": "MIT", + "bugs": { + "url": "https://github.com/libp2p/js-libp2p-switch/issues" + }, + "homepage": "https://github.com/libp2p/js-libp2p-switch", + "pre-push": [ + "lint" + ], + "engines": { + "node": ">=6.0.0", + "npm": ">=3.0.0" + }, + "devDependencies": { + "aegir": "^18.2.1", + "chai": "^4.2.0", + "chai-checkmark": "^1.0.1", + "dirty-chai": "^2.0.1", + "libp2p-mplex": "~0.8.5", + "libp2p-pnet": "~0.1.0", + "libp2p-secio": "~0.11.1", + "libp2p-spdy": "~0.13.3", + "libp2p-tcp": "~0.13.0", + "libp2p-webrtc-star": "~0.15.8", + "libp2p-websockets": "~0.12.2", + "peer-book": "~0.9.1", + "portfinder": "^1.0.20", + "pull-length-prefixed": "^1.3.2", + "pull-mplex": "~0.1.2", + "pull-pair": "^1.1.0", + "sinon": "^7.3.1", + "webrtcsupport": "^2.2.0" + }, + "dependencies": { + "async": "^2.6.2", + "bignumber.js": "^8.1.1", + "class-is": "^1.1.0", + "debug": "^4.1.1", + "err-code": "^1.1.2", + "fsm-event": "^2.1.0", + "hashlru": "^2.3.0", + "interface-connection": "~0.3.3", + "libp2p-circuit": "~0.3.6", + "libp2p-identify": "~0.7.6", + "moving-average": "^1.0.0", + "multiaddr": "^6.0.6", + "multistream-select": "~0.14.4", + "once": "^1.4.0", + "peer-id": "~0.12.2", + "peer-info": "~0.15.1", + "pull-stream": "^3.6.9", + "retimer": "^2.0.0" + }, + "contributors": [ + "Alan Shaw ", + "Alan Shaw ", + "Arnaud ", + "David Dias ", + "David Dias ", + "Dmitriy Ryajov ", + "Francisco Baio Dias ", + "Friedel Ziegelmayer ", + "Greenkeeper ", + "Haad ", + "Hugo Dias ", + "Hugo Dias ", + "Jacob Heun ", + "Jacob Heun ", + "Kevin Kwok ", + "Kobi Gurkan ", + "Maciej Krüger ", + "Matteo Collina ", + "Michael Fakhry ", + "Oli Evans ", + "Pau Ramon Revilla ", + "Pedro Teixeira ", + "Pius Nyakoojo ", + "Richard Littauer ", + "Sid Harder ", + "Vasco Santos ", + "greenkeeper[bot] ", + "harrshasri <35241544+harrshasri@users.noreply.github.com>", + "kumavis ", + "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ " + ] +} diff --git a/src/switch/plaintext.js b/src/switch/plaintext.js new file mode 100644 index 0000000000..889a07f85d --- /dev/null +++ b/src/switch/plaintext.js @@ -0,0 +1,20 @@ +'use strict' + +const setImmediate = require('async/setImmediate') + +/** + * An encryption stub in the instance that the default crypto + * has not been overriden for the Switch + */ +module.exports = { + tag: '/plaintext/1.0.0', + encrypt (myId, conn, remoteId, callback) { + if (typeof remoteId === 'function') { + callback = remoteId + remoteId = undefined + } + + setImmediate(() => callback()) + return conn + } +} diff --git a/src/switch/protocol-muxer.js b/src/switch/protocol-muxer.js new file mode 100644 index 0000000000..90c9769e93 --- /dev/null +++ b/src/switch/protocol-muxer.js @@ -0,0 +1,48 @@ +'use strict' + +const multistream = require('multistream-select') +const observeConn = require('./observe-connection') + +const debug = require('debug') +const log = debug('libp2p:switch:protocol-muxer') +log.error = debug('libp2p:switch:protocol-muxer:error') + +module.exports = function protocolMuxer (protocols, observer) { + return (transport) => (_parentConn, msListener) => { + const ms = msListener || new multistream.Listener() + let parentConn + + // Only observe the transport if we have one, and there is not already a listener + if (transport && !msListener) { + parentConn = observeConn(transport, null, _parentConn, observer) + } else { + parentConn = _parentConn + } + + Object.keys(protocols).forEach((protocol) => { + if (!protocol) { + return + } + + const handler = (protocolName, _conn) => { + log('registering handler with protocol %s', protocolName) + const protocol = protocols[protocolName] + if (protocol) { + const handlerFunc = protocol && protocol.handlerFunc + if (handlerFunc) { + const conn = observeConn(null, protocolName, _conn, observer) + handlerFunc(protocol, conn) + } + } + } + + ms.addHandler(protocol, handler, protocols[protocol].matchFunc) + }) + + ms.handle(parentConn, (err) => { + if (err) { + log.error(`multistream handshake failed`, err) + } + }) + } +} diff --git a/src/switch/stats/index.js b/src/switch/stats/index.js new file mode 100644 index 0000000000..0948e05392 --- /dev/null +++ b/src/switch/stats/index.js @@ -0,0 +1,150 @@ +'use strict' + +const EventEmitter = require('events') + +const Stat = require('./stat') +const OldPeers = require('./old-peers') + +const defaultOptions = { + computeThrottleMaxQueueSize: 1000, + computeThrottleTimeout: 2000, + movingAverageIntervals: [ + 60 * 1000, // 1 minute + 5 * 60 * 1000, // 5 minutes + 15 * 60 * 1000 // 15 minutes + ], + maxOldPeersRetention: 50 +} + +const initialCounters = [ + 'dataReceived', + 'dataSent' +] + +const directionToEvent = { + in: 'dataReceived', + out: 'dataSent' +} + +/** + * Binds to message events on the given `observer` to generate stats + * based on the Peer, Protocol and Transport used for the message. Stat + * events will be emitted via the `update` event. + * + * @param {Observer} observer + * @param {any} _options + * @returns {Stats} + */ +module.exports = (observer, _options) => { + const options = Object.assign({}, defaultOptions, _options) + const globalStats = new Stat(initialCounters, options) + + const stats = Object.assign(new EventEmitter(), { + start: start, + stop: stop, + global: globalStats, + peers: () => Array.from(peerStats.keys()), + forPeer: (peerId) => { + return peerStats.get(peerId) || oldPeers.get(peerId) + }, + transports: () => Array.from(transportStats.keys()), + forTransport: (transport) => transportStats.get(transport), + protocols: () => Array.from(protocolStats.keys()), + forProtocol: (protocol) => protocolStats.get(protocol) + }) + + globalStats.on('update', propagateChange) + + const oldPeers = OldPeers(options.maxOldPeersRetention) + const peerStats = new Map() + const transportStats = new Map() + const protocolStats = new Map() + + observer.on('peer:closed', (peerId) => { + const peer = peerStats.get(peerId) + if (peer) { + peer.removeListener('update', propagateChange) + peer.stop() + peerStats.delete(peerId) + oldPeers.set(peerId, peer) + } + }) + + return stats + + function onMessage (peerId, transportTag, protocolTag, direction, bufferLength) { + const event = directionToEvent[direction] + + if (transportTag) { + // because it has a transport tag, this message is at the global level, so we account this + // traffic as global. + globalStats.push(event, bufferLength) + + // peer stats + let peer = peerStats.get(peerId) + if (!peer) { + peer = oldPeers.get(peerId) + if (peer) { + oldPeers.delete(peerId) + } else { + peer = new Stat(initialCounters, options) + } + peer.on('update', propagateChange) + peer.start() + peerStats.set(peerId, peer) + } + peer.push(event, bufferLength) + } + + // transport stats + if (transportTag) { + let transport = transportStats.get(transportTag) + if (!transport) { + transport = new Stat(initialCounters, options) + transport.on('update', propagateChange) + transportStats.set(transportTag, transport) + } + transport.push(event, bufferLength) + } + + // protocol stats + if (protocolTag) { + let protocol = protocolStats.get(protocolTag) + if (!protocol) { + protocol = new Stat(initialCounters, options) + protocol.on('update', propagateChange) + protocolStats.set(protocolTag, protocol) + } + protocol.push(event, bufferLength) + } + } + + function start () { + observer.on('message', onMessage) + + globalStats.start() + + for (let peerStat of peerStats.values()) { + peerStat.start() + } + for (let transportStat of transportStats.values()) { + transportStat.start() + } + } + + function stop () { + observer.removeListener('message', onMessage) + globalStats.stop() + + for (let peerStat of peerStats.values()) { + peerStat.stop() + } + for (let transportStat of transportStats.values()) { + transportStat.stop() + } + } + + function propagateChange () { + stats.emit('update') + } +} diff --git a/src/switch/stats/old-peers.js b/src/switch/stats/old-peers.js new file mode 100644 index 0000000000..4ebc015a90 --- /dev/null +++ b/src/switch/stats/old-peers.js @@ -0,0 +1,15 @@ +'use strict' + +const LRU = require('hashlru') + +/** + * Creates and returns a Least Recently Used Cache + * + * @param {Number} maxSize + * @returns {LRUCache} + */ +module.exports = (maxSize) => { + const patched = LRU(maxSize) + patched.delete = patched.remove + return patched +} diff --git a/src/switch/stats/stat.js b/src/switch/stats/stat.js new file mode 100644 index 0000000000..18b4a66bad --- /dev/null +++ b/src/switch/stats/stat.js @@ -0,0 +1,239 @@ +'use strict' + +const EventEmitter = require('events') +const Big = require('bignumber.js') +const MovingAverage = require('moving-average') +const retimer = require('retimer') + +/** + * A queue based manager for stat processing + * + * @param {Array} initialCounters + * @param {any} options + */ +class Stats extends EventEmitter { + constructor (initialCounters, options) { + super() + + this._options = options + this._queue = [] + this._stats = {} + + this._frequencyLastTime = Date.now() + this._frequencyAccumulators = {} + this._movingAverages = {} + + this._update = this._update.bind(this) + + const intervals = this._options.movingAverageIntervals + + for (var i = 0; i < initialCounters.length; i++) { + var key = initialCounters[i] + this._stats[key] = Big(0) + this._movingAverages[key] = {} + for (var k = 0; k < intervals.length; k++) { + var interval = intervals[k] + var ma = this._movingAverages[key][interval] = MovingAverage(interval) + ma.push(this._frequencyLastTime, 0) + } + } + } + + /** + * Initializes the internal timer if there are items in the queue. This + * should only need to be called if `Stats.stop` was previously called, as + * `Stats.push` will also start the processing. + * + * @returns {void} + */ + start () { + if (this._queue.length) { + this._resetComputeTimeout() + } + } + + /** + * Stops processing and computing of stats by clearing the internal + * timer. + * + * @returns {void} + */ + stop () { + if (this._timeout) { + this._timeout.clear() + this._timeout = null + } + } + + /** + * Returns a clone of the current stats. + * + * @returns {Map} + */ + get snapshot () { + return Object.assign({}, this._stats) + } + + /** + * Returns a clone of the internal movingAverages + * + * @returns {Array} + */ + get movingAverages () { + return Object.assign({}, this._movingAverages) + } + + /** + * Pushes the given operation data to the queue, along with the + * current Timestamp, then resets the update timer. + * + * @param {string} counter + * @param {number} inc + * @returns {void} + */ + push (counter, inc) { + this._queue.push([counter, inc, Date.now()]) + this._resetComputeTimeout() + } + + /** + * Resets the timeout for triggering updates. + * + * @private + * @returns {void} + */ + _resetComputeTimeout () { + if (this._timeout) { + this._timeout.reschedule(this._nextTimeout()) + } else { + this._timeout = retimer(this._update, this._nextTimeout()) + } + } + + /** + * Calculates and returns the timeout for the next update based on + * the urgency of the update. + * + * @private + * @returns {number} + */ + _nextTimeout () { + // calculate the need for an update, depending on the queue length + const urgency = this._queue.length / this._options.computeThrottleMaxQueueSize + const timeout = Math.max(this._options.computeThrottleTimeout * (1 - urgency), 0) + return timeout + } + + /** + * If there are items in the queue, they will will be processed and + * the frequency for all items will be updated based on the Timestamp + * of the last item in the queue. The `update` event will also be emitted + * with the latest stats. + * + * If there are no items in the queue, no action is taken. + * + * @private + * @returns {void} + */ + _update () { + this._timeout = null + if (this._queue.length) { + let last + while (this._queue.length) { + const op = last = this._queue.shift() + this._applyOp(op) + } + + this._updateFrequency(last[2]) // contains timestamp of last op + + this.emit('update', this._stats) + } + } + + /** + * For each key in the stats, the frequncy and moving averages + * will be updated via Stats._updateFrequencyFor based on the time + * difference between calls to this method. + * + * @private + * @param {Timestamp} latestTime + * @returns {void} + */ + _updateFrequency (latestTime) { + const timeDiff = latestTime - this._frequencyLastTime + + Object.keys(this._stats).forEach((key) => { + this._updateFrequencyFor(key, timeDiff, latestTime) + }) + + this._frequencyLastTime = latestTime + } + + /** + * Updates the `movingAverages` for the given `key` and also + * resets the `frequencyAccumulator` for the `key`. + * + * @private + * @param {string} key + * @param {number} timeDiffMS Time in milliseconds + * @param {Timestamp} latestTime Time in ticks + * @returns {void} + */ + _updateFrequencyFor (key, timeDiffMS, latestTime) { + const count = this._frequencyAccumulators[key] || 0 + this._frequencyAccumulators[key] = 0 + // if `timeDiff` is zero, `hz` becomes Infinity, so we fallback to 1ms + const safeTimeDiff = timeDiffMS || 1 + const hz = (count / safeTimeDiff) * 1000 + + let movingAverages = this._movingAverages[key] + if (!movingAverages) { + movingAverages = this._movingAverages[key] = {} + } + + const intervals = this._options.movingAverageIntervals + + for (var i = 0; i < intervals.length; i++) { + var movingAverageInterval = intervals[i] + var movingAverage = movingAverages[movingAverageInterval] + if (!movingAverage) { + movingAverage = movingAverages[movingAverageInterval] = MovingAverage(movingAverageInterval) + } + movingAverage.push(latestTime, hz) + } + } + + /** + * For the given operation, `op`, the stats and `frequencyAccumulator` + * will be updated or initialized if they don't already exist. + * + * @private + * @param {Array} op + * @throws {InvalidNumber} + * @returns {void} + */ + _applyOp (op) { + const key = op[0] + const inc = op[1] + + if (typeof inc !== 'number') { + throw new Error('invalid increment number:', inc) + } + + let n + + if (!this._stats.hasOwnProperty(key)) { + n = this._stats[key] = Big(0) + } else { + n = this._stats[key] + } + this._stats[key] = n.plus(inc) + + if (!this._frequencyAccumulators[key]) { + this._frequencyAccumulators[key] = 0 + } + this._frequencyAccumulators[key] += inc + } +} + +module.exports = Stats diff --git a/src/switch/transport.js b/src/switch/transport.js new file mode 100644 index 0000000000..ce0d298f05 --- /dev/null +++ b/src/switch/transport.js @@ -0,0 +1,272 @@ +'use strict' + +/* eslint no-warning-comments: off */ + +const parallel = require('async/parallel') +const once = require('once') +const debug = require('debug') +const log = debug('libp2p:switch:transport') + +const LimitDialer = require('./limit-dialer') +const { DIAL_TIMEOUT } = require('./constants') +const { uniqueBy } = require('./utils') + +// number of concurrent outbound dials to make per peer, same as go-libp2p-swtch +const defaultPerPeerRateLimit = 8 + +/** + * Manages the transports for the switch. This simplifies dialing and listening across + * multiple transports. + */ +class TransportManager { + constructor (_switch) { + this.switch = _switch + this.dialer = new LimitDialer(defaultPerPeerRateLimit, this.switch._options.dialTimeout || DIAL_TIMEOUT) + } + + /** + * Adds a `Transport` to the list of transports on the switch, and assigns it to the given key + * + * @param {String} key + * @param {Transport} transport + * @returns {void} + */ + add (key, transport) { + log('adding %s', key) + if (this.switch.transports[key]) { + throw new Error('There is already a transport with this key') + } + + this.switch.transports[key] = transport + if (!this.switch.transports[key].listeners) { + this.switch.transports[key].listeners = [] + } + } + + /** + * Closes connections for the given transport key + * and removes it from the switch. + * + * @param {String} key + * @param {function(Error)} callback + * @returns {void} + */ + remove (key, callback) { + callback = callback || function () {} + + if (!this.switch.transports[key]) { + return callback() + } + + this.close(key, (err) => { + delete this.switch.transports[key] + callback(err) + }) + } + + /** + * Calls `remove` on each transport the switch has + * + * @param {function(Error)} callback + * @returns {void} + */ + removeAll (callback) { + const tasks = Object.keys(this.switch.transports).map((key) => { + return (cb) => { + this.remove(key, cb) + } + }) + + parallel(tasks, callback) + } + + /** + * For a given transport `key`, dial to all that transport multiaddrs + * + * @param {String} key Key of the `Transport` to dial + * @param {PeerInfo} peerInfo + * @param {function(Error, Connection)} callback + * @returns {void} + */ + dial (key, peerInfo, callback) { + const transport = this.switch.transports[key] + let multiaddrs = peerInfo.multiaddrs.toArray() + + if (!Array.isArray(multiaddrs)) { + multiaddrs = [multiaddrs] + } + + // filter the multiaddrs that are actually valid for this transport + multiaddrs = TransportManager.dialables(transport, multiaddrs, this.switch._peerInfo) + log('dialing %s', key, multiaddrs.map((m) => m.toString())) + + // dial each of the multiaddrs with the given transport + this.dialer.dialMany(peerInfo.id, transport, multiaddrs, (errors, success) => { + if (errors) { + return callback(errors) + } + + peerInfo.connect(success.multiaddr) + callback(null, success.conn) + }) + } + + /** + * For a given Transport `key`, listen on all multiaddrs in the switch's `_peerInfo`. + * If a `handler` is not provided, the Switch's `protocolMuxer` will be used. + * + * @param {String} key + * @param {*} _options Currently ignored + * @param {function(Connection)} handler + * @param {function(Error)} callback + * @returns {void} + */ + listen (key, _options, handler, callback) { + handler = this.switch._connectionHandler(key, handler) + + const transport = this.switch.transports[key] + let originalAddrs = this.switch._peerInfo.multiaddrs.toArray() + + // Until TCP can handle distinct addresses on listen, https://github.com/libp2p/interface-transport/issues/41, + // make sure we aren't trying to listen on duplicate ports. This also applies to websockets. + originalAddrs = uniqueBy(originalAddrs, (addr) => { + // Any non 0 port should register as unique + const port = Number(addr.toOptions().port) + return isNaN(port) || port === 0 ? addr.toString() : port + }) + + const multiaddrs = TransportManager.dialables(transport, originalAddrs) + + if (!transport.listeners) { + transport.listeners = [] + } + + let freshMultiaddrs = [] + + const createListeners = multiaddrs.map((ma) => { + return (cb) => { + const done = once(cb) + const listener = transport.createListener(handler) + listener.once('error', done) + + listener.listen(ma, (err) => { + if (err) { + return done(err) + } + listener.removeListener('error', done) + listener.getAddrs((err, addrs) => { + if (err) { + return done(err) + } + freshMultiaddrs = freshMultiaddrs.concat(addrs) + transport.listeners.push(listener) + done() + }) + }) + } + }) + + parallel(createListeners, (err) => { + if (err) { + return callback(err) + } + + // cause we can listen on port 0 or 0.0.0.0 + this.switch._peerInfo.multiaddrs.replace(multiaddrs, freshMultiaddrs) + callback() + }) + } + + /** + * Closes the transport with the given key, by closing all of its listeners + * + * @param {String} key + * @param {function(Error)} callback + * @returns {void} + */ + close (key, callback) { + const transport = this.switch.transports[key] + + if (!transport) { + return callback(new Error(`Trying to close non existing transport: ${key}`)) + } + + parallel(transport.listeners.map((listener) => { + return (cb) => { + listener.close(cb) + } + }), callback) + } + + /** + * For a given transport, return its multiaddrs that match the given multiaddrs + * + * @param {Transport} transport + * @param {Array} multiaddrs + * @param {PeerInfo} peerInfo Optional - a peer whose addresses should not be returned + * @returns {Array} + */ + static dialables (transport, multiaddrs, peerInfo) { + // If we dont have a proper transport, return no multiaddrs + if (!transport || !transport.filter) return [] + + const transportAddrs = transport.filter(multiaddrs) + if (!peerInfo || !transportAddrs.length) { + return transportAddrs + } + + const ourAddrs = ourAddresses(peerInfo) + + const result = transportAddrs.filter(transportAddr => { + // If our address is in the destination address, filter it out + return !ourAddrs.some(a => getDestination(transportAddr).startsWith(a)) + }) + + return result + } +} + +/** + * Expand addresses in peer info into array of addresses with and without peer + * ID suffix. + * + * @param {PeerInfo} peerInfo Our peer info object + * @returns {String[]} + */ +function ourAddresses (peerInfo) { + const ourPeerId = peerInfo.id.toB58String() + return peerInfo.multiaddrs.toArray() + .reduce((ourAddrs, addr) => { + const peerId = addr.getPeerId() + addr = addr.toString() + const otherAddr = peerId + ? addr.slice(0, addr.lastIndexOf(`/ipfs/${peerId}`)) + : `${addr}/ipfs/${ourPeerId}` + return ourAddrs.concat([addr, otherAddr]) + }, []) + .filter(a => Boolean(a)) + .concat(`/ipfs/${ourPeerId}`) +} + +const RelayProtos = [ + 'p2p-circuit', + 'p2p-websocket-star', + 'p2p-webrtc-star', + 'p2p-stardust' +] + +/** + * Get the destination address of a (possibly relay) multiaddr as a string + * + * @param {Multiaddr} addr + * @returns {String} + */ +function getDestination (addr) { + const protos = addr.protoNames().reverse() + const splitProto = protos.find(p => RelayProtos.includes(p)) + addr = addr.toString() + if (!splitProto) return addr + return addr.slice(addr.lastIndexOf(splitProto) + splitProto.length) +} + +module.exports = TransportManager diff --git a/src/switch/utils.js b/src/switch/utils.js new file mode 100644 index 0000000000..55e049432b --- /dev/null +++ b/src/switch/utils.js @@ -0,0 +1,60 @@ +'use strict' + +const Identify = require('libp2p-identify') + +/** + * For a given multistream, registers to handle the given connection + * @param {MultistreamDialer} multistream + * @param {Connection} connection + * @returns {Promise} + */ +module.exports.msHandle = (multistream, connection) => { + return new Promise((resolve, reject) => { + multistream.handle(connection, (err) => { + if (err) return reject(err) + resolve() + }) + }) +} + +/** + * For a given multistream, selects the given protocol + * @param {MultistreamDialer} multistream + * @param {string} protocol + * @returns {Promise} Resolves the selected Connection + */ +module.exports.msSelect = (multistream, protocol) => { + return new Promise((resolve, reject) => { + multistream.select(protocol, (err, connection) => { + if (err) return reject(err) + resolve(connection) + }) + }) +} + +/** + * Runs identify for the given connection and verifies it against the + * PeerInfo provided + * @param {Connection} connection + * @param {PeerInfo} cryptoPeerInfo The PeerInfo determined during crypto exchange + * @returns {Promise} Resolves {peerInfo, observedAddrs} + */ +module.exports.identifyDialer = (connection, cryptoPeerInfo) => { + return new Promise((resolve, reject) => { + Identify.dialer(connection, cryptoPeerInfo, (err, peerInfo, observedAddrs) => { + if (err) return reject(err) + resolve({ peerInfo, observedAddrs }) + }) + }) +} + +/** + * Get unique values from `arr` using `getValue` to determine + * what is used for uniqueness + * @param {Array} arr The array to get unique values for + * @param {function(value)} getValue The function to determine what is compared + * @returns {Array} + */ +module.exports.uniqueBy = (arr, getValue) => { + return [...new Map(arr.map((i) => [getValue(i), i])).values()] +} diff --git a/test/switch/browser.js b/test/switch/browser.js new file mode 100644 index 0000000000..513ed9afd2 --- /dev/null +++ b/test/switch/browser.js @@ -0,0 +1,12 @@ +/* eslint-env mocha */ +'use strict' + +const w = require('webrtcsupport') + +require('./transports.browser.js') +require('./swarm-muxing+websockets.browser') + +if (w.support) { + require('./t-webrtc-star.browser') + require('./swarm-muxing+webrtc-star.browser') +} diff --git a/test/switch/circuit-relay.node.js b/test/switch/circuit-relay.node.js new file mode 100644 index 0000000000..801273682c --- /dev/null +++ b/test/switch/circuit-relay.node.js @@ -0,0 +1,366 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const sinon = require('sinon') +const once = require('once') +const parallel = require('async/parallel') +const series = require('async/series') +const TCP = require('libp2p-tcp') +const WS = require('libp2p-websockets') +const multiplex = require('pull-mplex') +const PeerBook = require('peer-book') +const getPorts = require('portfinder').getPorts + +const utils = require('./utils') +const createInfos = utils.createInfos +const Swarm = require('libp2p-switch') +const switchOptions = { + blacklistTTL: 0 // nullifies blacklisting +} + +describe(`circuit`, function () { + describe('basic', () => { + let swarmA // TCP and WS + let swarmB // WS + let swarmC // no transports + let dialSpyA + + before((done) => createInfos(3, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + const peerC = infos[2] + + peerA.multiaddrs.add('/ip4/0.0.0.0/tcp/9001') + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/9002/ws') + + swarmA = new Swarm(peerA, new PeerBook(), switchOptions) + swarmB = new Swarm(peerB, new PeerBook()) + swarmC = new Swarm(peerC, new PeerBook()) + + swarmA.transport.add('tcp', new TCP()) + swarmA.transport.add('ws', new WS()) + swarmB.transport.add('ws', new WS()) + + dialSpyA = sinon.spy(swarmA.transport, 'dial') + + done() + })) + + after((done) => { + parallel([ + (cb) => swarmA.stop(cb), + (cb) => swarmB.stop(cb) + ], done) + }) + + it('circuit not enabled and all transports failed', (done) => { + swarmA.dial(swarmC._peerInfo, (err, conn) => { + expect(err).to.exist() + expect(err).to.match(/Circuit not enabled and all transports failed to dial peer/) + expect(conn).to.not.exist() + done() + }) + }) + + it('.enableCircuitRelay', () => { + swarmA.connection.enableCircuitRelay({ enabled: true }) + expect(Object.keys(swarmA.transports).length).to.equal(3) + + swarmB.connection.enableCircuitRelay({ enabled: true }) + expect(Object.keys(swarmB.transports).length).to.equal(2) + }) + + it('listed on the transports map', () => { + expect(swarmA.transports.Circuit).to.exist() + expect(swarmB.transports.Circuit).to.exist() + }) + + it('add /p2p-circuit addrs on start', (done) => { + parallel([ + (cb) => swarmA.start(cb), + (cb) => swarmB.start(cb) + ], (err) => { + expect(err).to.not.exist() + expect(swarmA._peerInfo.multiaddrs.toArray().filter((a) => a.toString() + .includes(`/p2p-circuit`)).length).to.be.at.least(3) + // ensure swarmA has had 0.0.0.0 replaced in the addresses + expect(swarmA._peerInfo.multiaddrs.toArray().filter((a) => a.toString() + .includes(`/0.0.0.0`)).length).to.equal(0) + expect(swarmB._peerInfo.multiaddrs.toArray().filter((a) => a.toString() + .includes(`/p2p-circuit`)).length).to.be.at.least(2) + done() + }) + }) + + it('dial circuit only once', (done) => { + swarmA._peerInfo.multiaddrs.clear() + swarmA._peerInfo.multiaddrs + .add(`/dns4/wrtc-star.discovery.libp2p.io/tcp/443/wss/p2p-webrtc-star`) + + swarmA.dial(swarmC._peerInfo, (err, conn) => { + expect(err).to.exist() + expect(err).to.match(/No available transports to dial peer/) + expect(conn).to.not.exist() + expect(dialSpyA.callCount).to.be.eql(1) + done() + }) + }) + + it('dial circuit last', (done) => { + const peerC = swarmC._peerInfo + peerC.multiaddrs.clear() + peerC.multiaddrs.add(`/p2p-circuit/ipfs/ABCD`) + peerC.multiaddrs.add(`/ip4/127.0.0.1/tcp/9998/ipfs/ABCD`) + peerC.multiaddrs.add(`/ip4/127.0.0.1/tcp/9999/ws/ipfs/ABCD`) + + swarmA.dial(peerC, (err, conn) => { + expect(err).to.exist() + expect(conn).to.not.exist() + expect(dialSpyA.lastCall.args[0]).to.be.eql('Circuit') + done() + }) + }) + + it('should not try circuit if no transports enabled', (done) => { + swarmC.dial(swarmA._peerInfo, (err, conn) => { + expect(err).to.exist() + expect(conn).to.not.exist() + + expect(err).to.match(/No transports registered, dial not possible/) + done() + }) + }) + + it('should not dial circuit if other transport succeed', (done) => { + swarmA.dial(swarmB._peerInfo, (err) => { + expect(err).not.to.exist() + expect(dialSpyA.lastCall.args[0]).to.not.be.eql('Circuit') + done() + }) + }) + }) + + describe('in a basic network', () => { + // Create 5 nodes + // Make node 1 act as a Bootstrap node and relay (speak tcp and ws) + // Make nodes 2 & 3 speak tcp only + // Make nodes 4 & 5 speak WS only + // Have all nodes dial node 1 + // Each node should get the peers of node 1 + // Attempt to dial to each peer + let bootstrapSwitch + let tcpSwitch1 + let tcpSwitch2 + let wsSwitch1 + let wsSwitch2 + let bootstrapPeer + let tcpPeer1 + let tcpPeer2 + let wsPeer1 + let wsPeer2 + + before((done) => createInfos(5, (err, infos) => { + expect(err).to.not.exist() + + getPorts(6, (err, ports) => { + expect(err).to.not.exist() + + bootstrapPeer = infos[0] + tcpPeer1 = infos[1] + tcpPeer2 = infos[2] + wsPeer1 = infos[3] + wsPeer2 = infos[4] + + // Setup the addresses of our nodes + bootstrapPeer.multiaddrs.add(`/ip4/0.0.0.0/tcp/${ports.shift()}`) + bootstrapPeer.multiaddrs.add(`/ip4/0.0.0.0/tcp/${ports.shift()}/ws`) + tcpPeer1.multiaddrs.add(`/ip4/0.0.0.0/tcp/${ports.shift()}`) + tcpPeer2.multiaddrs.add(`/ip4/0.0.0.0/tcp/${ports.shift()}`) + wsPeer1.multiaddrs.add(`/ip4/0.0.0.0/tcp/${ports.shift()}/ws`) + wsPeer2.multiaddrs.add(`/ip4/0.0.0.0/tcp/${ports.shift()}/ws`) + + // Setup the bootstrap node with the minimum needed for being a relay + bootstrapSwitch = new Swarm(bootstrapPeer, new PeerBook()) + bootstrapSwitch.connection.addStreamMuxer(multiplex) + bootstrapSwitch.connection.reuse() + bootstrapSwitch.connection.enableCircuitRelay({ + enabled: true, + // The relay needs to allow hopping + hop: { + enabled: true + } + }) + + // Setup the tcp1 node with the minimum needed for dialing via a relay + tcpSwitch1 = new Swarm(tcpPeer1, new PeerBook()) + tcpSwitch1.connection.addStreamMuxer(multiplex) + tcpSwitch1.connection.reuse() + tcpSwitch1.connection.enableCircuitRelay({ + enabled: true + }) + + // Setup tcp2 node to not be able to dial/listen over relay + tcpSwitch2 = new Swarm(tcpPeer2, new PeerBook()) + tcpSwitch2.connection.reuse() + tcpSwitch2.connection.addStreamMuxer(multiplex) + + // Setup the ws1 node with the minimum needed for dialing via a relay + wsSwitch1 = new Swarm(wsPeer1, new PeerBook()) + wsSwitch1.connection.addStreamMuxer(multiplex) + wsSwitch1.connection.reuse() + wsSwitch1.connection.enableCircuitRelay({ + enabled: true + }) + + // Setup the ws2 node with the minimum needed for dialing via a relay + wsSwitch2 = new Swarm(wsPeer2, new PeerBook()) + wsSwitch2.connection.addStreamMuxer(multiplex) + wsSwitch2.connection.reuse() + wsSwitch2.connection.enableCircuitRelay({ + enabled: true + }) + + bootstrapSwitch.transport.add('tcp', new TCP()) + bootstrapSwitch.transport.add('ws', new WS()) + tcpSwitch1.transport.add('tcp', new TCP()) + tcpSwitch2.transport.add('tcp', new TCP()) + wsSwitch1.transport.add('ws', new WS()) + wsSwitch2.transport.add('ws', new WS()) + + series([ + // start the nodes + (cb) => { + parallel([ + (cb) => bootstrapSwitch.start(cb), + (cb) => tcpSwitch1.start(cb), + (cb) => tcpSwitch2.start(cb), + (cb) => wsSwitch1.start(cb), + (cb) => wsSwitch2.start(cb) + ], cb) + }, + // dial to the bootstrap node + (cb) => { + parallel([ + (cb) => tcpSwitch1.dial(bootstrapPeer, cb), + (cb) => tcpSwitch2.dial(bootstrapPeer, cb), + (cb) => wsSwitch1.dial(bootstrapPeer, cb), + (cb) => wsSwitch2.dial(bootstrapPeer, cb) + ], cb) + } + ], (err) => { + if (err) return done(err) + + if (bootstrapSwitch._peerBook.getAllArray().length === 4) { + return done() + } + + done = once(done) + // Wait for everyone to connect, before we try relaying + bootstrapSwitch.on('peer-mux-established', () => { + if (bootstrapSwitch._peerBook.getAllArray().length === 4) { + done() + } + }) + }) + }) + })) + + before('wait so hop status can be negotiated', function (done) { + setTimeout(done, 1000) + }) + + after(function (done) { + parallel([ + (cb) => bootstrapSwitch.stop(cb), + (cb) => tcpSwitch1.stop(cb), + (cb) => tcpSwitch2.stop(cb), + (cb) => wsSwitch1.stop(cb), + (cb) => wsSwitch2.stop(cb) + ], done) + }) + + it('should be able to dial tcp -> tcp', (done) => { + tcpSwitch2.on('peer-mux-established', (peerInfo) => { + if (peerInfo.id.toB58String() === tcpPeer1.id.toB58String()) { + tcpSwitch2.removeAllListeners('peer-mux-established') + done() + } + }) + tcpSwitch1.dial(tcpPeer2, (err, connection) => { + expect(err).to.not.exist() + // We're not dialing a protocol, so we won't get a connection back + expect(connection).to.be.undefined() + }) + }) + + it('should be able to dial tcp -> ws over relay', (done) => { + wsSwitch1.on('peer-mux-established', (peerInfo) => { + if (peerInfo.id.toB58String() === tcpPeer1.id.toB58String()) { + wsSwitch1.removeAllListeners('peer-mux-established') + done() + } + }) + + tcpSwitch1.dial(wsPeer1, (err, connection) => { + expect(err).to.not.exist() + // We're not dialing a protocol, so we won't get a connection back + expect(connection).to.be.undefined() + }) + }) + + it('should be able to dial ws -> ws', (done) => { + wsSwitch2.on('peer-mux-established', (peerInfo) => { + if (peerInfo.id.toB58String() === wsPeer1.id.toB58String()) { + wsSwitch2.removeAllListeners('peer-mux-established') + done() + } + }) + wsSwitch1.dial(wsPeer2, (err, connection) => { + expect(err).to.not.exist() + // We're not dialing a protocol, so we won't get a connection back + expect(connection).to.be.undefined() + }) + }) + + it('should be able to dial ws -> tcp over relay', (done) => { + tcpSwitch1.on('peer-mux-established', (peerInfo) => { + if (peerInfo.id.toB58String() === wsPeer2.id.toB58String()) { + tcpSwitch1.removeAllListeners('peer-mux-established') + expect(Object.keys(tcpSwitch1._peerBook.getAll())).to.include(wsPeer2.id.toB58String()) + done() + } + }) + + wsSwitch2.dial(tcpPeer1, (err, connection) => { + expect(err).to.not.exist() + // We're not dialing a protocol, so we won't get a connection back + expect(connection).to.be.undefined() + }) + }) + + it('shouldnt be able to dial to a non relay node', (done) => { + // tcpPeer2 doesnt have relay enabled + wsSwitch1.dial(tcpPeer2, (err, connection) => { + expect(err).to.exist() + expect(connection).to.not.exist() + done() + }) + }) + + it('shouldnt be able to dial from a non relay node', (done) => { + // tcpSwitch2 doesnt have relay enabled + tcpSwitch2.dial(wsPeer1, (err, connection) => { + expect(err).to.exist() + expect(connection).to.not.exist() + done() + }) + }) + }) +}) diff --git a/test/switch/connection.node.js b/test/switch/connection.node.js new file mode 100644 index 0000000000..732471ae5b --- /dev/null +++ b/test/switch/connection.node.js @@ -0,0 +1,452 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const expect = chai.expect +chai.use(require('dirty-chai')) +chai.use(require('chai-checkmark')) +const sinon = require('sinon') +const PeerBook = require('peer-book') +const WS = require('libp2p-websockets') +const parallel = require('async/parallel') +const secio = require('libp2p-secio') +const pull = require('pull-stream') +const multiplex = require('pull-mplex') +const spdy = require('libp2p-spdy') +const Connection = require('interface-connection').Connection +const Protector = require('libp2p-pnet') +const generatePSK = Protector.generate + +const psk = Buffer.alloc(95) +generatePSK(psk) + +const ConnectionFSM = require('libp2p-switch/connection') +const Switch = require('libp2p-switch') +const createInfos = require('./utils').createInfos + +describe('ConnectionFSM', () => { + let spdySwitch + let listenerSwitch + let dialerSwitch + + before((done) => { + createInfos(3, (err, infos) => { + if (err) { + return done(err) + } + + dialerSwitch = new Switch(infos.shift(), new PeerBook()) + dialerSwitch._peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/15451/ws') + dialerSwitch.connection.crypto(secio.tag, secio.encrypt) + dialerSwitch.connection.addStreamMuxer(multiplex) + dialerSwitch.transport.add('ws', new WS()) + + listenerSwitch = new Switch(infos.shift(), new PeerBook()) + listenerSwitch._peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/15452/ws') + listenerSwitch.connection.crypto(secio.tag, secio.encrypt) + listenerSwitch.connection.addStreamMuxer(multiplex) + listenerSwitch.transport.add('ws', new WS()) + + spdySwitch = new Switch(infos.shift(), new PeerBook()) + spdySwitch._peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/15453/ws') + spdySwitch.connection.crypto(secio.tag, secio.encrypt) + spdySwitch.connection.addStreamMuxer(spdy) + spdySwitch.transport.add('ws', new WS()) + + parallel([ + (cb) => dialerSwitch.start(cb), + (cb) => listenerSwitch.start(cb), + (cb) => spdySwitch.start(cb) + ], (err) => { + done(err) + }) + }) + }) + + after((done) => { + parallel([ + (cb) => dialerSwitch.stop(cb), + (cb) => listenerSwitch.stop(cb), + (cb) => spdySwitch.stop(cb) + ], () => { + done() + }) + }) + + it('should have a default state of disconnected', () => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + expect(connection.getState()).to.equal('DISCONNECTED') + }) + + it('should emit an error with an invalid transition', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + expect(connection.getState()).to.equal('DISCONNECTED') + + connection.once('error', (err) => { + expect(err).to.have.property('code', 'INVALID_STATE_TRANSITION') + done() + }) + connection.upgrade() + }) + + it('.dial should create a basic connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + done() + }) + + connection.dial() + }) + + it('should be able to close with an error and not throw', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + expect(() => connection.close(new Error('shutting down'))).to.not.throw() + done() + }) + + connection.dial() + }) + + it('should emit warning on dial failed attempt', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + const stub = sinon.stub(dialerSwitch.transport, 'dial').callsArgWith(2, [ + new Error('address in use') + ]) + + connection.once('error:connection_attempt_failed', (errors) => { + expect(errors).to.have.length(1).mark() + stub.restore() + }) + + connection.once('error', (err) => { + expect(err).to.exist().mark() + }) + + expect(2).checks(done) + + connection.dial() + }) + + it('should ignore concurrent dials', () => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + const stub = sinon.stub(connection, '_onDialing') + + connection.dial() + connection.dial() + + expect(stub.callCount).to.equal(1) + }) + + it('should be able to encrypt a basic connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + done() + }) + + connection.dial() + }) + + it('should disconnect on encryption failure', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + const stub = sinon.stub(dialerSwitch.crypto, 'encrypt') + .callsArgWith(3, new Error('fail encrypt')) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('close', () => { + stub.restore() + done() + }) + connection.once('encrypted', () => { + throw new Error('should not encrypt') + }) + + connection.dial() + }) + + it('should be able to upgrade an encrypted connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.upgrade() + }) + connection.once('muxed', (conn) => { + expect(conn.multicodec).to.equal(multiplex.multicodec) + done() + }) + + connection.dial() + }) + + it('should fail to upgrade a connection with incompatible muxers', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: spdySwitch._peerInfo + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.upgrade() + }) + connection.once('error:upgrade_failed', (err) => { + expect(err).to.exist() + done() + }) + + connection.dial() + }) + + it('should be able to handshake a protocol over a muxed connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + listenerSwitch.handle('/muxed-conn-test/1.0.0', (_, conn) => { + return pull(conn, conn) + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.upgrade() + }) + connection.once('muxed', (conn) => { + expect(conn.multicodec).to.equal(multiplex.multicodec) + + connection.shake('/muxed-conn-test/1.0.0', (err, protocolConn) => { + expect(err).to.not.exist() + expect(protocolConn).to.be.an.instanceof(Connection) + done() + }) + }) + + connection.dial() + }) + + it('should not return a connection when handshaking with no protocol', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + listenerSwitch.handle('/muxed-conn-test/1.0.0', (_, conn) => { + return pull(conn, conn) + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.upgrade() + }) + connection.once('muxed', (conn) => { + expect(conn.multicodec).to.equal(multiplex.multicodec) + + connection.shake(null, (err, protocolConn) => { + expect(err).to.not.exist() + expect(protocolConn).to.not.exist() + done() + }) + }) + + connection.dial() + }) + + describe('with no muxers', () => { + let oldMuxers + before(() => { + oldMuxers = dialerSwitch.muxers + dialerSwitch.muxers = {} + }) + + after(() => { + dialerSwitch.muxers = oldMuxers + }) + + it('should be able to handshake a protocol over a basic connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + listenerSwitch.handle('/unmuxed-conn-test/1.0.0', (_, conn) => { + return pull(conn, conn) + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.upgrade() + }) + connection.once('muxed', () => { + throw new Error('connection shouldnt be muxed') + }) + connection.once('unmuxed', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + + connection.shake('/unmuxed-conn-test/1.0.0', (err, protocolConn) => { + expect(err).to.not.exist() + expect(protocolConn).to.be.an.instanceof(Connection) + done() + }) + }) + + connection.dial() + }) + }) + + describe('with a protector', () => { + // Restart the switches with protectors + before((done) => { + parallel([ + (cb) => dialerSwitch.stop(cb), + (cb) => listenerSwitch.stop(cb) + ], () => { + dialerSwitch.protector = new Protector(psk) + listenerSwitch.protector = new Protector(psk) + + parallel([ + (cb) => dialerSwitch.start(cb), + (cb) => listenerSwitch.start(cb) + ], done) + }) + }) + + afterEach(() => { + sinon.restore() + }) + + it('should be able to protect a basic connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + connection.once('private', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + done() + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.protect() + }) + + connection.dial() + }) + + it('should close on failed protection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + const error = new Error('invalid key') + const stub = sinon.stub(dialerSwitch.protector, 'protect').callsFake((_, cb) => { + cb(error) + }) + + expect(3).check(done) + + connection.once('close', () => { + expect(stub.callCount).to.eql(1).mark() + }) + + connection.once('error', (err) => { + expect(err).to.eql(error).mark() + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection).mark() + connection.protect() + }) + + connection.dial() + }) + + it('should be able to encrypt a protected connection', (done) => { + const connection = new ConnectionFSM({ + _switch: dialerSwitch, + peerInfo: listenerSwitch._peerInfo + }) + + connection.once('connected', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.protect() + }) + connection.once('private', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + connection.encrypt() + }) + connection.once('encrypted', (conn) => { + expect(conn).to.be.an.instanceof(Connection) + done() + }) + + connection.dial() + }) + }) +}) diff --git a/test/switch/constructor.spec.js b/test/switch/constructor.spec.js new file mode 100644 index 0000000000..8dbb12b86e --- /dev/null +++ b/test/switch/constructor.spec.js @@ -0,0 +1,15 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const Switch = require('libp2p-switch') + +describe('create Switch instance', () => { + it('throws on missing peerInfo', () => { + expect(() => new Switch()).to.throw(/You must provide a `peerInfo`/) + }) +}) diff --git a/test/switch/dial-fsm.node.js b/test/switch/dial-fsm.node.js new file mode 100644 index 0000000000..6014e0d391 --- /dev/null +++ b/test/switch/dial-fsm.node.js @@ -0,0 +1,405 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 5] */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(require('chai-checkmark')) +chai.use(dirtyChai) +const sinon = require('sinon') +const PeerBook = require('peer-book') +const parallel = require('async/parallel') +const series = require('async/series') +const WS = require('libp2p-websockets') +const TCP = require('libp2p-tcp') +const secio = require('libp2p-secio') +const multiplex = require('pull-mplex') +const pull = require('pull-stream') +const identify = require('libp2p-identify') + +const utils = require('./utils') +const createInfos = utils.createInfos +const Switch = require('libp2p-switch') + +describe('dialFSM', () => { + let switchA + let switchB + let switchC + let switchDialOnly + let peerAId + let peerBId + let protocol + + before((done) => createInfos(4, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + const peerC = infos[2] + const peerDialOnly = infos[3] + + peerAId = peerA.id.toB58String() + peerBId = peerB.id.toB58String() + + peerA.multiaddrs.add('/ip4/0.0.0.0/tcp/0') + peerB.multiaddrs.add('/ip4/0.0.0.0/tcp/0') + peerC.multiaddrs.add('/ip4/0.0.0.0/tcp/0/ws') + // Give peer C a tcp address we wont actually support + peerC.multiaddrs.add('/ip4/0.0.0.0/tcp/0') + + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + switchC = new Switch(peerC, new PeerBook()) + switchDialOnly = new Switch(peerDialOnly, new PeerBook()) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + switchC.transport.add('ws', new WS()) + switchDialOnly.transport.add('ws', new WS()) + + switchA.connection.crypto(secio.tag, secio.encrypt) + switchB.connection.crypto(secio.tag, secio.encrypt) + switchC.connection.crypto(secio.tag, secio.encrypt) + switchDialOnly.connection.crypto(secio.tag, secio.encrypt) + + switchA.connection.addStreamMuxer(multiplex) + switchB.connection.addStreamMuxer(multiplex) + switchC.connection.addStreamMuxer(multiplex) + switchDialOnly.connection.addStreamMuxer(multiplex) + + switchA.connection.reuse() + switchB.connection.reuse() + switchC.connection.reuse() + switchDialOnly.connection.reuse() + + parallel([ + (cb) => switchA.start(cb), + (cb) => switchB.start(cb), + (cb) => switchC.start(cb) + ], done) + })) + + after((done) => { + parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb), + (cb) => switchC.stop(cb) + ], done) + }) + + afterEach(() => { + switchA.unhandle(protocol) + switchB.unhandle(protocol) + switchC.unhandle(protocol) + protocol = null + }) + + it('should emit `error:connection_attempt_failed` when a transport fails to dial', (done) => { + protocol = '/warn/1.0.0' + switchC.handle(protocol, () => { }) + + switchA.dialFSM(switchC._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + connFSM.once('error:connection_attempt_failed', (errors) => { + expect(errors).to.be.an('array') + expect(errors).to.have.length(1) + done() + }) + }) + }) + + it('should emit an `error` event when a it cannot dial a peer', (done) => { + protocol = '/error/1.0.0' + switchC.handle(protocol, () => { }) + + switchA.dialer.clearBlacklist(switchC._peerInfo) + switchA.dialFSM(switchC._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + connFSM.once('error', (err) => { + expect(err).to.be.exist() + expect(err).to.have.property('code', 'CONNECTION_FAILED') + done() + }) + }) + }) + + it('should error when the peer is blacklisted', (done) => { + protocol = '/error/1.0.0' + switchC.handle(protocol, () => { }) + + switchA.dialer.clearBlacklist(switchC._peerInfo) + switchA.dialFSM(switchC._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + connFSM.once('error', () => { + // dial with the blacklist + switchA.dialFSM(switchC._peerInfo, protocol, (err) => { + expect(err).to.exist() + expect(err.code).to.eql('ERR_BLACKLISTED') + done() + }) + }) + }) + }) + + it('should not blacklist a peer that was successfully connected', (done) => { + protocol = '/noblacklist/1.0.0' + switchB.handle(protocol, () => { }) + + switchA.dialer.clearBlacklist(switchB._peerInfo) + switchA.dialFSM(switchB._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + connFSM.once('connection', () => { + connFSM.once('close', () => { + // peer should not be blacklisted + switchA.dialFSM(switchB._peerInfo, protocol, (err, conn) => { + expect(err).to.not.exist() + conn.once('close', done) + conn.close() + }) + }) + connFSM.close(new Error('bad things')) + }) + }) + }) + + it('should clear the blacklist for a peer that connected to us', (done) => { + series([ + // Attempt to dial the peer that's not listening + (cb) => switchC.dial(switchDialOnly._peerInfo, (err) => { + expect(err).to.exist() + cb() + }), + // Dial from the dial only peer + (cb) => switchDialOnly.dial(switchC._peerInfo, (err) => { + expect(err).to.not.exist() + // allow time for muxing to occur + setTimeout(cb, 100) + }), + // "Dial" to the dial only peer, this should reuse the existing connection + (cb) => switchC.dial(switchDialOnly._peerInfo, (err) => { + expect(err).to.not.exist() + cb() + }) + ], (err) => { + expect(err).to.not.exist() + done() + }) + }) + + it('should emit a `closed` event when closed', (done) => { + protocol = '/closed/1.0.0' + switchB.handle(protocol, () => { }) + + switchA.dialFSM(switchB._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + + connFSM.once('close', () => { + expect(switchA.connection.getAllById(peerBId)).to.have.length(0) + done() + }) + + connFSM.once('muxed', () => { + expect(switchA.connection.getAllById(peerBId)).to.have.length(1) + connFSM.close() + }) + }) + }) + + it('should have the peers protocols once connected', (done) => { + protocol = '/lscheck/1.0.0' + switchB.handle(protocol, () => { }) + + expect(4).checks(done) + + switchB.once('peer-mux-established', (peerInfo) => { + const peerB = switchA._peerBook.get(switchB._peerInfo.id.toB58String()) + const peerA = switchB._peerBook.get(switchA._peerInfo.id.toB58String()) + // Verify the dialer knows the receiver's protocols + expect(Array.from(peerB.protocols)).to.eql([ + multiplex.multicodec, + identify.multicodec, + protocol + ]).mark() + // Verify the receiver knows the dialer's protocols + expect(Array.from(peerA.protocols)).to.eql([ + multiplex.multicodec, + identify.multicodec + ]).mark() + + switchA.hangUp(switchB._peerInfo) + }) + + switchA.dialFSM(switchB._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist().mark() + + connFSM.once('close', () => { + // Just mark that close was called + expect(true).to.eql(true).mark() + }) + }) + }) + + it('should close when the receiver closes', (done) => { + protocol = '/closed/1.0.0' + switchB.handle(protocol, () => { }) + + // wait for the expects to happen + expect(2).checks(() => { + done() + }) + + switchB.on('peer-mux-established', (peerInfo) => { + if (peerInfo.id.toB58String() === peerAId) { + switchB.removeAllListeners('peer-mux-established') + expect(switchB.connection.getAllById(peerAId)).to.have.length(1).mark() + switchB.connection.getOne(peerAId).close() + } + }) + + switchA.dialFSM(switchB._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + + connFSM.once('close', () => { + expect(switchA.connection.getAllById(peerBId)).to.have.length(0).mark() + }) + }) + }) + + it('parallel dials to the same peer should not create new connections', (done) => { + switchB.handle('/parallel/2.0.0', (_, conn) => { pull(conn, conn) }) + + parallel([ + (cb) => switchA.dialFSM(switchB._peerInfo, '/parallel/2.0.0', cb), + (cb) => switchA.dialFSM(switchB._peerInfo, '/parallel/2.0.0', cb) + ], (err, results) => { + expect(err).to.not.exist() + expect(results).to.have.length(2) + expect(switchA.connection.getAllById(peerBId)).to.have.length(1) + + switchA.hangUp(switchB._peerInfo, () => { + expect(switchA.connection.getAllById(peerBId)).to.have.length(0) + done() + }) + }) + }) + + it('parallel dials to one another should disconnect on hangup', function (done) { + this.timeout(10e3) + protocol = '/parallel/1.0.0' + + switchA.handle(protocol, (_, conn) => { pull(conn, conn) }) + switchB.handle(protocol, (_, conn) => { pull(conn, conn) }) + + expect(switchA.connection.getAllById(peerBId)).to.have.length(0) + + // Expect 4 `peer-mux-established` events + expect(4).checks(() => { + // Expect 2 `peer-mux-closed`, plus 1 hangup + expect(3).checks(() => { + switchA.removeAllListeners('peer-mux-closed') + switchB.removeAllListeners('peer-mux-closed') + switchA.removeAllListeners('peer-mux-established') + switchB.removeAllListeners('peer-mux-established') + done() + }) + + switchA.hangUp(switchB._peerInfo, (err) => { + expect(err).to.not.exist().mark() + }) + }) + + switchA.on('peer-mux-established', (peerInfo) => { + expect(peerInfo.id.toB58String()).to.eql(peerBId).mark() + }) + switchB.on('peer-mux-established', (peerInfo) => { + expect(peerInfo.id.toB58String()).to.eql(peerAId).mark() + }) + + switchA.on('peer-mux-closed', (peerInfo) => { + expect(peerInfo.id.toB58String()).to.eql(peerBId).mark() + }) + switchB.on('peer-mux-closed', (peerInfo) => { + expect(peerInfo.id.toB58String()).to.eql(peerAId).mark() + }) + + switchA.dialFSM(switchB._peerInfo, protocol, (err, connFSM) => { + expect(err).to.not.exist() + // Hold the dial from A, until switch B is done dialing to ensure + // we have both incoming and outgoing connections + connFSM._state.on('DIALING:leave', (cb) => { + switchB.dialFSM(switchA._peerInfo, protocol, (err, connB) => { + expect(err).to.not.exist() + connB.on('muxed', cb) + }) + }) + }) + }) + + it('parallel dials to one another should disconnect on stop', (done) => { + protocol = '/parallel/1.0.0' + switchA.handle(protocol, (_, conn) => { pull(conn, conn) }) + switchB.handle(protocol, (_, conn) => { pull(conn, conn) }) + + // 2 close checks and 1 hangup check + expect(2).checks(() => { + switchA.removeAllListeners('peer-mux-closed') + switchB.removeAllListeners('peer-mux-closed') + // restart the node for subsequent tests + switchA.start(done) + }) + + switchA.on('peer-mux-closed', (peerInfo) => { + expect(peerInfo.id.toB58String()).to.eql(peerBId).mark() + }) + switchB.on('peer-mux-closed', (peerInfo) => { + expect(peerInfo.id.toB58String()).to.eql(peerAId).mark() + }) + + switchA.dialFSM(switchB._peerInfo, '/parallel/1.0.0', (err, connFSM) => { + expect(err).to.not.exist() + // Hold the dial from A, until switch B is done dialing to ensure + // we have both incoming and outgoing connections + connFSM._state.on('DIALING:leave', (cb) => { + switchB.dialFSM(switchA._peerInfo, '/parallel/1.0.0', (err, connB) => { + expect(err).to.not.exist() + connB.on('muxed', cb) + }) + }) + + connFSM.on('connection', () => { + // Hangup and verify the connections are closed + switchA.stop((err) => { + expect(err).to.not.exist().mark() + }) + }) + }) + }) + + it('queued dials should be aborted on node stop', (done) => { + switchB.handle('/abort-queue/1.0.0', (_, conn) => { pull(conn, conn) }) + + switchA.dialFSM(switchB._peerInfo, '/abort-queue/1.0.0', (err, connFSM) => { + expect(err).to.not.exist() + // 2 conn aborts, 1 close, and 1 stop + expect(4).checks(done) + + connFSM.once('close', (err) => { + expect(err).to.not.exist().mark() + }) + + sinon.stub(connFSM, '_onUpgrading').callsFake(() => { + switchA.dialFSM(switchB._peerInfo, '/abort-queue/1.0.0', (err) => { + expect(err.code).to.eql('DIAL_ABORTED').mark() + }) + switchA.dialFSM(switchB._peerInfo, '/abort-queue/1.0.0', (err) => { + expect(err.code).to.eql('DIAL_ABORTED').mark() + }) + + switchA.stop((err) => { + expect(err).to.not.exist().mark() + }) + }) + }) + }) +}) diff --git a/test/switch/dialSelf.spec.js b/test/switch/dialSelf.spec.js new file mode 100644 index 0000000000..83251d1937 --- /dev/null +++ b/test/switch/dialSelf.spec.js @@ -0,0 +1,85 @@ +'use strict' + +/* eslint-env mocha */ + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const { EventEmitter } = require('events') +const PeerBook = require('peer-book') +const Duplex = require('pull-pair/duplex') + +const utils = require('./utils') +const createInfos = utils.createInfos +const Swarm = require('libp2p-switch') + +class MockTransport extends EventEmitter { + constructor () { + super() + this.conn = Duplex() + } + dial (addr, cb) { + let c = this.conn[0] + this.emit('connection', this.conn[1]) + setImmediate(() => cb(null, c)) + return c + } + listen (addr, cb) { + return cb() + } + filter (mas) { + return Array.isArray(mas) ? mas : [mas] + } +} + +describe(`dial self`, () => { + let swarmA + let peerInfos + + before((done) => createInfos(2, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos.shift() + peerInfos = infos + + peerA.multiaddrs.add('/ip4/127.0.0.1/tcp/9001') + peerA.multiaddrs.add(`/ip4/127.0.0.1/tcp/9001/ipfs/${peerA.id.toB58String()}`) + peerA.multiaddrs.add(`/ip4/127.0.0.1/tcp/9001/p2p-circuit/ipfs/${peerA.id.toB58String()}`) + peerA.multiaddrs.add('/ip4/0.0.0.0/tcp/9001') + peerA.multiaddrs.add(`/ip4/0.0.0.0/tcp/9001/ipfs/${peerA.id.toB58String()}`) + peerA.multiaddrs.add(`/ip4/0.0.0.0/tcp/9001/p2p-circuit/ipfs/${peerA.id.toB58String()}`) + + swarmA = new Swarm(peerA, new PeerBook()) + + swarmA.transport.add('tcp', new MockTransport()) + + done() + })) + + after((done) => swarmA.stop(done)) + + it('node should not be able to dial itself', (done) => { + swarmA.dial(swarmA._peerInfo, (err, conn) => { + expect(err).to.exist() + expect(() => { throw err }).to.throw(/A node cannot dial itself/) + expect(conn).to.not.exist() + done() + }) + }) + + it('node should not be able to dial another peers address that matches its own', (done) => { + const peerB = peerInfos.shift() + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/9001') + peerB.multiaddrs.add('/ip4/0.0.0.0/tcp/9001') + peerB.multiaddrs.add(`/ip4/0.0.0.0/tcp/9001/ipfs/${peerB.id.toB58String()}`) + + swarmA.dial(peerB, (err, conn) => { + expect(err).to.exist() + expect(err.code).to.eql('CONNECTION_FAILED') + expect(conn).to.not.exist() + done() + }) + }) +}) diff --git a/test/switch/dialer.spec.js b/test/switch/dialer.spec.js new file mode 100644 index 0000000000..f87f7171db --- /dev/null +++ b/test/switch/dialer.spec.js @@ -0,0 +1,230 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(require('chai-checkmark')) +chai.use(dirtyChai) +const sinon = require('sinon') + +const PeerBook = require('peer-book') +const Queue = require('libp2p-switch/dialer/queue') +const QueueManager = require('libp2p-switch/dialer/queueManager') +const Switch = require('libp2p-switch') +const { PRIORITY_HIGH, PRIORITY_LOW } = require('libp2p-switch/constants') + +const utils = require('./utils') +const createInfos = utils.createInfos + +describe('dialer', () => { + let switchA + let switchB + + before((done) => createInfos(2, (err, infos) => { + expect(err).to.not.exist() + + switchA = new Switch(infos[0], new PeerBook()) + switchB = new Switch(infos[1], new PeerBook()) + + done() + })) + + afterEach(() => { + sinon.restore() + }) + + describe('connect', () => { + afterEach(() => { + switchA.dialer.clearBlacklist(switchB._peerInfo) + }) + + it('should use default options', (done) => { + switchA.dialer.connect(switchB._peerInfo, (err) => { + expect(err).to.exist() + done() + }) + }) + + it('should be able to use custom options', (done) => { + switchA.dialer.connect(switchB._peerInfo, { useFSM: true, priority: PRIORITY_HIGH }, (err) => { + expect(err).to.exist() + done() + }) + }) + }) + + describe('queue', () => { + it('should blacklist forever after 5 blacklists', () => { + const queue = new Queue('QM', switchA) + for (var i = 0; i < 4; i++) { + queue.blacklist() + expect(queue.blackListed).to.be.a('number') + expect(queue.blackListed).to.not.eql(Infinity) + } + + queue.blacklist() + expect(queue.blackListed).to.eql(Infinity) + }) + }) + + describe('queue manager', () => { + let queueManager + before(() => { + queueManager = new QueueManager(switchA) + }) + + it('should abort cold calls when the queue is full', (done) => { + sinon.stub(queueManager._coldCallQueue, 'size').value(switchA.dialer.MAX_COLD_CALLS) + const dialRequest = { + peerInfo: { + id: { toB58String: () => 'QmA' } + }, + protocol: null, + options: { useFSM: true, priority: PRIORITY_LOW }, + callback: (err) => { + expect(err.code).to.eql('DIAL_ABORTED') + done() + } + } + + queueManager.add(dialRequest) + }) + + it('should add a protocol dial to the normal queue', () => { + const dialRequest = { + peerInfo: { + id: { toB58String: () => 'QmA' }, + isConnected: () => null + }, + protocol: '/echo/1.0.0', + options: { useFSM: true, priority: PRIORITY_HIGH }, + callback: () => {} + } + + const runSpy = sinon.stub(queueManager, 'run') + const addSpy = sinon.stub(queueManager._queue, 'add') + const deleteSpy = sinon.stub(queueManager._coldCallQueue, 'delete') + + queueManager.add(dialRequest) + + expect(runSpy.called).to.eql(true) + expect(addSpy.called).to.eql(true) + expect(addSpy.getCall(0).args[0]).to.eql('QmA') + expect(deleteSpy.called).to.eql(true) + expect(deleteSpy.getCall(0).args[0]).to.eql('QmA') + }) + + it('should add a cold call to the cold call queue', () => { + const dialRequest = { + peerInfo: { + id: { toB58String: () => 'QmA' }, + isConnected: () => null + }, + protocol: null, + options: { useFSM: true, priority: PRIORITY_LOW }, + callback: () => {} + } + + const runSpy = sinon.stub(queueManager, 'run') + const addSpy = sinon.stub(queueManager._coldCallQueue, 'add') + + queueManager.add(dialRequest) + + expect(runSpy.called).to.eql(true) + expect(addSpy.called).to.eql(true) + expect(addSpy.getCall(0).args[0]).to.eql('QmA') + }) + + it('should abort a cold call if it\'s in the normal queue', (done) => { + const dialRequest = { + peerInfo: { + id: { toB58String: () => 'QmA' }, + isConnected: () => null + }, + protocol: null, + options: { useFSM: true, priority: PRIORITY_LOW }, + callback: (err) => { + expect(runSpy.called).to.eql(false) + expect(hasSpy.called).to.eql(true) + expect(hasSpy.getCall(0).args[0]).to.eql('QmA') + expect(err.code).to.eql('DIAL_ABORTED') + done() + } + } + + const runSpy = sinon.stub(queueManager, 'run') + const hasSpy = sinon.stub(queueManager._queue, 'has').returns(true) + + queueManager.add(dialRequest) + }) + + it('should remove a queue that has reached max blacklist', () => { + const queue = new Queue('QmA', switchA) + queue.blackListed = Infinity + + const abortSpy = sinon.spy(queue, 'abort') + const queueManager = new QueueManager(switchA) + queueManager._queues[queue.id] = queue + + queueManager._clean() + + expect(abortSpy.called).to.eql(true) + expect(queueManager._queues).to.eql({}) + }) + + it('should not remove a queue that is blacklisted below max', () => { + const queue = new Queue('QmA', switchA) + queue.blackListed = Date.now() + 10e3 + + const abortSpy = sinon.spy(queue, 'abort') + const queueManager = new QueueManager(switchA) + queueManager._queues[queue.id] = queue + + queueManager._clean() + + expect(abortSpy.called).to.eql(false) + expect(queueManager._queues).to.eql({ + QmA: queue + }) + }) + + it('should remove a queue that is not running and the peer is not connected', () => { + const disconnectedPeer = { + id: { toB58String: () => 'QmA' }, + isConnected: () => null + } + const queue = new Queue(disconnectedPeer.id.toB58String(), switchA) + + const abortSpy = sinon.spy(queue, 'abort') + const queueManager = new QueueManager(switchA) + queueManager._queues[queue.id] = queue + + queueManager._clean() + + expect(abortSpy.called).to.eql(true) + expect(queueManager._queues).to.eql({}) + }) + + it('should not remove a queue that is not running but the peer is connected', () => { + const connectedPeer = { + id: { toB58String: () => 'QmA' }, + isConnected: () => true + } + const queue = new Queue(connectedPeer.id.toB58String(), switchA) + + switchA._peerBook.put(connectedPeer) + + const abortSpy = sinon.spy(queue, 'abort') + const queueManager = new QueueManager(switchA) + queueManager._queues[queue.id] = queue + + queueManager._clean() + + expect(abortSpy.called).to.eql(false) + expect(queueManager._queues).to.eql({ + QmA: queue + }) + }) + }) +}) diff --git a/test/switch/get-peer-info.spec.js b/test/switch/get-peer-info.spec.js new file mode 100644 index 0000000000..be8de7b774 --- /dev/null +++ b/test/switch/get-peer-info.spec.js @@ -0,0 +1,102 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const PeerBook = require('peer-book') +const PeerInfo = require('peer-info') +const PeerId = require('peer-id') +const MultiAddr = require('multiaddr') +const TestPeerInfos = require('./test-data/ids.json').infos + +const getPeerInfo = require('libp2p-switch/get-peer-info') + +describe('Get peer info', () => { + let peerBook + let peerInfoA + let multiaddrA + let peerIdA + + before((done) => { + peerBook = new PeerBook() + PeerId.createFromJSON(TestPeerInfos[0].id, (err, id) => { + peerIdA = id + peerInfoA = new PeerInfo(peerIdA) + multiaddrA = MultiAddr('/ipfs/QmdWYwTywvXBeLKWthrVNjkq9SafEDn1PbAZdz4xZW7Jd9') + peerInfoA.multiaddrs.add(multiaddrA) + peerBook.put(peerInfoA) + done(err) + }) + }) + + it('should be able get peer info from multiaddr', () => { + let _peerInfo = getPeerInfo(multiaddrA, peerBook) + expect(peerBook.has(_peerInfo)).to.equal(true) + expect(peerInfoA).to.deep.equal(_peerInfo) + }) + + it('should return a new PeerInfo with a multiAddr not in the PeerBook', () => { + let wrongMultiAddr = MultiAddr('/ipfs/QmckZzdVd72h9QUFuJJpQqhsZqGLwjhh81qSvZ9BhB2FQi') + let _peerInfo = getPeerInfo(wrongMultiAddr, peerBook) + expect(PeerInfo.isPeerInfo(_peerInfo)).to.equal(true) + expect(peerBook.has(_peerInfo)).to.equal(false) + }) + + it('should be able get peer info from peer id', () => { + let _peerInfo = getPeerInfo(multiaddrA, peerBook) + expect(peerBook.has(_peerInfo)).to.equal(true) + expect(peerInfoA).to.deep.equal(_peerInfo) + }) + + it('should not be able to get the peer info for a wrong peer id', (done) => { + PeerId.createFromJSON(TestPeerInfos[1].id, (err, id) => { + let func = () => { + getPeerInfo(id, peerBook) + } + + expect(func).to.throw('Couldnt get PeerInfo') + + done(err) + }) + }) + + it('should add a peerInfo to the book', (done) => { + PeerId.createFromJSON(TestPeerInfos[1].id, (err, id) => { + const peerInfo = new PeerInfo(id) + expect(peerBook.has(peerInfo.id.toB58String())).to.eql(false) + + expect(getPeerInfo(peerInfo, peerBook)).to.exist() + expect(peerBook.has(peerInfo.id.toB58String())).to.eql(true) + done(err) + }) + }) + + it('should return the most up to date version of the peer', (done) => { + const ma1 = MultiAddr('/ip4/0.0.0.0/tcp/8080') + const ma2 = MultiAddr('/ip6/::/tcp/8080') + PeerId.createFromJSON(TestPeerInfos[1].id, (err, id) => { + const peerInfo = new PeerInfo(id) + peerInfo.multiaddrs.add(ma1) + expect(getPeerInfo(peerInfo, peerBook)).to.exist() + + const peerInfo2 = new PeerInfo(id) + peerInfo2.multiaddrs.add(ma2) + const returnedPeerInfo = getPeerInfo(peerInfo2, peerBook) + expect(returnedPeerInfo.multiaddrs.toArray()).to.contain.members([ + ma1, ma2 + ]) + done(err) + }) + }) + + it('an invalid peer type should throw an error', () => { + let func = () => { + getPeerInfo('/ip4/127.0.0.1/tcp/1234', peerBook) + } + + expect(func).to.throw('peer type not recognized') + }) +}) diff --git a/test/switch/identify.node.js b/test/switch/identify.node.js new file mode 100644 index 0000000000..25bcde51fe --- /dev/null +++ b/test/switch/identify.node.js @@ -0,0 +1,173 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +chai.use(require('dirty-chai')) +chai.use(require('chai-checkmark')) +const expect = chai.expect +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const multiplex = require('libp2p-mplex') +const pull = require('pull-stream') +const secio = require('libp2p-secio') +const PeerInfo = require('peer-info') +const PeerBook = require('peer-book') +const identify = require('libp2p-identify') +const lp = require('pull-length-prefixed') +const sinon = require('sinon') + +const utils = require('./utils') +const createInfos = utils.createInfos +const Switch = require('libp2p-switch') + +describe('Identify', () => { + let switchA + let switchB + let switchC + + before((done) => createInfos(3, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + const peerC = infos[2] + + peerA.multiaddrs.add('/ip4/127.0.0.1/tcp/9001') + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/9002') + peerC.multiaddrs.add('/ip4/127.0.0.1/tcp/9003') + + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + switchC = new Switch(peerC, new PeerBook()) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + switchC.transport.add('tcp', new TCP()) + + switchA.connection.crypto(secio.tag, secio.encrypt) + switchB.connection.crypto(secio.tag, secio.encrypt) + switchC.connection.crypto(secio.tag, secio.encrypt) + + switchA.connection.addStreamMuxer(multiplex) + switchB.connection.addStreamMuxer(multiplex) + switchC.connection.addStreamMuxer(multiplex) + + switchA.connection.reuse() + switchB.connection.reuse() + switchC.connection.reuse() + + parallel([ + (cb) => switchA.transport.listen('tcp', {}, null, cb), + (cb) => switchB.transport.listen('tcp', {}, null, cb), + (cb) => switchC.transport.listen('tcp', {}, null, cb) + ], done) + })) + + after((done) => { + parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb), + (cb) => switchC.stop(cb) + ], done) + }) + + afterEach(function (done) { + sinon.restore() + // Hangup everything + parallel([ + (cb) => switchA.hangUp(switchB._peerInfo, cb), + (cb) => switchA.hangUp(switchC._peerInfo, cb), + (cb) => switchB.hangUp(switchA._peerInfo, cb), + (cb) => switchB.hangUp(switchC._peerInfo, cb), + (cb) => switchC.hangUp(switchA._peerInfo, cb), + (cb) => switchC.hangUp(switchB._peerInfo, cb) + ], done) + }) + + it('should identify a good peer', (done) => { + switchA.handle('/id-test/1.0.0', (protocol, conn) => pull(conn, conn)) + switchB.dial(switchA._peerInfo, '/id-test/1.0.0', (err, conn) => { + expect(err).to.not.exist() + + let data = Buffer.from('data that can be had') + pull( + pull.values([data]), + conn, + pull.collect((err, values) => { + expect(err).to.not.exist() + expect(values).to.deep.equal([data]) + done() + }) + ) + }) + }) + + it('should get protocols for one another', (done) => { + // We need to reset the PeerInfo objects we use, + // since we share memory we can receive a false positive if not + let peerA = new PeerInfo(switchA._peerInfo.id) + switchA._peerInfo.multiaddrs.toArray().forEach((m) => { + peerA.multiaddrs.add(m) + }) + switchB._peerBook.remove(switchA._peerInfo.id.toB58String()) + switchA._peerBook.remove(switchB._peerInfo.id.toB58String()) + + switchA.handle('/id-test/1.0.0', (protocol, conn) => pull(conn, conn)) + switchB.dial(peerA, '/id-test/1.0.0', (err) => { + expect(err).to.not.exist() + + // Give identify a moment to run + setTimeout(() => { + const peerB = switchA._peerBook.get(switchB._peerInfo.id.toB58String()) + const peerA = switchB._peerBook.get(switchA._peerInfo.id.toB58String()) + expect(Array.from(peerB.protocols)).to.eql([ + multiplex.multicodec, + identify.multicodec + ]) + expect(Array.from(peerA.protocols)).to.eql([ + multiplex.multicodec, + identify.multicodec, + '/id-test/1.0.0' + ]) + + done() + }, 500) + }) + }) + + it('should close connection when identify fails', (done) => { + const stub = sinon.stub(identify, 'listener').callsFake((conn) => { + conn.getObservedAddrs((err, observedAddrs) => { + if (err) { return } + observedAddrs = observedAddrs[0] + + // pretend to be another peer + let publicKey = switchC._peerInfo.id.pubKey.bytes + + const msgSend = identify.message.encode({ + protocolVersion: 'ipfs/0.1.0', + agentVersion: 'na', + publicKey: publicKey, + listenAddrs: switchC._peerInfo.multiaddrs.toArray().map((ma) => ma.buffer), + observedAddr: observedAddrs ? observedAddrs.buffer : Buffer.from('') + }) + + pull( + pull.values([msgSend]), + lp.encode(), + conn + ) + }) + }) + + expect(2).checks(done) + + switchA.handle('/id-test/1.0.0', (protocol, conn) => pull(conn, conn)) + switchB.dialFSM(switchA._peerInfo, '/id-test/1.0.0', (err, connFSM) => { + expect(err).to.not.exist().mark() + connFSM.once('close', () => { + expect(stub.called).to.eql(true).mark() + }) + }) + }) +}) diff --git a/test/switch/limit-dialer.node.js b/test/switch/limit-dialer.node.js new file mode 100644 index 0000000000..bae178ddc7 --- /dev/null +++ b/test/switch/limit-dialer.node.js @@ -0,0 +1,93 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +chai.use(require('dirty-chai')) +chai.use(require('chai-checkmark')) +const expect = chai.expect +const multiaddr = require('multiaddr') +const pull = require('pull-stream') +const setImmediate = require('async/setImmediate') + +const LimitDialer = require('libp2p-switch/limit-dialer') +const utils = require('./utils') + +describe('LimitDialer', () => { + let peers + + before((done) => { + utils.createInfos(5, (err, infos) => { + if (err) { + return done(err) + } + peers = infos + + peers.forEach((peer, i) => { + peer.multiaddrs.add(multiaddr(`/ip4/191.0.0.1/tcp/123${i}`)) + peer.multiaddrs.add(multiaddr(`/ip4/192.168.0.1/tcp/923${i}`)) + peer.multiaddrs.add(multiaddr(`/ip4/193.168.0.99/tcp/923${i}`)) + }) + done() + }) + }) + + it('all failing', (done) => { + const dialer = new LimitDialer(2, 10) + const error = new Error('fail') + // mock transport + const t1 = { + dial (addr, cb) { + setTimeout(() => cb(error), 1) + return {} + } + } + + dialer.dialMany(peers[0].id, t1, peers[0].multiaddrs.toArray(), (err, conn) => { + expect(err).to.exist() + expect(err).to.eql([error, error, error]) + expect(conn).to.not.exist() + done() + }) + }) + + it('two success', (done) => { + const dialer = new LimitDialer(2, 10) + + // mock transport + const t1 = { + dial (addr, cb) { + const as = addr.toString() + if (as.match(/191/)) { + setImmediate(() => cb(new Error('fail'))) + return null + } else if (as.match(/192/)) { + setTimeout(cb, 2) + return { + source: pull.values([1]), + sink: pull.drain() + } + } else if (as.match(/193/)) { + setTimeout(cb, 8) + return { + source: pull.values([2]), + sink: pull.drain() + } + } + } + } + + dialer.dialMany(peers[0].id, t1, peers[0].multiaddrs.toArray(), (err, success) => { + const conn = success.conn + expect(success.multiaddr.toString()).to.equal('/ip4/192.168.0.1/tcp/9230') + expect(err).to.not.exist() + pull( + conn, + pull.collect((err, res) => { + expect(err).to.not.exist() + expect(res).to.be.eql([1]) + done() + }) + ) + }) + }) +}) diff --git a/test/switch/node.js b/test/switch/node.js new file mode 100644 index 0000000000..534f7e0b2e --- /dev/null +++ b/test/switch/node.js @@ -0,0 +1,14 @@ +'use strict' + +require('./connection.node') +require('./dial-fsm.node') +require('./pnet.node') +require('./transports.node') +require('./stream-muxers.node') +require('./secio.node') +require('./swarm-no-muxing.node') +require('./swarm-muxing.node') +require('./circuit-relay.node') +require('./identify.node') +require('./limit-dialer.node') +require('./stats.node') diff --git a/test/switch/pnet.node.js b/test/switch/pnet.node.js new file mode 100644 index 0000000000..e670addb88 --- /dev/null +++ b/test/switch/pnet.node.js @@ -0,0 +1,152 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const multiplex = require('pull-mplex') +const pull = require('pull-stream') +const PeerBook = require('peer-book') +const secio = require('libp2p-secio') +const Protector = require('libp2p-pnet') + +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho +const Switch = require('libp2p-switch') + +const generatePSK = Protector.generate + +const psk = Buffer.alloc(95) +const psk2 = Buffer.alloc(95) +generatePSK(psk) +generatePSK(psk2) + +describe('Private Network', function () { + let switchA + let switchB + let switchC + let switchD + + before((done) => createInfos(4, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + const peerC = infos[2] + const peerD = infos[3] + + peerA.multiaddrs.add('/ip4/127.0.0.1/tcp/9001') + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/9002') + peerC.multiaddrs.add('/ip4/127.0.0.1/tcp/9003') + peerD.multiaddrs.add('/ip4/127.0.0.1/tcp/9004') + + switchA = new Switch(peerA, new PeerBook(), { + protector: new Protector(psk) + }) + switchB = new Switch(peerB, new PeerBook(), { + protector: new Protector(psk) + }) + // alternative way to add the protector + switchC = new Switch(peerC, new PeerBook()) + switchC.protector = new Protector(psk) + // Create a switch on a different private network + switchD = new Switch(peerD, new PeerBook(), { + protector: new Protector(psk2) + }) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + switchC.transport.add('tcp', new TCP()) + switchD.transport.add('tcp', new TCP()) + + switchA.connection.crypto(secio.tag, secio.encrypt) + switchB.connection.crypto(secio.tag, secio.encrypt) + switchC.connection.crypto(secio.tag, secio.encrypt) + switchD.connection.crypto(secio.tag, secio.encrypt) + + switchA.connection.addStreamMuxer(multiplex) + switchB.connection.addStreamMuxer(multiplex) + switchC.connection.addStreamMuxer(multiplex) + switchD.connection.addStreamMuxer(multiplex) + + parallel([ + (cb) => switchA.transport.listen('tcp', {}, null, cb), + (cb) => switchB.transport.listen('tcp', {}, null, cb), + (cb) => switchC.transport.listen('tcp', {}, null, cb), + (cb) => switchD.transport.listen('tcp', {}, null, cb) + ], done) + })) + + after(function (done) { + parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb), + (cb) => switchC.stop(cb), + (cb) => switchD.stop(cb) + ], done) + }) + + it('should handle + dial on protocol', (done) => { + switchB.handle('/abacaxi/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchA.dial(switchB._peerInfo, '/abacaxi/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + tryEcho(conn, done) + }) + }) + + it('should dial to warm conn', (done) => { + switchB.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + expect(Object.keys(switchB.conns).length).to.equal(0) + expect(switchB.connection.getAll()).to.have.length(1) + done() + }) + }) + + it('should dial on protocol, reuseing warmed conn', (done) => { + switchA.handle('/papaia/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchB.dial(switchA._peerInfo, '/papaia/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(Object.keys(switchB.conns).length).to.equal(0) + expect(switchB.connection.getAll()).to.have.length(1) + tryEcho(conn, done) + }) + }) + + it('should enable identify to reuse incomming muxed conn', (done) => { + switchA.connection.reuse() + switchC.connection.reuse() + + switchC.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + setTimeout(() => { + expect(switchC.connection.getAll()).to.have.length(1) + expect(switchA.connection.getAll()).to.have.length(2) + done() + }, 500) + }) + }) + + /** + * This test is being skipped until a related issue with pull-reader overreading can be resolved + * Currently this test will time out instead of returning an error properly. This is the same issue + * in ipfs/interop, https://github.com/ipfs/interop/pull/24/commits/179978996ecaef39e78384091aa9669dcdb94cc0 + */ + it('should fail to talk to a switch on a different private network', function (done) { + switchD.dial(switchA._peerInfo, (err) => { + expect(err).to.exist() + }) + + // A successful connection will return in well under 2 seconds + setTimeout(() => { + done() + }, 2000) + }) +}) diff --git a/test/switch/secio.node.js b/test/switch/secio.node.js new file mode 100644 index 0000000000..7731cef9a9 --- /dev/null +++ b/test/switch/secio.node.js @@ -0,0 +1,116 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const multiplex = require('pull-mplex') +const pull = require('pull-stream') +const secio = require('libp2p-secio') +const PeerBook = require('peer-book') + +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho +const Switch = require('libp2p-switch') + +describe('SECIO', () => { + let switchA + let switchB + let switchC + + before((done) => createInfos(3, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + const peerC = infos[2] + + peerA.multiaddrs.add('/ip4/127.0.0.1/tcp/9001') + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/9002') + peerC.multiaddrs.add('/ip4/127.0.0.1/tcp/9003') + + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + switchC = new Switch(peerC, new PeerBook()) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + switchC.transport.add('tcp', new TCP()) + + switchA.connection.crypto(secio.tag, secio.encrypt) + switchB.connection.crypto(secio.tag, secio.encrypt) + switchC.connection.crypto(secio.tag, secio.encrypt) + + switchA.connection.addStreamMuxer(multiplex) + switchB.connection.addStreamMuxer(multiplex) + switchC.connection.addStreamMuxer(multiplex) + + parallel([ + (cb) => switchA.transport.listen('tcp', {}, null, cb), + (cb) => switchB.transport.listen('tcp', {}, null, cb), + (cb) => switchC.transport.listen('tcp', {}, null, cb) + ], done) + })) + + after(function (done) { + this.timeout(3 * 1000) + parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb), + (cb) => switchC.stop(cb) + ], done) + }) + + it('handle + dial on protocol', (done) => { + switchB.handle('/abacaxi/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchA.dial(switchB._peerInfo, '/abacaxi/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + tryEcho(conn, done) + }) + }) + + it('dial to warm conn', (done) => { + switchB.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + expect(Object.keys(switchB.conns).length).to.equal(0) + expect(switchB.connection.getAll()).to.have.length(1) + done() + }) + }) + + it('dial on protocol, reuse warmed conn', (done) => { + switchA.handle('/papaia/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchB.dial(switchA._peerInfo, '/papaia/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(Object.keys(switchB.conns).length).to.equal(0) + expect(switchB.connection.getAll()).to.have.length(1) + tryEcho(conn, done) + }) + }) + + it('enable identify to reuse incomming muxed conn', (done) => { + switchA.connection.reuse() + switchC.connection.reuse() + + switchC.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + setTimeout(() => { + expect(switchC.connection.getAll()).to.have.length(1) + expect(switchA.connection.getAll()).to.have.length(2) + done() + }, 500) + }) + }) + + it('switch back to plaintext if no arguments passed in', () => { + switchA.connection.crypto() + expect(switchA.crypto.tag).to.eql('/plaintext/1.0.0') + }) +}) diff --git a/test/switch/stats.node.js b/test/switch/stats.node.js new file mode 100644 index 0000000000..1520caadfe --- /dev/null +++ b/test/switch/stats.node.js @@ -0,0 +1,280 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) +const parallel = require('async/parallel') +const each = require('async/each') +const map = require('async/map') +const series = require('async/series') +const TCP = require('libp2p-tcp') +const multiplex = require('libp2p-mplex') +const pull = require('pull-stream') +const secio = require('libp2p-secio') +const PeerBook = require('peer-book') + +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho +const Switch = require('libp2p-switch') + +describe('Stats', () => { + const setup = (cb) => { + createInfos(2, (err, infos) => { + expect(err).to.not.exist() + + const options = { + stats: { + computeThrottleTimeout: 100 + } + } + + const peerA = infos[0] + const peerB = infos[1] + + peerA.multiaddrs.add('/ip4/127.0.0.1/tcp/0') + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/0') + + const switchA = new Switch(peerA, new PeerBook(), options) + const switchB = new Switch(peerB, new PeerBook(), options) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + + switchA.connection.crypto(secio.tag, secio.encrypt) + switchB.connection.crypto(secio.tag, secio.encrypt) + + switchA.connection.addStreamMuxer(multiplex) + switchB.connection.addStreamMuxer(multiplex) + + parallel([ + (cb) => switchA.start(cb), + (cb) => switchB.start(cb) + ], (err) => { + if (err) { + cb(err) + return + } + const echo = (protocol, conn) => pull(conn, conn) + switchB.handle('/echo/1.0.0', echo) + switchA.handle('/echo/1.0.0', echo) + + parallel([ + (cb) => { + switchA.dial(switchB._peerInfo, '/echo/1.0.0', (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, cb) + }) + }, + (cb) => { + switchB.dial(switchA._peerInfo, '/echo/1.0.0', (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, cb) + }) + } + ], (err) => { + if (err) { + cb(err) + return + } + + // wait until stats are processed + let pending = 12 + switchA.stats.on('update', waitForUpdate) + switchB.stats.on('update', waitForUpdate) + + function waitForUpdate () { + if (--pending === 0) { + switchA.stats.removeListener('update', waitForUpdate) + switchB.stats.removeListener('update', waitForUpdate) + cb(null, [switchA, switchB]) + } + } + }) + }) + }) + } + + const teardown = (switches, cb) => { + map(switches, (swtch, cb) => swtch.stop(cb), cb) + } + + it('both nodes have some global stats', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + + switches.forEach((swtch) => { + let snapshot = swtch.stats.global.snapshot + expect(snapshot.dataReceived.toFixed()).to.equal('2210') + expect(snapshot.dataSent.toFixed()).to.equal('2210') + }) + + teardown(switches, done) + }) + }) + + it('both nodes know the transports', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + const expectedTransports = [ + 'tcp' + ] + + switches.forEach( + (swtch) => expect(swtch.stats.transports().sort()).to.deep.equal(expectedTransports)) + teardown(switches, done) + }) + }) + + it('both nodes know the protocols', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + const expectedProtocols = [ + '/echo/1.0.0', + '/mplex/6.7.0', + '/secio/1.0.0' + ] + + switches.forEach((swtch) => { + expect(swtch.stats.protocols().sort()).to.deep.equal(expectedProtocols) + }) + + teardown(switches, done) + }) + }) + + it('both nodes know about each other', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + switches.forEach( + (swtch, index) => { + const otherSwitch = selectOther(switches, index) + expect(swtch.stats.peers().sort()).to.deep.equal([otherSwitch._peerInfo.id.toB58String()]) + }) + teardown(switches, done) + }) + }) + + it('both have transport-specific stats', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + switches.forEach((swtch) => { + let snapshot = swtch.stats.forTransport('tcp').snapshot + expect(snapshot.dataReceived.toFixed()).to.equal('2210') + expect(snapshot.dataSent.toFixed()).to.equal('2210') + }) + teardown(switches, done) + }) + }) + + it('both have protocol-specific stats', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + switches.forEach((swtch) => { + let snapshot = swtch.stats.forProtocol('/echo/1.0.0').snapshot + expect(snapshot.dataReceived.toFixed()).to.equal('8') + expect(snapshot.dataSent.toFixed()).to.equal('8') + }) + teardown(switches, done) + }) + }) + + it('both have peer-specific stats', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + switches.forEach((swtch, index) => { + const other = selectOther(switches, index) + let snapshot = swtch.stats.forPeer(other._peerInfo.id.toB58String()).snapshot + expect(snapshot.dataReceived.toFixed()).to.equal('2210') + expect(snapshot.dataSent.toFixed()).to.equal('2210') + }) + teardown(switches, done) + }) + }) + + it('both have moving average stats for peer', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + switches.forEach((swtch, index) => { + const other = selectOther(switches, index) + let ma = swtch.stats.forPeer(other._peerInfo.id.toB58String()).movingAverages + const intervals = [60000, 300000, 900000] + intervals.forEach((interval) => { + const average = ma.dataReceived[interval].movingAverage() + expect(average).to.be.above(0).below(100) + }) + }) + teardown(switches, done) + }) + }) + + it('retains peer after disconnect', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + let index = -1 + each(switches, (swtch, cb) => { + swtch.once('peer-mux-closed', () => cb()) + index++ + swtch.hangUp(selectOther(switches, index)._peerInfo, (err) => { + expect(err).to.not.exist() + }) + }, + (err) => { + expect(err).to.not.exist() + switches.forEach((swtch, index) => { + const other = selectOther(switches, index) + const snapshot = swtch.stats.forPeer(other._peerInfo.id.toB58String()).snapshot + expect(snapshot.dataReceived.toFixed()).to.equal('2210') + expect(snapshot.dataSent.toFixed()).to.equal('2210') + }) + teardown(switches, done) + }) + }) + }) + + it('retains peer after reconnect', (done) => { + setup((err, switches) => { + expect(err).to.not.exist() + series([ + (cb) => { + let index = -1 + each(switches, (swtch, cb) => { + swtch.once('peer-mux-closed', () => cb()) + index++ + swtch.hangUp(selectOther(switches, index)._peerInfo, (err) => { + expect(err).to.not.exist() + }) + }, cb) + }, + (cb) => { + let index = -1 + each(switches, (swtch, cb) => { + index++ + const other = selectOther(switches, index) + swtch.dial(other._peerInfo, '/echo/1.0.0', (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, cb) + }) + }, cb) + }, + (cb) => setTimeout(cb, 1000), + (cb) => { + switches.forEach((swtch, index) => { + const other = selectOther(switches, index) + const snapshot = swtch.stats.forPeer(other._peerInfo.id.toB58String()).snapshot + expect(snapshot.dataReceived.toFixed()).to.equal('4420') + expect(snapshot.dataSent.toFixed()).to.equal('4420') + }) + teardown(switches, cb) + } + ], done) + }) + }) +}) + +function selectOther (array, index) { + const useIndex = (index + 1) % array.length + return array[useIndex] +} diff --git a/test/switch/stream-muxers.node.js b/test/switch/stream-muxers.node.js new file mode 100644 index 0000000000..48330b2e68 --- /dev/null +++ b/test/switch/stream-muxers.node.js @@ -0,0 +1,155 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 8] */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const multiplex = require('libp2p-mplex') +const pullMplex = require('pull-mplex') +const spdy = require('libp2p-spdy') +const pull = require('pull-stream') +const PeerBook = require('peer-book') +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho + +const Switch = require('libp2p-switch') + +describe('Stream Multiplexing', () => { + [ + multiplex, + pullMplex, + spdy + ].forEach((sm) => describe(sm.multicodec, () => { + let switchA + let switchB + let switchC + + before((done) => createInfos(3, (err, peerInfos) => { + expect(err).to.not.exist() + function maGen (port) { return `/ip4/127.0.0.1/tcp/${port}` } + + const peerA = peerInfos[0] + const peerB = peerInfos[1] + const peerC = peerInfos[2] + + peerA.multiaddrs.add(maGen(9001)) + peerB.multiaddrs.add(maGen(9002)) + peerC.multiaddrs.add(maGen(9003)) + + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + switchC = new Switch(peerC, new PeerBook()) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + switchC.transport.add('tcp', new TCP()) + + parallel([ + (cb) => switchA.transport.listen('tcp', {}, null, cb), + (cb) => switchB.transport.listen('tcp', {}, null, cb), + (cb) => switchC.transport.listen('tcp', {}, null, cb) + ], done) + })) + + after((done) => parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb) + ], done)) + + it('switch.connection.addStreamMuxer', (done) => { + switchA.connection.addStreamMuxer(sm) + switchB.connection.addStreamMuxer(sm) + switchC.connection.addStreamMuxer(sm) + done() + }) + + it('handle + dial on protocol', (done) => { + switchB.handle('/abacaxi/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchA.dial(switchB._peerInfo, '/abacaxi/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + + tryEcho(conn, done) + }) + }) + + it('dial to warm conn', (done) => { + switchB.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + + expect(Object.keys(switchB.conns).length).to.equal(0) + expect(switchB.connection.getAll()).to.have.length(1) + done() + }) + }) + + it('dial on protocol, reuse warmed conn', (done) => { + switchA.handle('/papaia/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchB.dial(switchA._peerInfo, '/papaia/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(Object.keys(switchB.conns).length).to.equal(0) + expect(switchB.connection.getAll()).to.have.length(1) + + tryEcho(conn, done) + }) + }) + + it('enable identify to reuse incomming muxed conn', (done) => { + switchA.connection.reuse() + switchC.connection.reuse() + + switchC.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + setTimeout(() => { + expect(switchC.connection.getAll()).to.have.length(1) + expect(switchA.connection.getAll()).to.have.length(2) + done() + }, 500) + }) + }) + + it('with Identify enabled, do getPeerInfo', (done) => { + switchA.handle('/banana/1.0.0', (protocol, conn) => { + conn.getPeerInfo((err, pi) => { + expect(err).to.not.exist() + expect(switchC._peerInfo.id.toB58String()).to.equal(pi.id.toB58String()) + }) + + pull(conn, conn) + }) + + switchC.dial(switchA._peerInfo, '/banana/1.0.0', (err, conn) => { + expect(err).to.not.exist() + setTimeout(() => { + expect(switchC.connection.getAll()).to.have.length(1) + expect(switchA.connection.getAll()).to.have.length(2) + + conn.getPeerInfo((err, pi) => { + expect(err).to.not.exist() + expect(switchA._peerInfo.id.toB58String()).to.equal(pi.id.toB58String()) + tryEcho(conn, done) + }) + }, 500) + }) + }) + + it('closing one side cleans out in the other', (done) => { + switchC.stop((err) => { + expect(err).to.not.exist() + + setTimeout(() => { + expect(switchA.connection.getAll()).to.have.length(1) + done() + }, 500) + }) + }) + })) +}) diff --git a/test/switch/swarm-muxing+webrtc-star.browser.js b/test/switch/swarm-muxing+webrtc-star.browser.js new file mode 100644 index 0000000000..b54b6e9ff5 --- /dev/null +++ b/test/switch/swarm-muxing+webrtc-star.browser.js @@ -0,0 +1,145 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const peerId = require('peer-id') +const PeerInfo = require('peer-info') +const WebRTCStar = require('libp2p-webrtc-star') +const spdy = require('libp2p-spdy') +const parallel = require('async/parallel') +const series = require('async/series') +const pull = require('pull-stream') +const PeerBook = require('peer-book') +const tryEcho = require('./utils').tryEcho + +const Switch = require('libp2p-switch') + +describe('Switch (webrtc-star)', () => { + let switch1 + let peer1 + let wstar1 + + let switch2 + let peer2 + let wstar2 + + before((done) => series([ + (cb) => peerId.create((err, id1) => { + expect(err).to.not.exist() + peer1 = new PeerInfo(id1) + const ma1 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' + + id1.toB58String() + peer1.multiaddrs.add(ma1) + cb() + }), + (cb) => peerId.create((err, id2) => { + expect(err).to.not.exist() + peer2 = new PeerInfo(id2) + const ma2 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' + + id2.toB58String() + peer2.multiaddrs.add(ma2) + cb() + }) + ], (err) => { + expect(err).to.not.exist() + + switch1 = new Switch(peer1, new PeerBook()) + switch2 = new Switch(peer2, new PeerBook()) + done() + })) + + it('add WebRTCStar transport to switch 1', () => { + wstar1 = new WebRTCStar() + switch1.transport.add('wstar', wstar1) + expect(Object.keys(switch1.transports).length).to.equal(1) + }) + + it('add WebRTCStar transport to switch 2', () => { + wstar2 = new WebRTCStar() + switch2.transport.add('wstar', wstar2) + expect(Object.keys(switch2.transports).length).to.equal(1) + }) + + it('listen on switch 1', (done) => { + switch1.start(done) + }) + + it('listen on switch 2', (done) => { + switch2.start(done) + }) + + it('add spdy', () => { + switch1.connection.addStreamMuxer(spdy) + switch1.connection.reuse() + switch2.connection.addStreamMuxer(spdy) + switch2.connection.reuse() + }) + + it('handle proto', () => { + switch2.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn)) + }) + + it('dial on proto', (done) => { + switch1.dial(peer2, '/echo/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switch1.connection.getAll()).to.have.length(1) + + tryEcho(conn, () => { + expect(switch2.connection.getAll()).to.have.length(1) + done() + }) + }) + }) + + it('create a third node and check that discovery works', function (done) { + this.timeout(20 * 1000) + + let counter = 0 + + let switch3 + + function check () { + if (++counter === 4) { + const s1n = switch1.connection.getAll() + const s2n = switch2.connection.getAll() + const s3n = switch3.connection.getAll() + expect(s1n).to.have.length(2) + expect(s2n).to.have.length(2) + expect(s3n).to.have.length(2) + switch3.stop(done) + } + if (counter === 3) { + setTimeout(check, 2000) + } + } + + wstar1.discovery.on('peer', (peerInfo) => switch1.dial(peerInfo, check)) + wstar2.discovery.on('peer', (peerInfo) => switch2.dial(peerInfo, check)) + + peerId.create((err, id3) => { + expect(err).to.not.exist() + + const peer3 = new PeerInfo(id3) + const mh3 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' + id3.toB58String() + peer3.multiaddrs.add(mh3) + + switch3 = new Switch(peer3, new PeerBook()) + const wstar3 = new WebRTCStar() + switch3.transport.add('wstar', wstar3) + switch3.connection.addStreamMuxer(spdy) + switch3.connection.reuse() + switch3.start(check) + }) + }) + + it('stop', (done) => { + parallel([ + (cb) => switch1.stop(cb), + (cb) => switch2.stop(cb) + ], done) + }) +}) diff --git a/test/switch/swarm-muxing+websockets.browser.js b/test/switch/swarm-muxing+websockets.browser.js new file mode 100644 index 0000000000..c14adc03f7 --- /dev/null +++ b/test/switch/swarm-muxing+websockets.browser.js @@ -0,0 +1,74 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 5] */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const PeerId = require('peer-id') +const PeerInfo = require('peer-info') +const WebSockets = require('libp2p-websockets') +const mplex = require('pull-mplex') +const spdy = require('libp2p-spdy') +const PeerBook = require('peer-book') +const tryEcho = require('./utils').tryEcho + +const Switch = require('libp2p-switch') + +describe('Switch (WebSockets)', () => { + [ + mplex, + spdy + ].forEach((muxer) => { + describe(muxer.multicodec, () => { + let sw + let peerDst + + before((done) => { + PeerInfo.create((err, peerSrc) => { + expect(err).to.not.exist() + sw = new Switch(peerSrc, new PeerBook()) + done() + }) + }) + + after(done => { + sw.stop(done) + }) + + it(`add muxer (${muxer.multicodec})`, () => { + sw.connection.addStreamMuxer(muxer) + sw.connection.reuse() + }) + + it('add ws', () => { + sw.transport.add('ws', new WebSockets()) + expect(Object.keys(sw.transports).length).to.equal(1) + }) + + it('create Dst peer info', (done) => { + PeerId.createFromJSON(require('./test-data/id-2.json'), (err, id) => { + expect(err).to.not.exist() + + peerDst = new PeerInfo(id) + const ma = '/ip4/127.0.0.1/tcp/15347/ws' + peerDst.multiaddrs.add(ma) + done() + }) + }) + + it('dial to warm a conn', (done) => { + sw.dial(peerDst, done) + }) + + it('dial on protocol, use warmed conn', (done) => { + sw.dial(peerDst, '/echo/1.0.0', (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, done) + }) + }) + }) + }) +}) diff --git a/test/switch/swarm-muxing.node.js b/test/switch/swarm-muxing.node.js new file mode 100644 index 0000000000..32b282c6d8 --- /dev/null +++ b/test/switch/swarm-muxing.node.js @@ -0,0 +1,248 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 5] */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const WebSockets = require('libp2p-websockets') +const mplex = require('libp2p-mplex') +const pMplex = require('pull-mplex') +const spdy = require('libp2p-spdy') +const pull = require('pull-stream') +const PeerBook = require('peer-book') + +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho +const Switch = require('libp2p-switch') + +describe('Switch (everything all together)', () => { + [pMplex, spdy, mplex].forEach(muxer => { + describe(muxer.multicodec, () => { + let switchA // tcp + let switchB // tcp+ws + let switchC // tcp+ws + let switchD // ws + let switchE // ws + + before((done) => createInfos(5, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + const peerC = infos[2] + const peerD = infos[3] + const peerE = infos[4] + + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + switchC = new Switch(peerC, new PeerBook()) + switchD = new Switch(peerD, new PeerBook()) + switchE = new Switch(peerE, new PeerBook()) + + done() + })) + + after(function (done) { + parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb), + (cb) => switchD.stop(cb), + (cb) => switchE.stop(cb) + ], done) + }) + + it('add tcp', (done) => { + switchA._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10100') + switchB._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10200') + switchC._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10300') + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + switchC.transport.add('tcp', new TCP()) + + parallel([ + (cb) => switchA.transport.listen('tcp', {}, null, cb), + (cb) => switchB.transport.listen('tcp', {}, null, cb) + ], done) + }) + + it('add websockets', (done) => { + switchB._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/9012/ws') + switchC._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/9022/ws') + switchD._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/9032/ws') + switchE._peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/9042/ws') + + switchB.transport.add('ws', new WebSockets()) + switchC.transport.add('ws', new WebSockets()) + switchD.transport.add('ws', new WebSockets()) + switchE.transport.add('ws', new WebSockets()) + + parallel([ + (cb) => switchB.transport.listen('ws', {}, null, cb), + (cb) => switchD.transport.listen('ws', {}, null, cb), + (cb) => switchE.transport.listen('ws', {}, null, cb) + ], done) + }) + + it('listen automatically', (done) => { + switchC.start(done) + }) + + it('add spdy and enable identify', () => { + switchA.connection.addStreamMuxer(muxer) + switchB.connection.addStreamMuxer(muxer) + switchC.connection.addStreamMuxer(muxer) + switchD.connection.addStreamMuxer(muxer) + switchE.connection.addStreamMuxer(muxer) + + switchA.connection.reuse() + switchB.connection.reuse() + switchC.connection.reuse() + switchD.connection.reuse() + switchE.connection.reuse() + }) + + it('warm up from A to B on tcp to tcp+ws', function (done) { + this.timeout(10 * 1000) + parallel([ + (cb) => switchB.once('peer-mux-established', (pi) => { + expect(pi.id.toB58String()).to.equal(switchA._peerInfo.id.toB58String()) + cb() + }), + (cb) => switchA.once('peer-mux-established', (pi) => { + expect(pi.id.toB58String()).to.equal(switchB._peerInfo.id.toB58String()) + cb() + }), + (cb) => switchA.dial(switchB._peerInfo, (err) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + cb() + }) + ], done) + }) + + it('warm up a warmed up, from B to A', (done) => { + switchB.dial(switchA._peerInfo, (err) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + done() + }) + }) + + it('dial from tcp to tcp+ws, on protocol', (done) => { + switchB.handle('/anona/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchA.dial(switchB._peerInfo, '/anona/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + tryEcho(conn, done) + }) + }) + + it('dial from ws to ws no proto', (done) => { + switchD.dial(switchE._peerInfo, (err) => { + expect(err).to.not.exist() + expect(switchD.connection.getAll()).to.have.length(1) + done() + }) + }) + + it('dial from ws to ws', (done) => { + switchE.handle('/abacaxi/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchD.dial(switchE._peerInfo, '/abacaxi/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switchD.connection.getAll()).to.have.length(1) + + tryEcho(conn, () => setTimeout(() => { + expect(switchE.connection.getAll()).to.have.length(1) + done() + }, 1000)) + }) + }) + + it('dial from tcp to tcp+ws', (done) => { + switchB.handle('/grapes/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchA.dial(switchB._peerInfo, '/grapes/1.0.0', (err, conn) => { + expect(err).to.not.exist() + expect(switchA.connection.getAll()).to.have.length(1) + + tryEcho(conn, done) + }) + }) + + it('dial from tcp+ws to tcp+ws', (done) => { + let i = 0 + + function check (err) { + expect(err).to.not.exist() + if (++i === 3) { done() } + } + + switchC.handle('/mamao/1.0.0', (protocol, conn) => { + conn.getPeerInfo((err, peerInfo) => { + expect(err).to.not.exist() + expect(peerInfo).to.exist() + check() + }) + + pull(conn, conn) + }) + + switchA.dial(switchC._peerInfo, '/mamao/1.0.0', (err, conn) => { + expect(err).to.not.exist() + + conn.getPeerInfo((err, peerInfo) => { + expect(err).to.not.exist() + expect(peerInfo).to.exist() + check() + }) + + expect(switchA.connection.getAll()).to.have.length(2) + expect(switchC._peerInfo.isConnected).to.exist() + expect(switchA._peerInfo.isConnected).to.exist() + + tryEcho(conn, check) + }) + }) + + it('hangUp', (done) => { + let count = 0 + const ready = () => ++count === 3 ? done() : null + + switchB.once('peer-mux-closed', (peerInfo) => { + expect(switchB.connection.getAll()).to.have.length(0) + expect(switchB._peerInfo.isConnected()).to.not.exist() + ready() + }) + + switchA.once('peer-mux-closed', (peerInfo) => { + expect(switchA.connection.getAll()).to.have.length(1) + expect(switchA._peerInfo.isConnected()).to.not.exist() + ready() + }) + + switchA.hangUp(switchB._peerInfo, (err) => { + expect(err).to.not.exist() + ready() + }) + }) + + it('close a muxer emits event', function (done) { + this.timeout(3 * 1000) + + parallel([ + (cb) => switchA.once('peer-mux-closed', (peerInfo) => cb()), + (cb) => switchC.stop(cb) + ], done) + }) + }) + }) +}) diff --git a/test/switch/swarm-no-muxing.node.js b/test/switch/swarm-no-muxing.node.js new file mode 100644 index 0000000000..d55bedd532 --- /dev/null +++ b/test/switch/swarm-no-muxing.node.js @@ -0,0 +1,90 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const pull = require('pull-stream') +const PeerBook = require('peer-book') + +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho +const Switch = require('libp2p-switch') + +describe('Switch (no Stream Multiplexing)', () => { + let switchA + let switchB + + before((done) => createInfos(2, (err, infos) => { + expect(err).to.not.exist() + + const peerA = infos[0] + const peerB = infos[1] + + peerA.multiaddrs.add('/ip4/127.0.0.1/tcp/9001') + peerB.multiaddrs.add('/ip4/127.0.0.1/tcp/9002/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC') + + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + + switchA.transport.add('tcp', new TCP()) + switchB.transport.add('tcp', new TCP()) + + parallel([ + (cb) => switchA.transport.listen('tcp', {}, null, cb), + (cb) => switchB.transport.listen('tcp', {}, null, cb) + ], done) + })) + + after((done) => parallel([ + (cb) => switchA.stop(cb), + (cb) => switchB.stop(cb) + ], done)) + + it('handle a protocol', (done) => { + switchB.handle('/bananas/1.0.0', (protocol, conn) => pull(conn, conn)) + expect(switchB.protocols).to.have.all.keys('/bananas/1.0.0') + done() + }) + + it('dial on protocol', (done) => { + switchB.handle('/pineapple/1.0.0', (protocol, conn) => pull(conn, conn)) + + switchA.dial(switchB._peerInfo, '/pineapple/1.0.0', (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, done) + }) + }) + + it('dial on protocol (returned conn)', (done) => { + switchB.handle('/apples/1.0.0', (protocol, conn) => pull(conn, conn)) + + const conn = switchA.dial(switchB._peerInfo, '/apples/1.0.0', (err) => { + expect(err).to.not.exist() + }) + + tryEcho(conn, done) + }) + + it('dial to warm a conn', (done) => { + switchA.dial(switchB._peerInfo, done) + }) + + it('dial on protocol, reuse warmed conn', (done) => { + switchA.dial(switchB._peerInfo, '/bananas/1.0.0', (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, done) + }) + }) + + it('unhandle', () => { + const proto = '/bananas/1.0.0' + switchA.unhandle(proto) + expect(switchA.protocols[proto]).to.not.exist() + }) +}) diff --git a/test/switch/switch.spec.js b/test/switch/switch.spec.js new file mode 100644 index 0000000000..e3387df608 --- /dev/null +++ b/test/switch/switch.spec.js @@ -0,0 +1,37 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const Switch = require('libp2p-switch') + +describe('Switch', () => { + describe('.availableTransports', () => { + it('should always sort circuit last', () => { + const switchA = new Switch({}, {}) + const transport = { + filter: (addrs) => addrs + } + const mockPeerInfo = { + multiaddrs: { + toArray: () => ['a', 'b', 'c'] + } + } + + switchA.transports = { + Circuit: transport, + TCP: transport, + WebSocketStar: transport + } + + expect(switchA.availableTransports(mockPeerInfo)).to.eql([ + 'TCP', + 'WebSocketStar', + 'Circuit' + ]) + }) + }) +}) diff --git a/test/switch/t-webrtc-star.browser.js b/test/switch/t-webrtc-star.browser.js new file mode 100644 index 0000000000..c01fb8fcdb --- /dev/null +++ b/test/switch/t-webrtc-star.browser.js @@ -0,0 +1,83 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) +const PeerId = require('peer-id') +const PeerInfo = require('peer-info') +const WebRTCStar = require('libp2p-webrtc-star') +const parallel = require('async/parallel') +const pull = require('pull-stream') +const PeerBook = require('peer-book') +const tryEcho = require('./utils').tryEcho + +const Switch = require('libp2p-switch') + +describe('transport - webrtc-star', () => { + let switch1 + let switch2 + + before(() => { + const id1 = PeerId + .createFromB58String('QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooA') + const peer1 = new PeerInfo(id1) + + const ma1 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooA' + peer1.multiaddrs.add(ma1) + + const id2 = PeerId + .createFromB58String('QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooB') + const peer2 = new PeerInfo(id2) + const ma2 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooB' + peer2.multiaddrs.add(ma2) + + switch1 = new Switch(peer1, new PeerBook()) + switch2 = new Switch(peer2, new PeerBook()) + }) + + it('add WebRTCStar transport to switch 1', () => { + switch1.transport.add('wstar', new WebRTCStar()) + expect(Object.keys(switch1.transports).length).to.equal(1) + }) + + it('add WebRTCStar transport to switch 2', () => { + switch2.transport.add('wstar', new WebRTCStar()) + expect(Object.keys(switch2.transports).length).to.equal(1) + }) + + it('listen on switch 1', (done) => { + switch1.transport.listen('wstar', {}, (conn) => pull(conn, conn), done) + }) + + it('listen on switch 2', (done) => { + switch2.transport.listen('wstar', {}, (conn) => pull(conn, conn), done) + }) + + it('dial', (done) => { + switch1.transport.dial('wstar', switch2._peerInfo, (err, conn) => { + expect(err).to.not.exist() + + tryEcho(conn, done) + }) + }) + it('dial offline / non-existent node', (done) => { + const peer2 = switch2._peerInfo + peer2.multiaddrs.clear() + peer2.multiaddrs.add('/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/ABCD') + + switch1.transport.dial('wstar', peer2, (err, conn) => { + expect(err).to.exist() + expect(conn).to.not.exist() + done() + }) + }) + + it('close', (done) => { + parallel([ + (cb) => switch1.transport.close('wstar', cb), + (cb) => switch2.transport.close('wstar', cb) + ], done) + }) +}) diff --git a/test/switch/test-data/id-1.json b/test/switch/test-data/id-1.json new file mode 100644 index 0000000000..504e71ac92 --- /dev/null +++ b/test/switch/test-data/id-1.json @@ -0,0 +1,5 @@ +{ + "id": "QmYmfUS4A3E64BzU8DsCmCWpPhcXWU2KTKNRGtdtN4oCgU", + "privKey": "CAASqAkwggSkAgEAAoIBAQCYtGLh+ow9WEJMn50voPGa6MsqSgJx8pNXGtk5kMSktWxfYHrejLZJjN0+br2CwpFMtf9JW6dAIpxb3qViBCFXjzEK8JuYaXM2sHC6sapyCxeZUbZJtGAXNWQW3qV7m8s8cJTOu2s1euT/G6uf/mIVFIzCkQDx+Ejh5Aie+BTAEf1WbLmcoDDxVESe22gpTxtMG8WTocMV34BxKn8d8vhcZZsi8LLkjg172QwQr3Q68jKgdja3K1YYm6fnso6H3+H06IHgPFAvVhycBbmlyR3bL/hFBl6+ElwBxeIrlM/oAY93KCs622SLYWFHb+J2q7WofSbUSscp3gWj7c8KJqHvAgMBAAECggEBAJZi4BcpBj/L0c9gSg8D86zZomvNY0cQ3GYmPNPibKbBPS9Y9uiBr2wT3DeGHADQ2QOxIO7/4mDZNR+Mz1cONj/i9yuM9c9N2nd7oClcmz2hCualgF5p01BH9oBHWLW5IpgtT3+hN939X9SVTZpNjg6wpEdhQosKN8yvJIZaTyUvh/ZMRIJvbnbLg13gIF7Lpyn1rtFovQg0dET0C8zhTCDPacJIOLp8BIBMknPfOl0SrvOMZjufzVZLvbt0YraXhLK8EWe87ffTMoBlIktWpEKdPBOCuFf4E4WRXJ78tcbvNtx3f5zGi+ZVbKcLA1axu+OqbjHCG6yrlywcVBoTuxECgYEA56yDBaM0VFD1CqsqwYIWmAyYBjV7dkM+ogMb+mfQn+ja6QSt+U/APXB3dP+EDvysh5AZR0wpUrmz14xC1yB1/XAKIfMLQZB8DdUkuj5UcsKjkzLJkIFYGOXIutU7IHTma7s/0fLxwp8SvkEL+6nHuZskf77yjDAvWLZeSD/CYWsCgYEAqL0mKeyyhBBFvNJyE3CyyhDfzgf+NrvrNJcx73nAzLDE44BPc/3lHYn2AJJhasNnjJfRiFzW90PNgCjZLLXqeHkX4xixoibvRtb31WHR2UyxXe/KQZwBy11mPzStnI4Y83C2A8OXsx4xAPq69nX9foSFD6cuLkWUGeb8f7Jxbo0CgYB25mfcJdW+jEom7pAj/kLgSF5hmWNC3+IuPhBG5K8C0vw+6ULsmEyee7EjX9wD4RQfAwqmN+VhaqNtNbQ8OpGzv6PDprwZKzEv3DtcRo8K0vAmpMMkIe334T6y/Kq6zqRPmCt58gi4DPIOqM2gnJM/o+sIkRRkdHpoOjiLNgXp/wKBgQCNrGpLjwl/am4zEHppKhljIPHX+cwORo8/06ZAi/g9pDlbThLnr4fb2kaqyjxyuGfLmnh5xoFSkCINdb6KFJ8t0XYl3UjffVMvJjRle0EG8qaE2Vz24zZ6egvsC52ssX3vf3XDCUjoQfQg/2NUpVJWFIvnzZUvkom7ib38tWUZzQKBgDe0+OqdJEIdajkwCMEYbmZDYqkbw4pgmwSqCwK7HeCi8dvACW5OCCutnN0L57eEltyWy0XP2XmRlfsD0atkKBq3KgNfSawx6/t/K3OtZa8VAtg2M0PbCZljW/8Bz6xlxiyPXFTRgr9zr4yM1homMmPA39hURmXNNedXUh3IMkH7", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYtGLh+ow9WEJMn50voPGa6MsqSgJx8pNXGtk5kMSktWxfYHrejLZJjN0+br2CwpFMtf9JW6dAIpxb3qViBCFXjzEK8JuYaXM2sHC6sapyCxeZUbZJtGAXNWQW3qV7m8s8cJTOu2s1euT/G6uf/mIVFIzCkQDx+Ejh5Aie+BTAEf1WbLmcoDDxVESe22gpTxtMG8WTocMV34BxKn8d8vhcZZsi8LLkjg172QwQr3Q68jKgdja3K1YYm6fnso6H3+H06IHgPFAvVhycBbmlyR3bL/hFBl6+ElwBxeIrlM/oAY93KCs622SLYWFHb+J2q7WofSbUSscp3gWj7c8KJqHvAgMBAAE=" +} diff --git a/test/switch/test-data/id-2.json b/test/switch/test-data/id-2.json new file mode 100644 index 0000000000..167daf01a5 --- /dev/null +++ b/test/switch/test-data/id-2.json @@ -0,0 +1,5 @@ +{ + "id": "QmQAbW9j3wQ8JDFmg8JRid82EpZabuCngVDmhqzCmJwqt6", + "privKey": "CAASpgkwggSiAgEAAoIBAQCAQjiCzMF+PQaDUuNa7avUsj2xnNTQcUrs4yHz/L+JI/AY2ij0iXsBSE0chK1KtBu24gZzWs3/BDyNl28E0Sd41QpK6oTVMHjUfLovO+h7G78bqpI83vk5CEOKt29VihQs282fivbQb5ALYwzBIW2lsIoWwrQq1btsNA5NXJ43OAcPZ9SybBUg49f5gWf/kmh/J6e1rvwyVjQc7cmmpzcQUc+XNL7db6T3ArokXZMyBK6oQCOaJc1bqwgHwYSI3parjds9k8Z6fXA2ub3Va//1EgjQ50lRZH03PGYS42HR1QSSz1eLjMmdrbJrZZj7IbXgqAO6gT6wlGLr5xMQudabAgMBAAECggEAQ9NBESJ4fGqHJDFUG8St5pevelqGTAhtZ+IhFWamXz6K/Il5uP9u9dmnNZqQDX47XbYfVSdC4kX6Q6I+SlzUs9htTfrA7gBpFW00BEB5C4k7wcSs+tWrE9bj6NpiXOjdDG/cSC9zn/wvP2ZM22DzG/jEvY6POku2hlzs50pAPNB7bBaKysA/e52J0Tu/Wf/+sZyp2MiYQJmIkfbYeDF2rqm5y04S6Z31O3SMQIETNcBK8T+L2jwx+Q0msB8toam7hRf1KjxD0yZe+Vff9tPfwjgEoWF+O27g3+rjDq/QqUfzOPMgvAFgELBMpv6CCM8/3l9gUu+7itBxDq65sDCoCQKBgQC6FTLTQA3ux3WV0/7MKXJIHgYZ4b8lIbiiWuO/6t2ZnwvLfTbiU5br/8bcRPL5ygFuIdzkx8VHcbkOmld/VE7qaRZoJb94JVvC6N+5MQxr+pzbWQSNcE+cKJgy1RADea8nad698ifls/39kZGCc6Srt2TqxTBuoZ3c9jEMs3N2pwKBgQCwcxNSw7Wkq302lKc/7QdtfegrwlLjRClLYaW9ESQeErayRY8pxLgl/XKap1HPyc0aQ+78W6w+DAxvcToGBsLak0ujJjzP7b8G6fo+cexuIr8NiGL4LVzpZfQjkfQU4DDwsOdedeKzGelIdstMMtAZDFG9eNPe99XeJBnYfIDS7QKBgH8xFjiHQ/6+n4T2DueGPPNGcm0mfPzoe8ed0KbR5v6mU+2XfPheon5VqpvNFTff9/JLey11z0byWMe+f6gs/HQFuKcfhiydfIdRnfp7qD32Y1kbE52J8yCOLtowAG4fsrWCDBpRdyvvR+EWqxs76IbnKDfA6UX1em4aaZSA5J9pAoGAE8aB5ue6Rt9VZDWa3QZCq9nNmIHp6kCsZB9ohN0T8C7mvOog1myOuutB2eVgvOoAC66LbUsU7ctJ5X+KIjzFv9t8Qae6bw9VNoAopLD974YDZY/gj7H91Maxav8jnOdXdNJOy/5oTuxbgdyWgk67leMUkiiljjq2hHQFVYb2pS0CgYBam0ZJ5Trds1LijE2eoYPyiJdhWEsHYFDzoV17cyjhbSrmlWJBNKQfw6q6UtnxSNFMvsPOZv53d3B8iIDnZ/UHFvw1et+yQk/QrxTfXurqn8lJcMCfKzm3ORKibgJPMmtcPbLoxuEKXMXx18iwoCsMnapijJ0Qj5HofluiupSfxg==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCAQjiCzMF+PQaDUuNa7avUsj2xnNTQcUrs4yHz/L+JI/AY2ij0iXsBSE0chK1KtBu24gZzWs3/BDyNl28E0Sd41QpK6oTVMHjUfLovO+h7G78bqpI83vk5CEOKt29VihQs282fivbQb5ALYwzBIW2lsIoWwrQq1btsNA5NXJ43OAcPZ9SybBUg49f5gWf/kmh/J6e1rvwyVjQc7cmmpzcQUc+XNL7db6T3ArokXZMyBK6oQCOaJc1bqwgHwYSI3parjds9k8Z6fXA2ub3Va//1EgjQ50lRZH03PGYS42HR1QSSz1eLjMmdrbJrZZj7IbXgqAO6gT6wlGLr5xMQudabAgMBAAE=" +} diff --git a/test/switch/test-data/ids.json b/test/switch/test-data/ids.json new file mode 100644 index 0000000000..db62a09658 --- /dev/null +++ b/test/switch/test-data/ids.json @@ -0,0 +1,904 @@ +{ + "infos": [ + { + "id": { + "id": "QmdWYwTywvXBeLKWthrVNjkq9SafEDn1PbAZdz4xZW7Jd9", + "privKey": "CAASpgkwggSiAgEAAoIBAQDiRcrWi2mFd9G3bRd3YvmL+NfuZ4/62WKbDkXndWfrUXGxLkQOAwCp4zJklWWXwGeqEx0GJbvhFK6BUgotcSMDjuWL45fCnNL+kttJI1oM5SP5nhub6SdJKsvYa9GpTjfVu4iI3JkCVxlG8QoPhC0d0k72HsCVf6goTgRuI0ZHTv20wOjbYevRIGgGr4MZEXLiasGl4yD8it7X8MXcvVWQBYkdJOyB4z4cRGxRM0TtjPdxBmQg2/tFc8veIBuoTQhLyu6ClNm72gDQTNRrGtZUCx3pKmfaJPvf5A36Wv/JZyO/KkexxRMlKOYpHUNI5yJWdXcSLjtuNpx8m0vpfu7XAgMBAAECggEALU0t1BBrWvZnPWMQ/K0LKzPx/2Aqml1leYe9BR8jZCCVM5UAuRFu05SSJUMn6N7zokBbYjyxxdl/KpMDSJ/LE85LNNunKaZ+M8uxLY5vW/+QWUyHWIqwe9yenUDQ5CWt1hPKvSP1WluXyvU9P2gGJF9TwcDca9H4F8Gu72IOkv3kE8yoA2z33hBeRlzUVIhlcnrQ0pLASoWTDG/XeZWIWR1zbJXKliPzn5p19MdfJLCjEQR24f/X+vxOFlrLK0l74j5/rhOZWTR8wqE0R04MCjC8BYqTHnfyEaqP8ZL67GFOjIfGdPOlfI0hrI5t47j6FKEmoCoJjTdVQqyXUuXjUQKBgQD+2SS9XtL+IBcRA+6rgQYX3Ly0kz+rncM6lx/k1zD4ciRXQbvf4MhX3ab1IZMmujkCvaNPMBKLxZ8E9N7MY4dNdNVPy5fjvQY/2Qt5dB+o7dbzRIlBRj9Y4oPtswfKWiuyOVFa5tIf0TOpApcuIyyD+O9zbNyqIOZUfKQniUzr7wKBgQDjS5ZR/8Snvrp4kw1tfNUOwdsEcQUmt51ey3sNmGe+U3DDdvwKJx0W1b5PiR1b1Wheap8KR1d5UQn2NjUp7G9GSbvFr5uOH82vxk26Fsv5ZghXZTBEs4/HcX2sQ+mCb60sOVbs5UlV2mnok+EXY12sZrVhmmsw0Q1ZqCuMQr/jmQKBgFdWm5y6rpyg6sbODjGAmlH7OEC6ZguumYWu3SNUDFhY5dNxl612H7LdJ6bCxudy0q75xsoQs4prQ8AzG1f4lBobfC9ImtlVopqnC6OoBGGkgRIF3vQb2wHfP09rF7RliqwdsJ/ykviMfaPiW2VYcJ0Z5xYrrMQxWj6CKM/T4iTJAoGAdvA4ytPiHj0p6qpYnnByNPSwHRTfMzFmAhLMY4La1rdnDIGYxd9N04MpwQjo+gMkSDPW4VQPrAYCBnq7OyLj34352ipYZfiyc0Z7qeL//ZOszb6/kVO86wqyTpCDAqRZpAilOfWJeImAXhnz8X8np21fgKGDcdoS+FWN5CmRrBECgYAwLH/G3e+QqZ9d8ihdKiPVBhrTVcYD3ElL2tI/S6ELTP7GBMz7HH64gLoZNqT7drcNXgrbPOjSC6b7fVyyIjEmT5vXUNNtZtlkSb9mNKwP4qFUSkS33liHn+dGa3gERX84AvL8lKTG8P+VXbB1XJHnPW6LPyI/eGelW6lEVwFkAQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDiRcrWi2mFd9G3bRd3YvmL+NfuZ4/62WKbDkXndWfrUXGxLkQOAwCp4zJklWWXwGeqEx0GJbvhFK6BUgotcSMDjuWL45fCnNL+kttJI1oM5SP5nhub6SdJKsvYa9GpTjfVu4iI3JkCVxlG8QoPhC0d0k72HsCVf6goTgRuI0ZHTv20wOjbYevRIGgGr4MZEXLiasGl4yD8it7X8MXcvVWQBYkdJOyB4z4cRGxRM0TtjPdxBmQg2/tFc8veIBuoTQhLyu6ClNm72gDQTNRrGtZUCx3pKmfaJPvf5A36Wv/JZyO/KkexxRMlKOYpHUNI5yJWdXcSLjtuNpx8m0vpfu7XAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qmf6uXDHoY6b2Ahbiw5yf18XvRP7WDBS867v2F2V4K4QES", + "privKey": "CAASpgkwggSiAgEAAoIBAQC89Fbt4LtEk6LkBedZCoa+nIIAiSQpFW1XnMU9xTLviUtgBLCaYNgCuwpO4kVsZJvQMjINQqJEI1BjQvgpEkkduUVDq04NFdtcUmM1XVu5E8sm6nIWa+0skEkKEmm5vtnmB5qt/zN+pmwJzxOQXglRQ9f1WsiFSvKSMxNeXIh2Ht0QMqSNRX03uN8xBbrW+ZtoyUGbaPFQ4ZBABZcZdjHZmhkWBqWIRpn4JaUIdAt6nU+4LKISLV7aM+sBDiZMZ/CH3yNNwH2xDzvuAO1K3rygvMICNOIMNg23aieQ/C9MCgJTspGiMHzn0TkOesv/Ay45ONcPk1Dgy3KQg1/KXPB9AgMBAAECggEAPxS3XKzU9/ztuYA7Dt/TwhjP0cv29XxAx6n/szJ9YbiNIF4Qc0l3c9nrhBBIKvqfhe7sBL9FGshLUwgNfvCq1jB+7itnYDj2xah/lFY5g90WykQkmFWplWIJ8EHbZ/ZOGlxZiFMVZue6U7/9AQpTw/yJQVDwdodh2esRQURVDlGGQa8uqH9DImVOtnifClJcrftnF4BO73Wp7tK7rjNTt+UN6P234cZ/S2YXZRP/fGw3ObSopEYOSxMn212u7n+ieI0Cl02A/lUAcLQfIAN+XoH8cSQowc9xUOmBomplucOXCV4Mu3karZjlS5GeL17XAXXHg+J1kAbkWmXNBcDBYQKBgQDq9wx9P0ThBsiqOfPVI9Mwn/0rcaX6j29xK+kDMUVuxotaQjQB+gdO/o26DV1SOj6T9EmaAS/vCfQXMvWqgmubH2lCgC079RjgpQliJmo7FDufO0HoFMgwZzf8oX5Xld9fi/5QusWoGpyk8txvl8vvDlcg/8iC+Q1Lx1ZnPVq2SQKBgQDN3tDZ7n2IAu0I5B9e2YYSCsbPBh3TmQNGoguVGeseyzTGaLIEzmXYjgwwuhAzIgWZ/HMQMvvutMtP+opT+yU9XGQyWnZjPDzDMNtexY4XTmqQ1SWST2qNPbj9Gs6oZ1jJK6+MdgoNh7hFeT+uftzXtMzxVGrOcBMAK4qzT6oYlQKBgBeLT9YRC+7chikAi51U7KmXrn+28KHN06Xsd3nZaxKxlG8j6SA1lJvmx/7Xrf06VuDufp2O9uWmAq58bb97OBsgJ6UBQQccBTUldG5AWS64VU0cW/tMcc7f2O1YpVdTbkGdvosKXBn/KKkiqNIJzOaUckidONNe72UjgVXxAPD5AoGAAQYot8zN5w1MrIyl80zVs+VF0+XN5C2QrJtFv3ofh0mve4UtzYRRUWBzgxKJ3hc/O+Lbl6sJQci4ci9m3MAVEVcSUIXOrPOxwa7OiIwnBsqnEQ1eYHnwp7802l11xbSt5mJHP0WfCy4vpnjR7kZHRvNpSZIH7fr0vT16NSYiTHkCgYBEhZ0CHQcekk1/cWjIfNNjbA7as+doecQ+hj4nwlZG9Ng6CreCS/pMN0oupYO2pw8fm0xPZF2BABIQ0sI5igppyvD+sYF/SkKNUDCBq3KSD/5cuOdv2bEefnIhkhLTR75f8gJ4MJeCl4lkP695lMgYkalYHrCkJLuKaGcGmZg4FQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC89Fbt4LtEk6LkBedZCoa+nIIAiSQpFW1XnMU9xTLviUtgBLCaYNgCuwpO4kVsZJvQMjINQqJEI1BjQvgpEkkduUVDq04NFdtcUmM1XVu5E8sm6nIWa+0skEkKEmm5vtnmB5qt/zN+pmwJzxOQXglRQ9f1WsiFSvKSMxNeXIh2Ht0QMqSNRX03uN8xBbrW+ZtoyUGbaPFQ4ZBABZcZdjHZmhkWBqWIRpn4JaUIdAt6nU+4LKISLV7aM+sBDiZMZ/CH3yNNwH2xDzvuAO1K3rygvMICNOIMNg23aieQ/C9MCgJTspGiMHzn0TkOesv/Ay45ONcPk1Dgy3KQg1/KXPB9AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmdoLademTcdA2VM29NLb99GpqajKZWnVeQrKp99XpJn61", + "privKey": "CAASqQkwggSlAgEAAoIBAQDEzlaMbNq9kIAET1QHVsAXFENOtU9iWTiv+VyEoEl2P6ABkf1q6c3WjsP2CxgUDdHvstb5kyt38RhCIxa6CfQ0pg1c5/lJlDLmqx4eG1z6KTgYh6YePHjTvSFbKjrhCzFnXjuwitzkzAyYcaZMNeN0jkBU8uQ0FmgIzDZ31YgymkXqj8aFdxNx1Ry290oYJbTH+wsSEeIjSCGwvyZSF+IxKnwACfYG4rnZchEvd0mBnfdVIJW1xKfeVrihWnwbqn7Abq52gvFvojbCQlDzPvwku+BoH8yBEBuShXPHfHA6pFyULPa4f5TwI5/dyGm4ptLCCTCEYCuagrVqaCH6BwpdAgMBAAECggEACccWlbNyyqg7M/uc+SBeOsdO8MIhR4mXP2bsKcqs26sdj/Zo2L708wv0wGycraJiI76G369oIXVg9yg3INcNwu/dChicUgOC4+LshCJn5CXYG5/hqO7oMdzbo2PduQCNW81audKsVtGsboZ29KJYwpmuqInIvK3ATW+X5Sw+sATTxMG85Csr6s+kO3h6JVkbe+xyaUvyTNu/9ajkdpAIGlFqPtuhD3yxKaVxuEP1BIqr4RHzUA8IV1qB2M7PLstIFqAsUUOYymleeHZb6xDSjZxg9bO9nfSFTRCu/d6mSFj8ISE0YaE7w6nHf+P25VPFhIGzsQ1lc9Jo2n/DlxzZAQKBgQDy+7EXHewzOuDh+Fpsx5oBJVOixUnOryFgpFXe+o96x4Fjy/rHUUwSt01ikOOdmXqbtNpyJjWARPZWud1C5euBcePrzaVyL/fwUjCd0DFfka7ljB1v+mcb5dKkeVp0KFheQlqA7iOyPy4HC6xB3ZGY4uXjnEkB+nHLiQ0jxg0oBQKBgQDPWV2cswRDwQ124hhVn4sB3SfaUzNZ1m1zklHWy4sGXPYaEaG+gO4IIP6tiqG5E5Aj+wUCEPKBCwANW80bNOxdZIlFYImt82MhLuc2e/9U/hA8vXKwrX1Xm9/HPfbi/ZkB7WSVBGntoMx2uU6SDdJURHeR4RYFrUknw76GJ1ygeQKBgQDTQAPdB0Td3Wi6zYNAY+D+8gbe0wuySAyKyxVlQQ4RPva9XxBuzb2H4BnFghaCZHd2fCwXZiTJmitZh0pY6TBxYCU6U5ZtykqTg8GE0wa6Ahy+say+OEQAuzUBjggYSSNa//FTerdKNye7NGjU8t+svkgENVI8CBN7U3I7EetKSQKBgQCumNCjz3Yq21fMIGxfRR3XLvOM+vxFjLLTW4VAOlrRu9ubbfdlo8lL3QS2+wJdBuUb9xZre/vHv4yGsyON4k2aArs4SScF6+kwGv+kuFrzpY/kpZ36ucvOxrlzW3EWCHcb0Vsdw/6ykvE4k6degvb18EVC+GcD1rvAGSrIakKr+QKBgQDqTd13e9sjAtwabxykZif3j/eGSzHUrxrAAEqUJTA/yrEEHIRuFRG5q6Y3rqD+EZMoIHd9KeSKnv+WyeHLhT07r4V8RSdHKWJP5+avy25nJ8ykOUpawiwoKXeID1N/xLNMrF4suUgjjxEWjP6nW52eFzDhMqcOjgSWfb5zsLfBOQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDEzlaMbNq9kIAET1QHVsAXFENOtU9iWTiv+VyEoEl2P6ABkf1q6c3WjsP2CxgUDdHvstb5kyt38RhCIxa6CfQ0pg1c5/lJlDLmqx4eG1z6KTgYh6YePHjTvSFbKjrhCzFnXjuwitzkzAyYcaZMNeN0jkBU8uQ0FmgIzDZ31YgymkXqj8aFdxNx1Ry290oYJbTH+wsSEeIjSCGwvyZSF+IxKnwACfYG4rnZchEvd0mBnfdVIJW1xKfeVrihWnwbqn7Abq52gvFvojbCQlDzPvwku+BoH8yBEBuShXPHfHA6pFyULPa4f5TwI5/dyGm4ptLCCTCEYCuagrVqaCH6BwpdAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmZR5a9AAXGqQF2ADqoDdGS8zvqv8n3Pag6TDDnTNMcFW6", + "privKey": "CAASpwkwggSjAgEAAoIBAQC+5OEQhdvRsGh2pBY/a6dGBccThaH0L8coYFYHPoQx9M7puC7smS95zIyvP92j2+RK9VIswgdAjuqWRyBpev+i2TfFE37kcuE67HMGVWdk+2CAF79e6Ndabcb2/TuAT/1S101mV60niVn7URYqfFStbfqaUcsBViBbEKCIQtpA4AfmcN4rI+C0q4BncRLQHgr0tqJ7sHPYWbhPHBP6zJfFi7Wl3o/6lp8Mn2TuMdGhFmYaGZjn97F7NEUct7VzXnRTxXdwtNHu2RyeluASctHDr6HwKUsilJiUiZcpOrBdV2zrLYqO1yV2uh6R6r+xfejcIbhmS9Izd5wvlRv/v0UbAgMBAAECggEADY/VLYdVBqCxyzv9GKRdTew7KHfl+aMrUwMFGZ6nZaUuzgv3yXdYmB6gIBM5e9qzbV/gZq2iNkPxBpwnAVdrsfYcsDOiYDiJJ9aElX6byeDSCkeloOiJ5DLIX+O9xm/oX2pMZWj1NEndyq0IFhyfJ3MYyr3k3kNwKQgVX5jgSJuCTCMB4PP8IJDo0dRJQucjyBCeE91S2FpF7+eyxPsfz7ssl4EZ1RzqSmoAB2p1B9e+ajzSkRl0JX7nFTL3P/lcwn9QyvoBtSmulfZDXvMm7g07wE5B7EqFTzI7nbU2ZjgD/1Nk8zCzUSfibdmI6EXBc3k77h/dKc1WE77nn99DgQKBgQD6fSIja07V1hpMczSrmLabuRQy8aBAiOUT6gNGqU07eLJYokpUlLEv4Gs9vy/tcfGbPrJ131v0bd9nh/QdktIyhVwA3g0CU5kBUNezYHWRRA3zXHbNYuiHmRgdaouzN+SmMMylOxL/2tOj8Bb5Nm9L8LuCp8y/E83dYRp3cCKtHQKBgQDDGBTG2QWWftcQnU1jTWAHeBf7K05KwDgJAPAwB7dmQpFtlNxLxWpOOEixOPzO8b2FP/QRjapnxsktaRrhnMZ/nVz3U5nq7HBJEairFsyLNYF5DIyKXValHxjol+4abaxGw6YotDmsGtg00Y3nz5WOViNiNJxdXm0NCuf7uJR9lwKBgQC4lZmgjCTuAvYiPAsmIEUAf+RYniG/LKHSiPGdEoltN8YE9qLbrS7c3v1n5QlGal7mTc9oeQ3kE0s7mb3URStMO2XO5dKkUkI/6/jnoD9Cqum02gBZ3XcI5VIV6zvC938w0GkdoWigzfqDphrnzqs5RM6Iu2pvrAJaDoJYXXPQKQKBgFfvrs3CXIZtPbs7a/pqkfJL62NHLc77vUYxqhG8KKprLunZw0JUBYqkS/+11B3jUK2TGgwfcsO8EknpqjgvVjmHULQadrIxSJtm3kPfzuqgf290fJSRZdCfp7aPZL981749ydNnCOfOYc3M9s2Z/6tcoC5P0Hs1aKoMVGxd0nCZAoGAVi+UF2A+mYuDcu1dU5vlBt6FQmcwvy8wodY/0RR4dpDwMsgdSwMzfVy/nR8U1HXOWnQP2rlej0PrOc3fWKC2vMpTYtQ2lUVGCZRj+DnjIsodF2dyQXD7zzpDzh9PLO0n9+ZWf8aZkmKhHQc7HxB4aJLSJ+r6ti9zfjHqzOnXC2Y=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+5OEQhdvRsGh2pBY/a6dGBccThaH0L8coYFYHPoQx9M7puC7smS95zIyvP92j2+RK9VIswgdAjuqWRyBpev+i2TfFE37kcuE67HMGVWdk+2CAF79e6Ndabcb2/TuAT/1S101mV60niVn7URYqfFStbfqaUcsBViBbEKCIQtpA4AfmcN4rI+C0q4BncRLQHgr0tqJ7sHPYWbhPHBP6zJfFi7Wl3o/6lp8Mn2TuMdGhFmYaGZjn97F7NEUct7VzXnRTxXdwtNHu2RyeluASctHDr6HwKUsilJiUiZcpOrBdV2zrLYqO1yV2uh6R6r+xfejcIbhmS9Izd5wvlRv/v0UbAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qmeb34XKhbo7VtHMXmyep4MKdYWHKSVvnBVm1eijoJmy8U", + "privKey": "CAASpgkwggSiAgEAAoIBAQC/uQH9VPMIQ0Q5FIHRJj1rvYhXX1q/83Gv1EVBc4fOEPJMoRys47V78y9NXtPu1NivOi3qN+hFwXdNIX4azEQNiODHRJ4To8HC2uyoDtL0cjZQucEGDSJXXkMbtEwS1IFvKG+iKaaoFjw4LErYvaSYVSsV5xFpzi+ScL9u58bWEpwG5pAI5WJjoV4BX/mO5NFDfViTOsXAFkeiZQeru1GoJ+bWuulsLjnmggO++9yQG+PnXw7d+7S6XynCEnJv1F1KZrpCyfStpoayHHBg2zyDwE2EpwHvXQzTxXN414+8V0AZ7PPkQptFcxEKtbJWXXBnlIc3V70rtEKRAmlcKqZlAgMBAAECggEAPzcYUdh1ve64Cv4ZA8ZREDpRP0XgnVP+01PxdfBLAgYSbnPdCaCXUYRQv3kZ9jDWNYjAZO8ENiPhW1xEwT9C3ReZzfpxCNbA56fZylwA8LrL7/gfjgg8n4QkKnlbcAYDm4xAqr6DBf824eqwzyBQqi3C5BjpY/KpOubUKBRiOmkcUeqqVxXe0Dud8qz3rOaSOsQ7LR8VWliasCqp41uGbgBlSNnhFDFG+ONep71OqNMEV+/S341E6MbDj5243JVnLZGdyqUK/V46D9ALMdr3QKy+51fHXPz86GJvhzBq23xdmHARt1nmDbEjALw8lva1Yjss1vXPKJr167lkHYAWDQKBgQDejPUK/qqmYLFi3PhfF+Rw6YSSPPi2n+tWF5F7gm6xxzi8vLAHfr+U9vV5GtWXztDJ5DbdKF31+WlfBOOFWMYw0G2Z6ad2nxvzAMcuC2jP7cIf6x2sMq83AdCSdxr0eFr/eDA26CNPrIQyMkAnScSwsnJlce3j08dU8zOsvUdZRwKBgQDcieO6EdgxZr4adkSUaaKeS4NZSzOo0owZhDk0ipHHCc7j28LmyKrA6ouokLKB9GSYHIf3hlhmUORljMwR3wElG6aDd94awEcsuw7gYnoHUp6XIYr2H5Kr5r5rcUOmIV20SKD0k9OZvpeZDo+paRT+xPdN8lpdGZXrD60qH3vY8wKBgEL0e4CcT7EQpC2PN3Y8lPDXgJgSme0vvbjADHfxLOZ1fn9h8T/ABVmG1yFhTmOGyFAFRfBRhbtMF0SMDvt+Uto6ys6kekp44grA8CvNKPJtoJrDvMCi2w4ckKiQBt8IGrCDc1YBjyYYTAliDuUDD5btiPc2SJDjlTPcm25b38xfAoGAZat3/b7eQSARgdeGFDmCy6EaY58EqM6v4c+QI8XCINVHuMoGVyipd5hpXAOhF8IYYfu9PwKDXF/se1hmd9KsD3Ro1nD7Rq/f4CI4YH9lrFyNWjUPgBncHz2YCaZEvqDhNwzIjxhbU6SG9Pu+hSY5lJ4vOJMCz6rM73nhpeqvyLsCgYBk6nr0QbXLRDnYcK/91NN9mJQWoj2p3K4KLtkJh7zWHKDihf1a1cxRUj+kfNU875PH+TaZ0Md48VnnYlTwe07Hfc38rKZMX6vODBHbe654XGd5yhibhtTq6dhejLatGpwVj7cFM2TfA8lhn2yS2aSZLeOsUqEsRbpFc7c7dOcljg==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/uQH9VPMIQ0Q5FIHRJj1rvYhXX1q/83Gv1EVBc4fOEPJMoRys47V78y9NXtPu1NivOi3qN+hFwXdNIX4azEQNiODHRJ4To8HC2uyoDtL0cjZQucEGDSJXXkMbtEwS1IFvKG+iKaaoFjw4LErYvaSYVSsV5xFpzi+ScL9u58bWEpwG5pAI5WJjoV4BX/mO5NFDfViTOsXAFkeiZQeru1GoJ+bWuulsLjnmggO++9yQG+PnXw7d+7S6XynCEnJv1F1KZrpCyfStpoayHHBg2zyDwE2EpwHvXQzTxXN414+8V0AZ7PPkQptFcxEKtbJWXXBnlIc3V70rtEKRAmlcKqZlAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmXcgkTakwu7rsVf8ZT7A3uD5XwNB6Pbz2AbbjaENrFe3N", + "privKey": "CAASqAkwggSkAgEAAoIBAQDW/ZsbRHAZf3Vh2PyUSlXbBRHl0K/PCX26vMe38j/eKSYn80Up3iRk1Fk4MUKgC0X3t1Ldf/Y6In5RhohbX7mpni4kHErjbhKtjLqQWCTiSNWMDVuFoZ7jiy//Qu5V+w4tdHogyNVgLhQhn1SouGJ5wgYP+XA67NQ3XoSzycAPU1N3LWuqcWwHWI/L8mY1qsmZ46ShporoSul+Pp4h0sDXqSPSJAZJsSV4/baywJMBXD91wRo1IhKvd+3OcSgVAnNnmBMvVodSzN0xNmmMGvHijslam+mYWW4B/603QAeFmYK3orEKcQ2lZVV/1lsvbg4GqrlMLkK4hM8NbTASa4LLAgMBAAECggEBAI0xl0lMJBcK12uAlzlIrKQf60Y0TRI62IDodH4BMiLUgYOhSB4cD2jM8R9vcqMrZDMxCdIAtRQvDSi7oxfngUa9ZO5ASoqdAtVJ5EjiKq8WSHEnYKEdqP0lr0sEiQSc0g3WPlMDsubsvDnsqyv3lG0EmPiqyCNa4HDQuXReHq2wxh8XMkX68CaqeNOianRZ/r/pgXjVigcvxckUA+wyTm+N1tvnbF9jFAZkJOYbL71qcf1VHTgYIZF+TZCRixSaysWSotmeGX3PeoJlYHF4/5G+9YJknNDRRB31+IAZJX68S2Nz69DxuttWCIRiSp70gyctG+DN0xmNAQhTEo/VRYkCgYEA+RcXbAgMMovnp4rPSklez8+C7tFxNeHMzYfu9UfHIfzrQXZncs3W8K1I+p3e7eeKZ08mruzAL/U8vrlr/ydtF1kNNaBDMUfibovUh8a4HlHzqvYlBNQq0NM87YM0P4ishQ5b6MhTIcLv/Xhjjr8tyLFmevt8qwJWh8uEl0pREQ0CgYEA3PRbb+qMECEepuYxjkh5LztzQNLcab/KxtmK8om5hmXahT8t8iBobxZlzjDxVhAL3OYCYLA9tomULMBXJxJLS44uH+S04M/LbKFl4sDZ5scgXbwOpR2+a7OQJeRwhxqc0ETdFP3qfGLtCeJaYHdeq2M39fp2ywb1HEPB+nID/TcCgYB7hVLtFJSP4EbxE2m16eplXP8N1LiyQpXf+h+qbHy4QwaagM/N43tKAHRnKzBog2Bj2KFTLz4iyhbkcWi3r+JuKI/fXujTIFWOAjNTXVziVDtkNQmoeln9EjNtiJm5Q9phZPx41BY9cMC3ziJ4oB9hHW+3Xsy0tMUaM/c9WvIWZQKBgQCYNs52/wGWavqOx64D8vFpFG+FjL3DLBkpe9w40aA5chlkCe5BCwpm3OstbJIVU+CYQOwKZ99bzNODMM3ZYMT2O/CSkB/7b6sYHuftmiWC0lL9v/vmy+LOl1kKgaDzseWtpIMZXwMWxZ++W20fX5ycPTHkBrOnkhdxbUxImBsfaQKBgHTr3FGm/7BhVdlG1GW5qlTIi1gRLr2w+0Txmikoq6i1ljfV5sQ+qHWNYX5SEzShcXvG3qghyjtkvHzP2h5GQ9ji4Q6R5XC885vSpe/4/B1F82otAMmEqPMppk1qZnYbsjfDi06n8KHk4EGZjTVfPe6mkXs8R+hK0VmFoHYMQzdy", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDW/ZsbRHAZf3Vh2PyUSlXbBRHl0K/PCX26vMe38j/eKSYn80Up3iRk1Fk4MUKgC0X3t1Ldf/Y6In5RhohbX7mpni4kHErjbhKtjLqQWCTiSNWMDVuFoZ7jiy//Qu5V+w4tdHogyNVgLhQhn1SouGJ5wgYP+XA67NQ3XoSzycAPU1N3LWuqcWwHWI/L8mY1qsmZ46ShporoSul+Pp4h0sDXqSPSJAZJsSV4/baywJMBXD91wRo1IhKvd+3OcSgVAnNnmBMvVodSzN0xNmmMGvHijslam+mYWW4B/603QAeFmYK3orEKcQ2lZVV/1lsvbg4GqrlMLkK4hM8NbTASa4LLAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmVc9FLuDob3aE5ToYqx3L9MandZL8TD23mzmamUqBtz62", + "privKey": "CAASpwkwggSjAgEAAoIBAQDR23+nHVwMhKiv06tm4hsMbvPUpMMBCnv4SctsJA/6ByOfCy6tw66RURfMGbk2xnLFv74/vayf38jckD9lMmz2RSePsRk05IsZxXXgBzxNEO0eL7MoK+60CvJaYflFB9TzHKOnZheZktEa7wZttpF1IxpXS0XqejvuSPH5FqO8iBBWgKqpiXi0mV/5M9UJ0exLynKFPiB9zaijJEY4SXmbPqHPQeARcivqGorjmpRBe6QXWjGOKsRaWdbB5WbI5iz4Qh0jTThy1LOkM9TBY3DvbgmtZ/+0G/BgLjrZov38TKSBb4nNbNysgV1iphUucQl53sUxbWdaLq20RHrOkyx7AgMBAAECggEBAKGeEel5yvI5GFCRC2foqjwhFtelLCkZEfBdpLRb8ZH0/ZH24rQgB8kSUul0xhdRLgLtcG9WfCOEDQUQckJVW2UuTRF0qpz5hccLM4SdDeusJXEh+y/s5aDy7UJ+QaLQLUgtvjulfHdhgnjjrGfCOrOjnR2tcuLp0E3rD69tqBwAp+744DBvk+GEnwduzr+Akk9F1UlxQ1C3FmnKEwOYrHcdGQvsFQf9mKsfbmDhqhqaH7cr1f9hlRXjFKN39xmVWVgqVDWZ1Fx133am8fNn/Gzd+5lSDkyAWsWcFRJZoJ+n03YOsf4yC2OzDhzVyZ7DKjouIwYeqI587gseox7BBoECgYEA+K79ITiGNYJx6rur3MojRTPajcX38bcvHBCDegttmAKbUgepYhQppueuC0xFjdqg6NBbtjbeURwI4G/qyD7kd2jI3ZXRiaBRbV21BctWt+fdCtp0Ri7FLWSKHMq2XpgHex7nxj9POqmOdPf0hHbJcm+WFK8S1VFKxt7jZLQ0siMCgYEA2AgVNl+wBGr1lgvqnxwZhfFjZJvbmn9lA/IabENcRDMGexxVvPwX3U0gH/2BMrsSG3qMoyF0hH3HHAYJQSnl28vqJtd3AbBqtJ8p/+KQHJ8RinPuxrc2/lt9WlKxxV191PR5hWgyR0r7GGEZAPiDTya5/pkmRgILpOVNX/de5ckCgYA11kxeoMoNU4wt8SsnxWsVVECAaNdgsPO1861DAq5bNlVB0P7OiObrh0SalYyJRUeIn3L7Y62FibgyPohpiZQUdc7micSvMtHuB1dlRbwkXEHyU5DQkNeHGDj+OrR4jhkwgmRS+unAHW0FzZhWBRFfgODQ4YYGQG8b1q0L5Cd0WQKBgA49eih7Zj7kTgv1/SE/2O7bWpHnNDKa8y2vZ857IjncozC6TWyHsYsE6nkxXLLbYfYtvdeC/Qs+v0E5pKKHAH/ckTK+QTn7Rw1g8IPNi3JXifB2c+blbNqXbUvm55D6+LBw7RG+LJJGfwa8X8mQmBc/lkMSFVPIDrxv4QnSZI8BAoGAQIoWEL49iWhre4EedAS+awGFxVs1twC+VteWZoKwEmISjavUL7ecRzFANPCi1X30b6VJhdI4lZp+c6OeZAQ1f2o8I/OERDYWeMuEFZVKQCzxsfXVUtv+bjKflKKdevhMK2wtG1KgSEKvhLWaNZCbUNgEyijyikx0Gn6f3mx7e/M=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDR23+nHVwMhKiv06tm4hsMbvPUpMMBCnv4SctsJA/6ByOfCy6tw66RURfMGbk2xnLFv74/vayf38jckD9lMmz2RSePsRk05IsZxXXgBzxNEO0eL7MoK+60CvJaYflFB9TzHKOnZheZktEa7wZttpF1IxpXS0XqejvuSPH5FqO8iBBWgKqpiXi0mV/5M9UJ0exLynKFPiB9zaijJEY4SXmbPqHPQeARcivqGorjmpRBe6QXWjGOKsRaWdbB5WbI5iz4Qh0jTThy1LOkM9TBY3DvbgmtZ/+0G/BgLjrZov38TKSBb4nNbNysgV1iphUucQl53sUxbWdaLq20RHrOkyx7AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmYazJE7CkpYuDRQihzJdAqTNxHnPspEyoqTQ7TJ5pGQW5", + "privKey": "CAASqQkwggSlAgEAAoIBAQDR/98aOI26A/x1Uxu1/gm/belKQw3FnUi90eniBFANW8Fp3EVjYhuZELJelILmYex1ELxROoojxJ9g+eBNxM5/ZopzfbqBT2vUhH/94AdXXRksNR2WKHMVdy9M+tnIUpMELuey2ibkQSOMlYoqdQI1zNK3fg9QsACRUkFe1T2Z2gkIJZ/Lasb5pU4SqaTrhqtBs023ghdPaC0wV+LRwAhuso9mwWysonYfuxRi1++1RLizBHfFjfJ9sXRTaPjb6DEY/W9/984ypIZOoeif5+zq9UV+tt9LBrmuHKeE/K19Q0WIpoK+KlSGN00TwglSy1vI8q34FFguxr3d41FqOlIxAgMBAAECggEAeC7q/TOukO3lFzRYIKDh7Ue3AwQ7JoSsc85l/y8erXZ8y9v/bjBgwQoYOx7dh4I1dI3+aLKLCotl93cqUve2gp0p0Yz8JzNP8BFguufy66HhXTaM1zoRGxDZ5kGOUCJJ91Ps0KQfK/THppaSu1e5yxaM5ezkUPZZbNHZja+WkKx5gFU2s0VD3zpX8rrGbsJ7w6n0sW5dqHYyBcE5u4dhopLkRcLwtAti1PL2N6qsKXc7eEjlKsgFCfe0gBZZO6o9A2ABXob5skB9k8TatRCKc54aGJtGjHjff7Lwl/D6gGb+GrBeUCwohIC/OON+lg4dv1eT55wNm/RfAOD7NnlgXQKBgQDv6FMoy4zLpSjDtWU2QDzfX/t437hCXSPR8pG9XTF6lO9aQk5pOvMrDt1oeOp6L27L02d8RGxcCO5krj47zAxkGSSJS2Msw4Vg7/IpcV91D86wGEORxzzhITHccKkXK8eAIwffKDg8QgGA/dDpGWKURx+v+zErOORDuKtk+gKUwwKBgQDgFffcZqoilhj2sIu6r8lp/a1DZeLHLIQTMVtflP9GO2qprnbOIYwU9W3iVc28XpLDjI1x2+MduohqBYkjalpvOlx5XTI2t65fBa4xtmCOfOwiBNhBkLS/sf8cSCsVEDA7Ixwd9FnufZNlTDumKzipYi+vpQt94d2t3dMv3sA9+wKBgQDgKNDC1mYoxZowOyZlqWH3SSSbzVXKVGKqwZ6hNBmOMujuCfRf6J/bBJmmCwzzu6wnsNEJ0Jj66bFty00E7GRLhx6XViRFaC8Q40H+rRsHMwzphtJjvKjKpgyDr5SevN48gP7S6S6aRwZGs2Hm2zw71bTq5qcLfq3yBPPIdr3ApwKBgQDHekbe6HVjvIIUeCyqz3lY5P2sFbK+4x3fh/xzJcvo1VOqISiZbruonKJo7UDsArRbZ28ygC+5cyekWbEu2aoPgcB4OUJN+006QXBDyLpDnWkHD5EDLLH6Q5V5s7TGV1bYDfUlpTO5XggsEKS405jpEAKrNRz5vmr8L4+j+YLgqQKBgQCBBGCglLh4eUZEx3cDXzAonLEJGKHgQtvDXBHqYXImmeBHHxs1zcL3oL1n3dYTuXljz39YmoN3RRWVBzHsfnj6m8vBROZgR3SEipLPr7mVtJizdFiaia+YBEPPZdoOTHIOxmLYumvu/WArbpSwpk9RBJndbD0wLpbUIAUUoR4CIA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDR/98aOI26A/x1Uxu1/gm/belKQw3FnUi90eniBFANW8Fp3EVjYhuZELJelILmYex1ELxROoojxJ9g+eBNxM5/ZopzfbqBT2vUhH/94AdXXRksNR2WKHMVdy9M+tnIUpMELuey2ibkQSOMlYoqdQI1zNK3fg9QsACRUkFe1T2Z2gkIJZ/Lasb5pU4SqaTrhqtBs023ghdPaC0wV+LRwAhuso9mwWysonYfuxRi1++1RLizBHfFjfJ9sXRTaPjb6DEY/W9/984ypIZOoeif5+zq9UV+tt9LBrmuHKeE/K19Q0WIpoK+KlSGN00TwglSy1vI8q34FFguxr3d41FqOlIxAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmTw5gC2FkobMiSJ9uWAUPXuLoZMRXkXrAVUQYTA972fo2", + "privKey": "CAASpwkwggSjAgEAAoIBAQCvs+za7Dg7qKqOg3e+Zc4y0fKucQ72ECtbYTlbXmPiVeLQ+FZAl4QDWno07aya0ej2PgNlWX9USO4gU7gjBWYJpfm35vFpSedV/dglS4G5SdysaE6mvh39GBqpP2mIsD+R7STrpCamh+b/K3GUb5bwfbrdmkMYpsfANH5Y3TCGVBNjFFZPlnOIlafzgpMHJRcTOhCGmO39KQt76ZFfgtXqFXnvZhiedeP5bdWTRMHc4zP12IRLLLAoyseysfpYBdDoSETytPe9YGEQfCHBcfzz+xPTrEQXFu5uTz8PUEyH3pR6lX/aFLrQLyJ/CZZHh3ouCEQlj2/EM8ppYNkgiZu/AgMBAAECggEAROVGgOmTe0E977f5Yj1FR4QvpttKRI4+kgxjk0JF5GBNGifmmllPOIln1g1EW0joEnZqmnknhoM6bI6na4QYaLweWVBDZUfHYF6zPJyI94DQ+QHFpXhzBeVHvwnQdfq2UqAslAG/7hjoKTJ9zPictRx4A6ETojzzophy2qGQ/3qdRxyc0ybcUAAcSvArnqTPp37LZgSyBXU4yo+oRJtmgCFBCdUimgn5YVx8YQ5Zub6mGutWixVVuGChaXYx181ifT/DqWI26WACvs1mTr+9GVD4SkZ3FUEH5X1KvggydQesvFQrjKp7842b/bsP+z+jOXU78+V2I5DJCsnfJr/+cQKBgQDoFrx3J06md18BfrL0PDz3eRFKR5vQ/8l7WUo0tN5UUFMoPq4xHlbBcaKEdhM0FjBb0KPqugugLIgscX5oz3AfEA4l4ljHoDABN7D7A4XNLyMgx7erH3aXj/1hz7++QH3VhW2rZ/uUw8voTkFdvYjXoeToUIlESYywMA/tOnYHewKBgQDBzgckMga8SGr8p+QOdP3HDt41/XqDRtHX0q8dBw1akyB8p6vYmxKb0BQuNlR+A/rzJXM5usVdjSRdRWOr2lHPyJ/NkH2oKJiYH4+q/n61DFRHA0f2/XuWqLaOdOk7PpH/7ctx2tEodXMmocyG+cVFEwRnMoMXXaeN/Ck75/9njQKBgEGe/BaslH5YzhH8ItkPlyVZo9vet122lN89dc/FO/+W3oxIfLQCogD8Ajl1sSRPCclMCqy5gcP+E1qNlHJKBKejwHxRrUx0LF6LwoyWiGRlaYdBMNs/gCaGXdwkA1Dlpy6SFVobgnSjj6nVRoIcru5ZJgHRk54tNYwzaq1mlCy1AoGAYCfcmzTG6rvzeQ/DsviQwSa7UYZGNsP4cWByybAqC/pbb/2w4XNvNCd1G8iQ+0T2SZUXKllkexoAJNa8sRNM7A7aWp+J+NjLfQ6LtYc3TpSja+hQ2FbD7ugeS2fuIBrXTWeqPP8YLz62t0AnvgBGxBK/aIRDTmCFNYka3EIrEjECgYEAtL8cYqCkxJQF3fvN+B/iSUabXV7kUKeB2eELaodzAEBJjcfKwwTEyAdvb+7YXND5TAF83+qoXsq+f+Dbimh1MKsYV3kBTIxDOHSeUwgb7IS4mMlyr/A3SftDQkYZ/nJ9MyFfLhfC549WSOZNMwXs6AVxV3YzfoeF+5Fv4dsNZa4=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvs+za7Dg7qKqOg3e+Zc4y0fKucQ72ECtbYTlbXmPiVeLQ+FZAl4QDWno07aya0ej2PgNlWX9USO4gU7gjBWYJpfm35vFpSedV/dglS4G5SdysaE6mvh39GBqpP2mIsD+R7STrpCamh+b/K3GUb5bwfbrdmkMYpsfANH5Y3TCGVBNjFFZPlnOIlafzgpMHJRcTOhCGmO39KQt76ZFfgtXqFXnvZhiedeP5bdWTRMHc4zP12IRLLLAoyseysfpYBdDoSETytPe9YGEQfCHBcfzz+xPTrEQXFu5uTz8PUEyH3pR6lX/aFLrQLyJ/CZZHh3ouCEQlj2/EM8ppYNkgiZu/AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmRkAAboTpBsx8xB3BZpf9JcGfojpbUapi5M2tTgUuhaR7", + "privKey": "CAASqQkwggSlAgEAAoIBAQDNK8zVQEpDabjQnPpSAgU8O0yqtRHUiHPIFDB/MJ7aKlqXnOSIrM3ZmOBPl+WRRwOZnUJFV+Zkp1rYMF56oKRn2CJ0jrAYDdJ9At63ozjS+3ejg+F46zo3r6AEvcCKNIRFAf4IkI7iFLYL+FbiO0RVB3fmQePanSCTAz3WuNlmO93MgvEQB/HwAytMyuhX/aV0dYKUS2cHfJXUvw+6qnBnZ9nmW4acVUWf3+A+bVXrR2KX9YBG2p8XwljIkJexdilfiK+6PMae2OPvzgfd1J2fHCTLQBEyujNDu60egxnhVM5EjGwkwUqrFGWs6sXD7JO5lfRbjigZ8rxKInVMISL/AgMBAAECggEBAKAYtH4W65wM7CUEySOi5fjpANsX7bDdRRN0BZ/KDbqJYCV8TKwFw58u9qHFEmK5eiqtFqBLhcE3AeE+ZQrlPUS217QB/5DVgFECI05CdD3V8bZLW25ihwwa5A+vDYYKksfSVSrTulrZ9HAEua9QtfJvoHSxJ55YC6oL1n4twZ5OZAvCA5qQgx6SisBK3WoMwUtGPvpiktr06cXJTveHzn/8gQs+UgUi9hGQwT2ytwFr+15o7FMHxiEPXoln5Ltsw5PbIWD6kAHLRPaH3NEMdhR3CpeOxLg/Hk4qWLcDr8kvOccAf1gsr5mYqkdTNqX6zTgGi9krfR9L+u/9UBG19uECgYEA9uyvmVPtgVroJkTG2KxfDXX4zRcpa8+WQTZCv0tjdRC4A6nXk+zppzYibNdt8e6k+ofmHQ8sEZ0UlLy+5auNWGxiQ4DUyX/SlhB2BY+bpfQ2/yXyW5b1l8y/XSzojQ5coYG3CSvCm+iSCiJVXD5oFpjzi4GjwRfgSsrsbbVz5q8CgYEA1LZBd5RveQCGdL7H0N75j3VyOF3Xu033mPO2NFO1517xEcYJlfzNe//Zikwe7fxPH5HEp6Tud88pdIcNxXMbaA6GL4gJAXMWoT4lyZVbG4QAz0oyvasByEv54UZtgebX0k1aKb8AJ9FPfhuJ9CQHdXWOiBHhcLNh/fB8GQtUnLECgYEArnAClVT/IjTwb6iCuSr8c2v1+hz0vB8ITMViXfWKK3dGKABiNTRW1DOgGjgOia1Hi11aKQlA3qiTk4fLbEDHN8JJoNpweHD+edjjJ4aONKzT9Wf/UMjScwzH27EQECYnNkmG3sm1T6L7GIGsv9+udNhUpSdOYejWIMA+Sjq3yC0CgYBn3xQ7E6YXvZTq/5rNuYS+dEixk8ncMmedLi2kgdhLQsaPulhGAOxLCBYv/ZoA9vugW+tfPiAhK21/9M9Zwyr39le6cECNj6jWVmXXeXLDDgPjNcVvb0lwiQFd66lgDN0JWjKUPiwSRZj+6O3F5a4qwpw2gBzJjx9kBQJkrG7GEQKBgQCtuQoVnjFUVBzKTJP9N+SDbS+hg8uyzoawfNPhs6AKdo2I9eveJBut2Fdi+ZUq52OApnwn7+YvLSUl+9eS7Aoq5vxvfsE7ooavtlOXkrIMkWPUZiUp5xLVy276R0AjVhWWoZ3+7mPOmUx8F6w3+lk9+g82bjxZoI065f9hml/DTQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDNK8zVQEpDabjQnPpSAgU8O0yqtRHUiHPIFDB/MJ7aKlqXnOSIrM3ZmOBPl+WRRwOZnUJFV+Zkp1rYMF56oKRn2CJ0jrAYDdJ9At63ozjS+3ejg+F46zo3r6AEvcCKNIRFAf4IkI7iFLYL+FbiO0RVB3fmQePanSCTAz3WuNlmO93MgvEQB/HwAytMyuhX/aV0dYKUS2cHfJXUvw+6qnBnZ9nmW4acVUWf3+A+bVXrR2KX9YBG2p8XwljIkJexdilfiK+6PMae2OPvzgfd1J2fHCTLQBEyujNDu60egxnhVM5EjGwkwUqrFGWs6sXD7JO5lfRbjigZ8rxKInVMISL/AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmcEhzB1bUTptZ8tMHGDscgAgRUok5gPZUiqHWrXy64dG4", + "privKey": "CAASpwkwggSjAgEAAoIBAQCtS3RmkSwMLNS7Kvn+8ztrn9olH3EzScK3r/5+PyJV4klYYLZ5RkrPWdbCB7gRmVkwc+GqwiMaHVDualDoQNdbguAX0r4nhxo3/46qDgUf7JpNAT0sjyyr69LzJj9/Qs+o0YGTX8W8rAX0UBikoFI7DjbFf9dD4a8cEKLiaqh5CGKS7zgYVCGv/ohp3MbZYXZGbV2FAVOvLQwY1edJP6s7kBHlQhinmkzW0bCdAgIUD5DZKiwsmPjkX5oBQw2sCUComKuAQGiacXcgJ0/ykqLkj4779KO10Qs2DwaqvEORx1W+sgtQ8KllbDqQHzCq2fXJY6359noSTAlgn+LI1b6XAgMBAAECggEBAJcBrUjDL/LcDfObG4WCRkEeZmT65RWgLMEL52Pzd+QG74rHm7pJ+l59Fpq1RzxuuD10fSzjRts2uJNIqX/5ILBpdwTLa0/edoZddt/Qn76V2k9HyRrPGEonkQa4SZSHj5S4G4Vka1ZhQD8InLC303AKjsfDAr3wJzr5dDaAYpYzvSe2KVZpQ06JPYxwiaS2iwxJX1f5vNyvVj3HZOShaw3evKsFilzRo5sZhmeMGa16F8koEckbbjtPmK/zQkrJ6Tayy/8FClffgMOEinrU9V/DKq57wJT+MlwrlIa9i+/N9Yx+X9qgSNfnMJHPLRxRnNELzl8TXGm0/Ey2UJfyDaECgYEA1zttzJUHIQX5bGNwvoFMs6arLs11OIZOJXAodfTSlZjJJqwFfpuxfqaUXzA7WCSKAMbUJsgD2BPU5yZMF8RxhWCCadweXZdELK5kXXip9ddhcw7Hi/eBC5DWk2in2QS1fwC1sC9+WHGpemUQJ8kQWVrSH6Vga9ez2VMjAI1gtrUCgYEAzh58/H/4zyPJWGQaD5m5tUC5AOW7h5hYsVhgHM2g/vlt4V8iAQNo/eY7xO5jNp1c+rpr2QbHxKMmgCYPSGVOO46JnKsafOxupW4rYsxkywLHGlK+dop6yORBygP5wkNdcpGklR1kvrBN7bC8Kal44YIFVrIbLVoqIvSbHAN3A5sCgYBNkjmsdjmviTuv+Nb1khxW00b3A02wJZecnqO2f5o2GG7G5VDFpM9/2gG3nOaGigTC6uYjZAseoWcmOANMvZw8eeAGzzKSgKYthFzf41E+LXYNxdHdfEKiLH1pe1qjOLNBJrxU14ktzylJ14rPDAQ8cCMzDKOHuqIzPWdsF4g30QKBgDTo4J6UXxMVFZ9J+uKcTG55kcPoNO5GriXAENPz+OrarlkW6YynCnF6g0c3BmLDnFWEOyD3u5n/Y2er3WpxDtb87Ng5l9APhQuULzDqVMlECkX4jYmyXHhrF3Q69wbl8fvx5PSeGflVGnv0TSjIpw4EKUiq6Y0Hwx87+QEE5q0XAoGAcDHscbuA/w4SCywZEbzrlnY/Za1VW9hwgiDbQFxQD85eSYLMt0D9u141l663JHAHEHAWcFv4LhdeCrdhvIv1+/6J1vndPjX2cJ8XCV76x3mnSSUvrwalMoMTOgERO5MLQ4B/qHn3mJIWEUMPSIZ4aJSqpS5nne2113TbW7ijQF0=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtS3RmkSwMLNS7Kvn+8ztrn9olH3EzScK3r/5+PyJV4klYYLZ5RkrPWdbCB7gRmVkwc+GqwiMaHVDualDoQNdbguAX0r4nhxo3/46qDgUf7JpNAT0sjyyr69LzJj9/Qs+o0YGTX8W8rAX0UBikoFI7DjbFf9dD4a8cEKLiaqh5CGKS7zgYVCGv/ohp3MbZYXZGbV2FAVOvLQwY1edJP6s7kBHlQhinmkzW0bCdAgIUD5DZKiwsmPjkX5oBQw2sCUComKuAQGiacXcgJ0/ykqLkj4779KO10Qs2DwaqvEORx1W+sgtQ8KllbDqQHzCq2fXJY6359noSTAlgn+LI1b6XAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmXDuRHJvjK8WDmqwjnd9PSRi1aUTC1p9BryZ922wdhdBY", + "privKey": "CAASpgkwggSiAgEAAoIBAQDXo5iqDYnxNP3h40X+0fAw8b3bCEfYdtzrYCV6huKegNzxPkySFTh+9y6fcfi8Y9HYH4RkovmHqavlWlE999IreLQOzvsRVJ2pzOaSLURid2KjLO5hSi9CZTRPOMF70OGh/k2Egh7Y1buYVbDKGrgB+aHm76xxI03MQpvzhINtxrVlgzU4ErYEOZDFNXaccSH1UOfATb3FnAtD/3rhqldMZn9sAyULThoDYi1x7WxgX8j+DLx29cwOyoBBFtwS7/AmI0p3rYN3Y6otBNv0ycGnfg6dcnMdMDS+OcxBzqZph3o3ICKXtfI2+cP7zWl1QRBkblQdbHOYo8qevdw3wr4XAgMBAAECggEAB5FaPj2TZb+yWUccocDEaTNSsmkr/FDPmAMbzZ0GPwHOvzisf0P3Y51RKY9aZ2IpbyhMASwnDbfKrJXq2/3ihlwKFar17LnHfroOLXshN0NxVsCw7QEpf28F0vHu+GVwRbsjBU97vahimQoI1k7xvkAAipZGuwG+LTj5OCaiZivOkFmFwiZb8FSwGkDkGnWEObh2fWXbh/NNZU3JJ9CqU9RcHaguSonk0z5gOrQrcrbQrY3oNpgPssTVtwdPFxtGzf85D6tnhhmQsjS9E/dDyGYoNK+Vue7E0KoFGkJCXj9z/I8hPt4eDLh6HMA6Zqjxj1EcM9AhIqe8B2wYtAhCIQKBgQD9JFWEbvJ5PuNznOPmVG8ScBpQNbFulVnxOorg9S7dBSeS/TU3hFJZi0ojjtCKzIfDGumc+0Vf60M8FvXxbkM51R6DBaHtHwbIaX1luH6s05e5tpat9B/mc4xwQPaoFbDO/EvrdflBZRpUjXfM2Rgxa5rnzxgOKyN6Mck5aFZAowKBgQDaEt3DE3bSgnvovVsYlxOSDdGBEs718ZzGtrxz5u/i2WxXgXhzriRWYXoLjEBCUF017frbTyMIilBzX3DR4y/WrPP3NP+n/IbdyERQUEo4CY4cfOuHjS64UQo2kvIxBpz8tAbE7w2eQAFm1c9AIOhKPYmSC/SRo7iO2ZMekPx//QKBgGoxpOJyvKuac0ab6YtFnnboqlE9xRpz8xBck8g9cxRrRifGq12H2BgSc96o2dlwZf+2OYyOaJMNmd4Kb9CBhhgrzKoAYeacnnbSsjVLCXEtLrhM3bdJ81v021R4HEF1IAAlHSBBFHiXlk0kL76y0BBjaM+YNCo1dKOdYSIBIDXrAoGATqUtKtQTLxn1u9rGRpj9atfm7WiuEM6A3r06O4ZWjvYgd3Ju0TFFU4216QI8jm3TH8biiEMC/Gp9Vw5dbqRDNWWMWmPXq2qL7OHzmQ9LpOf1Q1rdyjXlWn2HdGUMSRf8d7opEs6vl5m3p7GGG7eCbnvA6FW9buSfg4z93LEnDrUCgYBNxymg6Mgnrw4XMDhPS0RR8NE1j1AWm3bhaMNrcgRnOCtmNcT5GGdUX626DJOk5xx7whfg6Ee4qb7Zj4hcVOSunOyjIOv5RRsWFC1Gw34n/WiyMdJF0afXZJKSRV31BZ4OP0R4EfVVLcfzKuScZKuxtuKjn6/2UVRfwjWAbz5WWA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDXo5iqDYnxNP3h40X+0fAw8b3bCEfYdtzrYCV6huKegNzxPkySFTh+9y6fcfi8Y9HYH4RkovmHqavlWlE999IreLQOzvsRVJ2pzOaSLURid2KjLO5hSi9CZTRPOMF70OGh/k2Egh7Y1buYVbDKGrgB+aHm76xxI03MQpvzhINtxrVlgzU4ErYEOZDFNXaccSH1UOfATb3FnAtD/3rhqldMZn9sAyULThoDYi1x7WxgX8j+DLx29cwOyoBBFtwS7/AmI0p3rYN3Y6otBNv0ycGnfg6dcnMdMDS+OcxBzqZph3o3ICKXtfI2+cP7zWl1QRBkblQdbHOYo8qevdw3wr4XAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmeHPhtUcxVo6eVciRKbDpS4x2KAGgsiyxA9Cim3k9gFzn", + "privKey": "CAASqQkwggSlAgEAAoIBAQCnch4Vp835CUp+5RNhMUbtgg5N37Ejekcd15fbmZkjSeCUjoE0dY6Lu4WN1z/z+F6V8TYd3ql4Nvx1qp9eB1urcJ0WXKQ/o/4dZ+iZqbonPAxyBl2OEzqQ2csbAiSkrio0ciSylMNAIF2Wv18gRwHw9YZWa+sOM55HNPiLK/qav2HEvaSUfypjWrwdRhrYOho0+pRrcHoU/neI8mFUkQQDMvArnWpeaN/dgPDsyO6RRaXyyi3A0ULK6FFjMyiwZEqQBQlRdrc61lC2o7b4ySpzfgzk0j1zwROSjZaUfH5IJn1FZVgAl9Z+S8nLgTvV/xrBjABee1gYsD0DVFleEgUrAgMBAAECggEBAIsRTkcyDPFOdB6b5tKL+Jp9r5+hrx8GCVaRnj/2e6dBTlJTYJ/PGsqWvb8mDKl1mCj0IrwAF8QN9vNK9/1CIzJp3y2ZV5i7fOuzRw2IV2EKkFOLUdwTwEpZeERALWrQc6EHQ89FmjwCJXh0DG9kSgp0AFR6YMh0unntVpdPuV0XSfxI1cEKoBRjcXweewxXNmQc3a4BTI8n860sr83jF2f3aoMihVnOCPDTk7NPDF3OUI5lXV6xUCpbAtdN7u/aG1st3exS34cLl8lMk/a9+s7GMBwBseJiBzENkF4i6cEkz2c/oR2VMvFd7nnIDGcgqWHM93ghQMYa7NBaljr809ECgYEA0/5ju1fU7Rwn6+5Sov90I4zgIhS1b/CfYow055U2s12RX5iAzhW4etYIX8lNFj+lHQMj6zHSdWJXtGxxSrqBQXLkOmWrfc9ZvG1aonYhMAasydNRcsajr5WYkfWbS1FgnUo6vBeOBdGzFi7yUYtgLooNigdg0Ob7m4HBEUQRPnUCgYEAyjRlGGbyHoEixo2Zpg6zMaYCVquB65P1kIJXDVpQAjz6pI035/VUsiF/HIfPkKfQ/IokuR5qCIfFN++OwCSFDub1lttikUJFakgeCgGlLVuu8VCc3IeQbPT3pSxqF/BHngWcvykTq7aNzz1yJiY//TjAucLthdVOYu/eyRYpAR8CgYEApWac76Wmtt059KV8ijpfpgEbOtwHd/A4mw4jlPBhvm5ppzl4fdKKniRyYjHQWGSN8eXqV24G85koLthRSGndwW/fzARZWg62yAJWLd2XJT5///RFXxTGz48be/4yDQDQLcilrO1/3OBxJwS4AZGKGKWTzLbW/gbKFtmVBmCiR6UCgYANSqxqkjnQL4TtsFktRUIaPWNh9xwvNCasPSUjx5AC1adUMcQ/By1uGC2W3oaSZ7WhJCON16X4sZQRPToQ/1WPyTbTl9A+5DBT8DGpTrpg5On3CumExZSE1QWCYg0HTdAnXw8SscyNOQ7RVKSwRUtnhdeFXn7mkUL51fK7HS3M2QKBgQCD8OOaClhJNMSvkHInrcKImhl96p+VgCw8GMoLxPHV8MnUGwuNYNWWatmoLQps8OavZTMWgqnbjusvBJMFlKSZ93ULaUnMaLFekwePiaPlLnE7DCpmBjlKbryLzBgrdOLW0R7PwFW88fDJ2q1IqZZmD01U6LnyfF+tRhj5ysdY5w==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCnch4Vp835CUp+5RNhMUbtgg5N37Ejekcd15fbmZkjSeCUjoE0dY6Lu4WN1z/z+F6V8TYd3ql4Nvx1qp9eB1urcJ0WXKQ/o/4dZ+iZqbonPAxyBl2OEzqQ2csbAiSkrio0ciSylMNAIF2Wv18gRwHw9YZWa+sOM55HNPiLK/qav2HEvaSUfypjWrwdRhrYOho0+pRrcHoU/neI8mFUkQQDMvArnWpeaN/dgPDsyO6RRaXyyi3A0ULK6FFjMyiwZEqQBQlRdrc61lC2o7b4ySpzfgzk0j1zwROSjZaUfH5IJn1FZVgAl9Z+S8nLgTvV/xrBjABee1gYsD0DVFleEgUrAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmTd3oibLxr8XKqj7DDKcm28a6bqnMLJu4tc4xf8yAm5xJ", + "privKey": "CAASqAkwggSkAgEAAoIBAQDYsSTm+HDwoD4Th72iDePNdWl/RMPTFPLX4Uj1GmY/4l5B776+pSYGcY16Ak8rlBURz4NIntiqQcW31eTMdRKusDCgBqNzY3as4qFtsTig7D8baqFYwoswSj8awe4y1Cq6N6R1/w54r9pEap1RzA1+MPof5+WjGA972h4BQaXoE5xdidm2PJxyk1ZTK9hKqZI33JII1JQ2Zdr3VQzMeH2Mh50U+OsJU0rtGNUqSOkvfCy67a0pNJHssGeKUWI77go1t7gWy5F9s85zGEJKd5J6lh1bpam3cDX0hX+jfxKtwHut/kCtEEGxBSxO6n7EHHhdLJylP26skd+YhAk1VfHdAgMBAAECggEBALsZgV55B7OM+OyOGPvy+E4v4e6E5ny8qs4h9IfFyqHAiFhwdIdSO5n2tAy0L73V97dQMPAkT7n6XojUA+FR+NaixOl3sevw5shySqZXDilMs1St5jCokdwZT5F//3cd4OK3JqbHmqw0UsceM0YsZT4fdejUp2ACZ2QuOhgloeXWaPKb+CcukkQywFa/mtCkbpD8yjUMmaTXg6Roq6tBcr2qk90ICgHxp9qG3udkWRFd0FWoWxXNKn8AuxeJix14S7LBSgfzDck311M41wNOb/wMzy2Z4tWerxlhd9YZ564fC7+xudAxN6KcNlN7D0Sy7jckfjRSI2015a0uPZ62lqECgYEA/zozaRWhlk6Q51Dr0hHcm9EJpktAqhGcbd8BvztoMKIJJhcPa0bmWaKDvOV00F8n/Ps9c7AsoD8iSyfl9Hhznjn1QXEiuwXJ4wyYmby8a2wWCs0JggMrSgdoZiOtqGhFem1Dkmy9mLvy5pZK6w7CzeiRu22Xecc9aVH7pEQPYAUCgYEA2VkUJpdfkUS8cLZK0hBANxWB/poTAkp1H6T1ECPYNRHGRskpoZcPWKVfFdMgIBSkU32nIL1D95zY0LzAjK47SwVzOfhUsmt+FTTZ+YFseWeqNUNuA0Uid9ARJW0weFPPK4yJLmO9v6C9c7fZFllob+ajcS+MKYpE7VVeDO2Z6fkCgYBslWxN5uAKPH61it3pT6QVvodmclmegUOWEuyBWVroZeeShvkOYOmbdOKrOMvL4s/2d0UbtPYnbvS+GMliiuRVir7nCqUGAF519GPv9DYNVbzC95x17bc7FY+69K7rGQGGJno7D3xSQJQEuihBfNQwGiP2I5fwPW3JIxH2PuZzqQKBgAQ9383NAHl2TPMqK5Wj6Yzpp4rPePV/fH+smXfCK1MF0MfK3zwfFZaWS5/CagsWPArBFgTmjLAFaJnSRTO5psCVD6We+hAtVt2VFXfwFazc4A6ADWKU89JAxkTjt6FxiUaBTKASJD7cJTZf7SWpgwdECgaIdgTNhQDYvKgl7u4JAoGBAOKu34WNvGDTX9BB+NeMQjrmkjVCnaoqRsg7yurUhzUlTbMNA3S2o3ZoUrbXUh2quYZlTDAqQjKpeCOLMpZn63fIA7Z0Pp/wfTry+QFL8cPs+4q0d+SJXFI7s/DcgUgVIbndtGDKSeougb1VNx7v4FILW+/tqUqcN3oEblmnFjuI", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDYsSTm+HDwoD4Th72iDePNdWl/RMPTFPLX4Uj1GmY/4l5B776+pSYGcY16Ak8rlBURz4NIntiqQcW31eTMdRKusDCgBqNzY3as4qFtsTig7D8baqFYwoswSj8awe4y1Cq6N6R1/w54r9pEap1RzA1+MPof5+WjGA972h4BQaXoE5xdidm2PJxyk1ZTK9hKqZI33JII1JQ2Zdr3VQzMeH2Mh50U+OsJU0rtGNUqSOkvfCy67a0pNJHssGeKUWI77go1t7gWy5F9s85zGEJKd5J6lh1bpam3cDX0hX+jfxKtwHut/kCtEEGxBSxO6n7EHHhdLJylP26skd+YhAk1VfHdAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmNNQLdERMKBZNs2kPd7ejWVVYLpBwb8UMqAYUNSQVE6p7", + "privKey": "CAASpgkwggSiAgEAAoIBAQDF0/EXsnhPXtfFZVyibJ0t0g11Z/0D8DXgQYriyYOhYWlBho562/Ga0ETEcwoyuY8mtsJ/8//3gAURAcsyfYgx5R0AFC+HV+ar0Ft+fNhxO2QStYF6lB2fYc9bFnxJ+fT/4ZS9BKao5ioGIRNA/zVCk9alc/dhQIA2Lj5rwYBw151ucKwuMNpLg/mh4qcsLLCEaJ5BITxTaKlpHguWn1b93nhmp4Th52mZUv6yHKD/G4gf9W4Kb/GJEYYb1a6ctw7h4Z0HTE/unesgWCROd8crzDx6X1HRKnR7wbudulfBNJXUtBKJUlabe30i+LNXEPwAGJQ2e8cAkKbDWslZZtdFAgMBAAECggEAEcOnaaZYEWCF5a7lc5xnPN8Y4EsXOExQujOIgjbwQAScTAsGLlgjyPAczLs71jQ9e497xbumZ5YyXkWX9o+5NCnLwd8OKYwmJZWPMbuKQBjCMr/jwZsdUduZoCdTv9zXOEcMcTDCunX4nhZIQVTpdnIKG09fjncZTEQ4zLpSi09YqjfVBfxACUrMhmcpERSAGam1UB7bBEze0Ddv+l9HZyRXW0+1elX5YFpRXW4VaaXjtDI4jZx3iGUsimvcIlWRiOxOzPCE4Plp/thQQ0EAo+8DcU3RKCoHoX9UnbEwr7mRxE24en2JQGX/R6z9nialaQHAmIXtI4Nkqb/SZL/FgQKBgQD6IZ7qOqrHGdwwDYHngxU8hPotcFD5nbmS84t7VIuIJ/lmbvFreFtEjV0DZMgEMlDlctivurRVKltwLrOsV9Fpt1+VVwpvleMhjwHNLldP64PBsKfhB6wgTQLxK5dAgNbMM4NOUUan/IzIro9xio6vXewNRVVczd5tpH8uQe9/5QKBgQDKeCrsSP17kkbrgEtemcE6ONw8n2PDuaW67jtWMX4W2pqeiFjuNuSuO5ttERAbLi0EoqzqKszUql8LSUr2TE4Ya7jPII/AARtnM7X+OrzPmm5aJhmk/QiJ4ff9KpZZuUlSLtmlBRsi0DUlZWRJA4aJuSKVMrnaPGrJqo9jCczD4QKBgCS6QRJVkPPxOSKZKSTsW3bqc62uW0V7wl7wgd+XF3HjpLxEuBA2uPgE5c50wuXS2YwHZAfRm18R/CEpyloY/vfN5CwSfsbJtHMeA360Oj/S7iLHpK7nKIAJrs/ovanMAT40pigeyQgrjiR9dTSPysm3OcztDE63L9zblY0eQ2N9AoGAOfwaRttMhSRKXU27yBb+qL76C/6V4sr7NMLfiXrZIpBusbJYzbg429FEXQMC+tXJnMc+AD5LtSgp2iCecFVAFGxdXCx2HsXyZCcCGxIVWtteeUDqHT8+P8bQb9fPgVi4L+os+L6ym9DHN7OG+gYhdLXpupLxeRfOeXz4XaPD2eECgYBvLlpviAeCe0ZpcNEu/7LHogxfE7q0ijHY6gJUXFcFVlHmRUFdqpM63XzVEzzfTBJ3CWIHVwybwPQJF5CIaloOXP6Ac0MTY2x7mJ+rIqnqF2qgY8vf8I2beM3a+A7zJGiERtiIYXQV1jzcgnT/FI8rcq8/v2jSB3U3kzd7P6JLSA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDF0/EXsnhPXtfFZVyibJ0t0g11Z/0D8DXgQYriyYOhYWlBho562/Ga0ETEcwoyuY8mtsJ/8//3gAURAcsyfYgx5R0AFC+HV+ar0Ft+fNhxO2QStYF6lB2fYc9bFnxJ+fT/4ZS9BKao5ioGIRNA/zVCk9alc/dhQIA2Lj5rwYBw151ucKwuMNpLg/mh4qcsLLCEaJ5BITxTaKlpHguWn1b93nhmp4Th52mZUv6yHKD/G4gf9W4Kb/GJEYYb1a6ctw7h4Z0HTE/unesgWCROd8crzDx6X1HRKnR7wbudulfBNJXUtBKJUlabe30i+LNXEPwAGJQ2e8cAkKbDWslZZtdFAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbhNX2z766ycmLDP8awr5BLB2FbqX8FyvUt6fBLRRWsjH", + "privKey": "CAASpwkwggSjAgEAAoIBAQCgRIZTcbtfOQI4aEpjVgyVx6+hR5z0TurjppSOv3p6e/Q5uBcXHBx0LjP7bLW93oAcgwMAPZwXBHOHIXq//XtBdzIAYDzUUztfCk76AXTWr5MR3jafXqf5lwyu5XLKSa9PiZHDwSEQDY05N4WeCS3AMyprcu1Z4ey5W3nGMy/ClPicyLPhCgyWONhk+ig4bVNfByP8AUcTHAzN2hgfhY9t6f5aqvXodybvG440GMt9kMH5sSYdZrqPL3Ixpmz7mOxkfbc6gaXh0M/pTD+q/f5JTrYZ7NbF0jdrLWcx/wAgJA9iLyrHG93ObDvn1L41k5H5l+QBqTNQzfz9mnv1Sx8xAgMBAAECggEAORiwkkHOcxooRFhDSCh7y1CcrWSJ8i+7Vucdvc1RoRlP5NBEyaLmMC3VrxkHlmESWxYBl7BbT4fycI3o4UU5CBWi5qdihHIykKVnhYHHUkSyrIbyBsz+ItlBV32+63pczoVAPPEtCj8JtPymyaqTdgnEbws+q+rlHxQLyiSqOzOu/eJJKFBaW9/C6Trh7EOxEwZYfIoHQuihb/zdrZtlsU36yotKxckaZSv44IXTv5cGT3vO3U3s/t0rPH8MJdz1wONr7iowqEdUp5GZivFg1VwUJoHvutBjIj/eiJGebQ/jlKBOg4HltjbHf3YAniK7Dty435eTRaQvIfS0zgZ7kQKBgQDSyytoU8ssoIP/CyIwbRGpQfnqHPeUcBXXntS3P/gbXV77iDdvQz3YCI0wmbDPzMVxynWbQuquPZVxhKInj58SF6DW9qHV7AuDScVY2fK37YbrEg9UdIX0WJAYbtiLeA3ejZ8BqOUeh3zNPrvx3z+QLiDIEFXU3iIigsIxFIUZYwKBgQDCo2r03ArJMeaCgD5i0U4ZAD5Dy6AAeYke2mS1L3NHGjIFlFNGmcc7LvChGGzCv0fktFzZTbD1reY0f3eF+JKz3DjhprUQRdsWKdSxnFagJmUjujal7BJvhBYg1oiqRAVXmGQXtVgylDU8VKdK3dAoBYkufcEoiG5P3VogTkBTWwKBgGm1CvqRcsTZZfgjPCzutTmc5Vfa2OkuYDW159RRlvkaFMSspaf9H2lTuIITwJAkjysmLV4D664fIe9AZRTTuCCZisXh/nxJl+hpuTZ6bXaA/fSqJNfkazyCoRgvlhYyyTm+6WsqqGNr7FD80cFUhAqopzXMw04xawrFad60/J4jAoGAIpQbvVKWS/YkiIy2CKI8qK5lYW/8hfkRhjywZYv/g+NAfcNDJCjPv1DwiP4o3FRVNmlgkW5/ALabTjpTBqcJkRCPvm76feCbMo3N7pviu+L2VumPKd0NzWf+8miKsQ0SkeRN6/RYreuspYI4klFj2KhbHbpTpZrPVjrx9wlP3j8CgYEAnz/M0t8/PcYvjwRS5Naned4gEMLFIPkwJdkQnqAVw6W0s2ajeUTEcCRYKT6fVUqyAj3unH9R1k7YT0kzjFLNypYuQjVbQJtVOSHnssbulKKlWcs9dwW3NUTxvf6XdOP+6ywZodwGLSZpQJqMpwEvS/qN7uHlkAQY0gPGLtOC0MI=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCgRIZTcbtfOQI4aEpjVgyVx6+hR5z0TurjppSOv3p6e/Q5uBcXHBx0LjP7bLW93oAcgwMAPZwXBHOHIXq//XtBdzIAYDzUUztfCk76AXTWr5MR3jafXqf5lwyu5XLKSa9PiZHDwSEQDY05N4WeCS3AMyprcu1Z4ey5W3nGMy/ClPicyLPhCgyWONhk+ig4bVNfByP8AUcTHAzN2hgfhY9t6f5aqvXodybvG440GMt9kMH5sSYdZrqPL3Ixpmz7mOxkfbc6gaXh0M/pTD+q/f5JTrYZ7NbF0jdrLWcx/wAgJA9iLyrHG93ObDvn1L41k5H5l+QBqTNQzfz9mnv1Sx8xAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmUQUxKeaJrVqEp89fpG38FKJKh8sFpyehCKosevfnE9bJ", + "privKey": "CAASqAkwggSkAgEAAoIBAQCdIzV6DUcwSmKGhCT1a2vs2zlhDs/0I0JR0OGTaNgDYeFHGM6Hw1a3QBoxvP+odOncCOkCbGLIEMfj4Yca9RkDvuF64wZWqx/tVQYvXJ5MYx25gfB2XQq5FMXxqaASP66FZN15kc8i8Gkzxt9Ff+My4vk7ve0QzXokSOcn46LAjyGU1D+abAS5RnAyBwsTEoXiWl2yTR7iunKEwbtJBIuCKtCYThRnbvTmr3wX4Ywn8twbJEjg+esR+MTrGerv7dqPtbB6/q8QPh0CCT26yRTpzOjielqqYs8ZOTBwe/+a2Wjnjr+PG6zPWZM1xl4DtxmTImsLUqRe3+48NFhLv3h/AgMBAAECggEAJ3V0804sRzMWpKLASSSNeG/ga7/1dl/4QmVKj+KvA8JreJgBHNRvjRq6uSy1ok6hfxB5upMPByA3ocC7VYignHEtW9dwewkDvmwwXmpKkfH9v9yiToa0r59IyZOHz61QHM0kVGfJ9QMb19WjsWcY3Wljnp3lzudaOYxZB4pBD0s9LzrSfiJ2HI1skgxIeMLtU1vvVhz3KUYar/xCjfuqqeVP2RKcDNbnlECokndpzVhqyQCHvcdNitpkkGmG7cwTHReVlZnrFcZeoH4pPKRdebZAxBZXg7jtHNBwZK+8X4hVxZgVRE9b5q1RQvFl75q43aB+CgiXg1cvmaG1tZCxAQKBgQDJk3YH3+G5PnAxXO0tejc+hY3mobFyNv5LYtx+fnY1Osu5rmy4iz2XVaA0xlegQwhxjPHDTd/ePVDAOaAANLa+iFT4Sv+dwlBNICfIXtM6eNhDjECY4kfZ6SDS6CsLEGsTV9d33ybq1vSlrYYWeGbShURIzpGKbTSKDynjgbPrgQKBgQDHkD84Mi4DwJiIuuxPesf9BHQw+F4dycDZ7ZkZed19aH1pWk9J+sqlDuLOvpGeCq52av1rK/t+Zn3vBvgJgs9upHq7zx+NgX0uvjr4V1i1Nxu23N++DBuhFRD9HcnyS+rOXjRVmoK3NId2YxwBZ0629NVBssP4fBqxdZ5uo/Vj/wKBgQCR9DjpWL0bIU+hHnUJkc3AcnmdvgQ6/ADC2xFmcfDrd+gdSWOleASfuDspG1hFTWQmu/QuAwwO4fy/QrpMi96qNRK5Oay+MP1t6tODbM2rL+b/eeUoDegSq4+9xqer+jZdqiP0wtpt/jjkYbGOQZ3J3v7jbNbLEWmScYpWFgsNgQKBgQCMGL/I+7FCARsUIeVzhoaPIWlQV4v67X/tfddVAzByscAZDcVL8jwA1Ap1iWNAx87iYwm1CxNrERinjQTj6GknC2D+J9HGzXjML8/GN8uWrDFQlo6cJHPhCaD7kMYMyy7z4T5sOiQ56S6P9dPbSGMCHa74iD77WmSC4Edw9Ll4kQKBgDGjPA5lIztQGNDZwdadsf34AQtN1k+JYziBj++alVdk57CT26Il7w0X/qPLtEzqigZgjWW6EfFV7f/qKpSjl/jcpzJFeUC1/mwOfTYa9HoX10gV7knHZP/vKL6+Q8woHE8rjUPswirX9jxU1N5iYlaIBkGbfDbrIBO2GbGQW91H", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCdIzV6DUcwSmKGhCT1a2vs2zlhDs/0I0JR0OGTaNgDYeFHGM6Hw1a3QBoxvP+odOncCOkCbGLIEMfj4Yca9RkDvuF64wZWqx/tVQYvXJ5MYx25gfB2XQq5FMXxqaASP66FZN15kc8i8Gkzxt9Ff+My4vk7ve0QzXokSOcn46LAjyGU1D+abAS5RnAyBwsTEoXiWl2yTR7iunKEwbtJBIuCKtCYThRnbvTmr3wX4Ywn8twbJEjg+esR+MTrGerv7dqPtbB6/q8QPh0CCT26yRTpzOjielqqYs8ZOTBwe/+a2Wjnjr+PG6zPWZM1xl4DtxmTImsLUqRe3+48NFhLv3h/AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmT3LdBHJFQUcNfCD4u4ecknh28k31EkrCBAnaSRg7ngXc", + "privKey": "CAASpwkwggSjAgEAAoIBAQC9YSjJQC8rMGegKO9Wn2sZnJt/BVDAv/druvl2uB6mgKc7GBLQNyTOw2DFsktbovXDMSMhYx9FvRa2rAShGzzeWmO9HnyXqu5mzL7r6oVhtb5FTHG9j6PetN1HJEiUuI7xSEjh54DI9GWfsnwhML3PXT1+TsDaz2BTBoNWW5NLKFZCqitIxMHWk8R1ooBz0gicqvRv50isfrIDAL9teiBNcfbUNSiXJ3F8ueq3NPuUKCVaCPoFrCsNlK0h4qGEV0jb50f0CkK4sKzeDcg/UD/S+jGrkNDAaA3f7cuks7JeVuL/gJpCaRQlBBjG4lt/FK0bmrPSm2AOL5wOUdGGUgbZAgMBAAECggEBAKJ9wykq0U4VclSRywpgLt0C6sjKHsfD7t+YxoN+542lxdeGiF3vcr2WFmqK2O3/nS+l8aasDiEgZWTHpBE39bozhHC4v97C41uBQi/aQifccS20scMchFaKiXKJR12UHdIZW6+5m17RlIC5/Jfd4n8SWbkOiZs1ZEjYxchLOs64i02bumZuj8NT8OMFEyfR7fl4TG08HSToCUvRNyGAz8T7p/fy64/Z2lw+xP24XCW/YHe1gD5Bu/QmOys1mrkT14w8SUhIDW1z/Lr1+mnfe78prPRxe0Z7BR2aidHVAu7h65LS0XuFvi9uOl3qrzTrrLTwXyTmUhJuqN5YnJVej6ECgYEA5mmujbZ+n9qKuOq6GVkSf00LqmUd8oVbEcI/d3lT/u/omapmKPrfPzz+VFrh0S7I8rCYlLUmoDnkBNGzF68llt0g3cYTIO8MnW3iySbiCv+mTCYCfzlCxPX4N+zW6Az1ofCds1SDMAZL3qZEowwy2iresS8KmEqj3gUYKgiFNcsCgYEA0mj1K0YdPZ59klb7PZAScIeScT3rH7xnRGH+2tNMQcDW/W8H6GXhqZJBrqH5Fs9y6Ndyi3dWQiQiEvuBIT0uaiMa9UkFDhhyz05uIajBqBpJY4JJAu67whUL3ng9uFhHF875wSsygxvJMNuTf9pgThyibKvq2l8O6gJfFMx0QWsCgYBKIxD+Gg0uJCRkkWolw8o22bR6NCTpps0Brs27BHfpXIor/271mpsAfwCaZc+o/fO8WuQNXSg7f8UFY+/LHBjtLONpWFVJUIFvmi7RaEhtH4sDj2tYQjVgqIAghn0zlw/l9kTXscawSiZZUohdKgymtAqJWkh/bezCAEOhKrKp9wKBgEYgy04QAWDvOSUULoq3QR4WYX2yyHH8ZmLJUpr2f90Oe9leL0GK62qMH64nuBCdNcxbOoc3UB2dU2oGP2SnspeXeb21B6VKCsIDfvti9qCjmkA7RUBf915Zi2oro06UxaUuy9lRH3XJRgYtuPyM+TovmwcjSZRcyGjAP5Z8CmdfAoGAUBDcDoxjm4qn21HCt0Kb83fxhyd0KAeCZx1DkA8ENu+sGaq0Var+iXdJwIzH84HfPzNVRylSfis6p3tkKtuhiVLxE5aNauPPD5oKwf5/nr06CgiMG8ENz7vdih0LilThK/cSGm9M57oITBkrw6fTEMSqt/18dRuvH7hD2Arr0l4=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9YSjJQC8rMGegKO9Wn2sZnJt/BVDAv/druvl2uB6mgKc7GBLQNyTOw2DFsktbovXDMSMhYx9FvRa2rAShGzzeWmO9HnyXqu5mzL7r6oVhtb5FTHG9j6PetN1HJEiUuI7xSEjh54DI9GWfsnwhML3PXT1+TsDaz2BTBoNWW5NLKFZCqitIxMHWk8R1ooBz0gicqvRv50isfrIDAL9teiBNcfbUNSiXJ3F8ueq3NPuUKCVaCPoFrCsNlK0h4qGEV0jb50f0CkK4sKzeDcg/UD/S+jGrkNDAaA3f7cuks7JeVuL/gJpCaRQlBBjG4lt/FK0bmrPSm2AOL5wOUdGGUgbZAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSeTfyubWsRZRcVczDxzBxhDJBgj7MhgHYbwv7zU3ib4c", + "privKey": "CAASqAkwggSkAgEAAoIBAQCwZ/HZRcMVjQ88dKCc5YnKARHUGBLt4sj1vCVofk6fotl5qojz/pNN+lCKtxi8nmVt4GQDVQC/xl/uB3iHfFkc6qho1XzaaRxI8XaBSJV9z3BOEGmrXBkISluDnJAXhfaPquZJZUhWoXjO9H+54G0Sd5sXeLDlzXSUGt9tMGE8tWggthN3TWR0G3jKw8oacoQZKOzJneuksyf+RZGeIY85THzaT8tBBCF3s/TPK0SkLbHyy/Yet8Y+8FSyz2sQPLLpeCRKnIZ+opxvtE7M7/mwD6NXVJ155eNLrFLBQOWOYU2bI451YQXCErJP98JwYeKqaYCETIw+jWY0ekc47edLAgMBAAECggEAYHnYmN1AXg7xYDzggi4+900ydO5dm+BFy68EPmulkES9735GvDpkUWcumU6dprpx+m+YAwKAEGHroQBQ+LgW/GuRgxQO3lxR7cqw5u/NYisK3oa3Y9JQlmokNoxveY34VIZAv682qrpQmc658+w7ergTB/knteZxdXZk7xBgfZRINv65p9ArT0rvsEOk3Ff6uq8g++zXN711b9xFMBmxJT1haHGT7fX7JuyUExCSqTElXjSMFykk40zOxjMzDQpzjxcSihffhTRyhScIjpru372BrCmL1WCeDrvN8pEV5DIJoYhgvjGLI1RuPGaGwqIGiR+OwXjX2kcyRgkXnVPPkQKBgQDbjljw1em8741Mkq8N+W/voAJZ59O7bUALSaxjrU8Hpljgd6uu3MI9YVTGp4gjI63XIHo5mKlONXDyer047E/58KNNjl8v/eyLLDUi/9lERzD6TPBsRspwgs172Yljm3UpmiWDfveiu+7/qVbrSK6b+4V4aAnRH7kSyUU29qSgrQKBgQDNsAM4qw+48wEscGWbqM+PlUOwVHhpzyo42gM8y1xtYhRC9oaYeUVpUPwXzS419apreart6KC/AFt/2mBh75pEBk/Vp9Z5l9a13yJV4xdTnDxRAUh+Zywqb6mCTqWFBnqeoPDFKZBcYBDqkgYkCuHLMjYZcebP9EC66yIcJBeO1wKBgA9kzKGeLfQ8S4jp4/Iz4gBIFMIe+f5zK4FfGgInHZpotGSQn230Nn49O8dt6aKlFsQ1l7xAEubT4mZt6qR6FSVuFNUUPWJNCG+9msAodiBOaYWzLUw6LmlzElszpmlgdfeDwkuU9GHpkVlFkz2N7Agtu270xHNwKPbDO+Idqu9FAoGBAIgZ0Hfd0QB7YyppkQJH2FfU175ElozE9NY7g+rlUVpbjLamc3dOv1wppzWEofA4hzSohC76P+tCrEjUUfRb3ALo/kiMz0ET9JHRfOHB6zx64/ph0/s3/6Rw0IQV0DZOjDKMoeSEVS6arnbYetG8lZ2jsuJxWN3/bBmC3sYqJ6BvAoGBAJT5hMfOTN+y2+DbT0o3E+bCbGGVJaQA7BBD53xoyvO414/weVqJ6JexW6hYAiTJ/VeA4Pbs7nvxZB9Ych9jj98Gmm07LRs59YcuICxsy7IidFwvUyTV9i8dFxmc02kXTqJZXihwNbPz/bKCO8DpMRPjk7Q5cT1uocsfZyEwyguY", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCwZ/HZRcMVjQ88dKCc5YnKARHUGBLt4sj1vCVofk6fotl5qojz/pNN+lCKtxi8nmVt4GQDVQC/xl/uB3iHfFkc6qho1XzaaRxI8XaBSJV9z3BOEGmrXBkISluDnJAXhfaPquZJZUhWoXjO9H+54G0Sd5sXeLDlzXSUGt9tMGE8tWggthN3TWR0G3jKw8oacoQZKOzJneuksyf+RZGeIY85THzaT8tBBCF3s/TPK0SkLbHyy/Yet8Y+8FSyz2sQPLLpeCRKnIZ+opxvtE7M7/mwD6NXVJ155eNLrFLBQOWOYU2bI451YQXCErJP98JwYeKqaYCETIw+jWY0ekc47edLAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmV3Gf2G79yWWGLnKQHuDuRTQZbvbnhb6NSKg6yGTKdibp", + "privKey": "CAASqAkwggSkAgEAAoIBAQC2qI/XfXskB0F8LzOEQS9Yx25lkj5thj+ddMMsOsKV5IDfFNKyd/t8T6LhC90Jhxsfm6BpN3cSSuR7i9pHBVHdoPB2n1LSTyHYi95ZzAm3SRy6SA6G3n+kXtQHaTgqZy38qEQozAeLUOoDFU4SGW0ai1cv14TojXnsPNphim3DwHRceouOmWkaIA7zRCdgNkB6Wfx9D5AVw5RravHrSsdn+jaBAXLjCqa0zoLJWPuvKlRD948JHyTG4ozvC260arxvqOtSlBDixnbaKAnycna7j6Xme2gJ7/t/cDSbWtBJGOYczst5u2W0zxfpqLeT+//BPoz5qhjyTrz1EHQTPm2RAgMBAAECggEBAIhjxUR7BgAZCuTXuff/VINOJzjgwoy1ubqw/SuBlNqoDTKGMe3heX+RV2YDncEHiVFIu7bVG6wlEAbQnuR5LG/5RJTO0uEHBZbUmesjV/3sMe9G7tH2QglSZbBC+RVwhf4rBvoPn3J/sL0so2cQZU90zF2E6FFdkrS7m7VJ0Dxhq4wAl8Qveda8hwvi2FAiTLL+8l2sf457pt2XF+jXH7qb+3uC7YuFCGKohPXK6jmsNPlvMZC/LIvyUNV4unla13t9VrUl5BPwUaPd6UI0MwiSDVwwPRK0m/pQVw46CKQNiX2lGoWFKyJjqa/OFtkKQ8g7CD/jPpbTiUl5JzCwYCECgYEA8dRJEmvrHZZiUGxwCxWc64BXVvDqOmakFxNUjxITGb5X4X5tWEYmGODEEoxmujfVbM9+xE43I2AaeowKBZssm8ebi0+rIP/SZJcMHXLUfDOj31BF2TJ7r6mAQBQ3nBPY0NpW0aOja6oQiGznxe2tPcPW4jKkKXvE2WSUfHXTIAMCgYEAwVyloXRV1UvLpnXegmQn7vWDZJI4WW9eJ2BicRP7E2RviRMo4JMAqDzUdANxu4UxQScxoVcWuZHPVC1NlDGdH76VoQi+tBKObc8vcPR6K0MM2Tgu+xf6pLthp/LlpcztJeZHeGD0nAxB3cWIc+SowM4UAVnbzMIRW9EWuisrWdsCgYBcwTDZ2PzQV2sUL9N13O9YQNy/Ix6kEdRkaWyoh6U93Y01l1l3X0ijiCqMdr+8M0gwORIFV368mdLuKCJ77f3ZLmGRuJgJyzW2kVz7Op0XmnMDZ3WzDjL0uI3Rhi+iNNaXnPdp51r6I7u9qA/qEfS92Qzlq8jdhHSHcZWme0bkYwKBgHFNWniK9Kixazm1I5cAHS42irFpxL8TNPaZ0dU0whCQ75JAudkuClqKmmsIgaJB36Sv1LMXludR+0z15tmJYOpzALaFq0lU/kR1/PSRLO0gsuytsUnMuT/B1O1WtR48QFHO594v4eV2gTn0P4q5V/DyUGKiRttqdEV69XhNR2+1AoGBAMgpdNgV3hogNUHJqPvT/MuGo5O74NK8xp6j0FrBlZUlE+8JSB8pxI6IREBifOkDZ+cy7Lebi1REPwZ5QVVtzRpKppgKJO0ybd3XFI2iEBMebDQMMZP/7Lq8KO/FHrNgiQGQfhnf4vBZWwj4ZHcI8+UeXcctTSwRYFqsFl3Vbyif", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC2qI/XfXskB0F8LzOEQS9Yx25lkj5thj+ddMMsOsKV5IDfFNKyd/t8T6LhC90Jhxsfm6BpN3cSSuR7i9pHBVHdoPB2n1LSTyHYi95ZzAm3SRy6SA6G3n+kXtQHaTgqZy38qEQozAeLUOoDFU4SGW0ai1cv14TojXnsPNphim3DwHRceouOmWkaIA7zRCdgNkB6Wfx9D5AVw5RravHrSsdn+jaBAXLjCqa0zoLJWPuvKlRD948JHyTG4ozvC260arxvqOtSlBDixnbaKAnycna7j6Xme2gJ7/t/cDSbWtBJGOYczst5u2W0zxfpqLeT+//BPoz5qhjyTrz1EHQTPm2RAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmeecBL9V5NybZhaKKMcSxQCaH553JCup6uf1oqhQziL1F", + "privKey": "CAASqgkwggSmAgEAAoIBAQDVHmqxlszl0nTg0jJTgt+7ubcx8TSwn1UGdvgkcb6Wi05UkcW1qqUBOaeQR1P3xe0rCLRHEdWBmG/Ap2GgOXh2xqZYFfb/LUU5+B3BKVIFpUk4WyK1T7BYWr10zDeWxbi6VGAOk4n5bZ+DGSjA8utJpIAVeQyePSJkKfrs33pes2cR6keshYbDuKk1cXROVaUacEoHTL9iSly4LBJ7bWaG14g4tPGBOATiRtkB6ABkdgO12aq5CwuzgUlfdhfQqzaIdwn8/tw0WAg4A1/MyFq8XAl6S4LwWcM0FL3qJZeZggpQ7CMJYjXyt1mAjGG99d4jDNl2npayWPorr1eGeIhDAgMBAAECggEBAKtOWsbLB4JIq+g3LXrRPRQBkQ7U6tx6Bnc+0/E/eMo7ycfSsNB5DU8xz836d7U3ZI9t3LMv06XrKRD7uk53Q6x9uyIc7cBp3DZfiVNF6oddN8DUCM8i8gXjUlx69sf7wKQNxHSTBZn4EvrnE0odOSGl18rq1UiwrV9EG02hyRQquktPlmABrp+WRP/eAcvq9ZKTyVlpoZnmL17MhdGarA1O3abGIsbbXpGC3n0jAzleG3fkaXO4nAWwQxBScfIV/wf3JAbyG+4sSYBhSDvCIjGjecBdFvBUjjvWoedO8enL69V09DI/PPfeC7RZMmGhySqIyG1hRexALYsE262n5ykCgYEA+313sml/E7mrCEjvSb1okAGb8F7rEVSh0HjsMuw9C1hmDmYba20a6Yew3j65GRuAYgyfGaG9ftPHwXqPuf0dzCnQtf6Pk1DwuoPLaciAqFl9f+jOCaMmzpOgMWC/QWlZ5cnpx2x/VkF9ssCEgPNP3jEPkR3k+BHKEvE7xobWxoUCgYEA2PDLqVREUGxByfex/c8yz4xf/eb6exy6p0p7CUJWIbYtgSmVRhUORfG0EMHONbZrvZMgt325WQA5eKbKm2eozIUKNnnjS1EViYDUQ0yQrckGZiH7ZlUZL+cL+d0pMlrBzkMsvsNBdJ/lThRdeM+ksEykGVkwLahqbYwcTbvqQicCgYEAmf9rg3msUiTYgXs/4/SzCbOijJ9i7DrZ13GkmU4l10OrQtftpGusFiJ8AKuB5sj7ZY77AdQT2IzQfj6Rsj83tuRIJJmby4a90kiQD9eySOR7wA6L1ETup4KojnQCyYg8f0ST/gUHOIdj9EiFGv1jA9khAii/I9So286SXvAEpo0CgYEA0PJMFpF1IsjCLNcHdmBkngakRhZ8Vqt7E7nm+yoLb3jaJzd38QJCtxdvyVwBUzaaWwMkVdcf+BsBP7XWGwwiRqo1Bfcr9tToG4Ib754FE301TpWYYB3CnqK4pDZhgYBsfk+w/yNtHfkLkMKIrN3Bz5Rh0ZBXmQJHT6/Nawl9Pa0CgYEAsyT3mt0dbXyOGK/qdHj/BQBt4FpPN2g8EVtT2sWWjZhWNnsNN3ITHeMG7GC+2ewzW365WXQnfmBOaWLL3yUnA4weRnaQWiwHVhcy1TH2ezR/lQ7ihwMbxwmlS/6O6Bmlmvh4DsjntJ+vZjxbGTC9pd3e4t7b0fhGJVR5lL0wLZE=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDVHmqxlszl0nTg0jJTgt+7ubcx8TSwn1UGdvgkcb6Wi05UkcW1qqUBOaeQR1P3xe0rCLRHEdWBmG/Ap2GgOXh2xqZYFfb/LUU5+B3BKVIFpUk4WyK1T7BYWr10zDeWxbi6VGAOk4n5bZ+DGSjA8utJpIAVeQyePSJkKfrs33pes2cR6keshYbDuKk1cXROVaUacEoHTL9iSly4LBJ7bWaG14g4tPGBOATiRtkB6ABkdgO12aq5CwuzgUlfdhfQqzaIdwn8/tw0WAg4A1/MyFq8XAl6S4LwWcM0FL3qJZeZggpQ7CMJYjXyt1mAjGG99d4jDNl2npayWPorr1eGeIhDAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbcRvn1ZcdqsPsrGqM6sgJRcskAKratagpVLXF96hP9Dt", + "privKey": "CAASpwkwggSjAgEAAoIBAQCtymwBl1Fp6mEyF5tcv6qvHoCLgDDREbFB1IrkYBDk88FMfpYIJ5WA02pN+hZ2S6BoA+uNBAgae3m+zfsSav1QRzyJJUoAYcZ9XMiGkFKAJyGV0FFsKP98I6ic31yaoSd78iROxei+lhkXy7dvfR4z1maVW2HjhW6mMF6Qz9i/zdc3txq8fOkJvb66l+H2RJz846Mz6h7OrNmdRP1ZkH31+Rllc8/itwqM0nsoG0iKq3CrMHwflr66Byt9cLfdEBvElGmHFt+eshq8ShtRjVRIEW/yGORra/h1y/G8WhUwLoL8UpgNkIqE7B0Rw7Zy+KmbfaNEcFQhZeLm8lvkW6gHAgMBAAECggEAckzisj0yV4XGPSrXjK2mdZyLELTT5n1LZq+CVed01RAYPtY2mNBn/J2Pmg90fIMK0b5aSpmvNrOlA7/3dEqXphfkEZNL02p7IHJIlHARQqX56c1j784bEitltx8UicKZ9GPySzjQ9aBEiqj6UUIp/g/x0iOTAw/8ESNY3sdEmAiUdc/rBjbG1qRC8gi8QOsMqu81zh0qh5hp5chQucgWFzeMfYyNmjg8Pohx1GhG7os2XMUxzaBnI0Y4G9oVAObWPqYOwUHZTOQYd5faj+k8h/QcuTVtBLXvLjjmwwoSaqBbc9diorx55Jo2lg3tyoAU8i5FX6FmUjjC2xAyvMUhYQKBgQDiKiDnjnC6Gkq7UeiqiRzC1OeeBTqXBDcV2kBcDOEy9f4gApZJz/FjZ57WALWRAE6VM5Rd2ktai8s3fyZ99yIwqHfeWa0KdVTmKk8KyijOfxB6KPfajS0cEA8LRtrxsHo82a+Xc5hytl3MiLMH0DF1ALwcQCgMFXVGJ8E608Gy8QKBgQDEt49pjZNrhnRUDnBy3NXzxDGWhquJEbg42+6ZLI91k6HvOr7Pl0KZsDZGKYdlgKUuJFB3agQGzKx7ZWyRXaLZ6CWodMIXvH68ffmylsbMBAxOVpDU+Oa3jJ8rGvWi2CcsqR7SPSTLSPIWTigQ4vJaAKMDnflWSQld3nGpEXUadwKBgQDhvJTtKkIfrsBqqX2mQYagfKrWEXgCZaWpvRbCCeT43YkRYCOrds8Dndhu13RiT0EgMMRkzM6riJ6EPPgpgHLyyCQknbNWnffoZ9BO/6qtOSw0EhIZZRHiUbECW22LEM9hTxGxBCLkVFvZG5Q+NzI2C062j96o+P390Q5P7i4GsQKBgDu9v1j//PhXsfZhGDdZ58QLHkAnj+qlrfvelvx/suWzOyeLAK3MsxY3lJQEQrFJu2Bi+Oj7ElP6Tpt+9tTCyhVBUkZxhwxsW1TlMTLSZXdJ927HDV8QZAj0NNaDbnvRBzyh89FHbmgqNBMgEzzln1JEBT2w+SsCLU0LpBsDSTwLAoGAfteotaR33Qchy3Z5vgIMzY0txZ7vU3sGErxjiSNdmv0Yp/dxHWeGv/jvHm57BV+9iyANDicjrzNH2XtOX13lmYlctgAHRkCLVEdHxw+f0xXMto+unep4fniX78CDNUQAfvmBl9etJMmGXYNsISANxZPgHeMgi+EkMjAj9tdRUic=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtymwBl1Fp6mEyF5tcv6qvHoCLgDDREbFB1IrkYBDk88FMfpYIJ5WA02pN+hZ2S6BoA+uNBAgae3m+zfsSav1QRzyJJUoAYcZ9XMiGkFKAJyGV0FFsKP98I6ic31yaoSd78iROxei+lhkXy7dvfR4z1maVW2HjhW6mMF6Qz9i/zdc3txq8fOkJvb66l+H2RJz846Mz6h7OrNmdRP1ZkH31+Rllc8/itwqM0nsoG0iKq3CrMHwflr66Byt9cLfdEBvElGmHFt+eshq8ShtRjVRIEW/yGORra/h1y/G8WhUwLoL8UpgNkIqE7B0Rw7Zy+KmbfaNEcFQhZeLm8lvkW6gHAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmfV6NS1ah83o84zMPfo9hCHgZ52X12QJsfixvfc9gw6v1", + "privKey": "CAASpwkwggSjAgEAAoIBAQCrRsmO5XAh6ObYK8t6BTU07TxuJvwttZJ+3OgTI0Ek/dyLztxEKY+/HXd3WLEb2uzvLHVDnvY3y2GFdtE5hFygF8vGtj+bz+fU8ax0kIMLNhyOlb8rv7twgp9syK/4PI10DS2LOAPNyUI5EHH68E+rlZwG/AftCVBp5lLCq7wxad6h0VizeoX/RzPXNxWpf4NiNUlbwAA/EH7rOUgZO3YWkTVHTehAmnJjQW0ZOfHFBQ2WTdhKQkLJCzFKt9466N01OdphW1F7JhVCqFK2SQZysHR3dohrsIGEu1TMOUFMenxeq8OMqzwqO+u8iFmxATygdqM5pC4nKOTevFYjWhvxAgMBAAECggEAHvC/soeyFP4czYpDzLwqG3CLzR5PyfYWC8LeTa69svAFKmBpHAsiA5VQIogsHmsTCDXQzTFnKzcbW9/V9fz6OpVx42jC3uPU7nvl+nysn5bb28ojacTOGIoQQLeUSlSt/PvwcUjiLwefZe2ZmYpV6hoxwHVA/UoEc8z+wFoDui0pEVdGYTvsKSKGfAkD/ZAIl4qDbSgTJhkh3OxEONlecBdocdwRdbqJJijpSN1snInKKFbXwvPfGAdRhezNe7wtVdWcUCHdvMsZuHyiHwrqd84J+Q1f+cLMloDVEyz5RwxlWhsCcFDs7AA15VyMErpCv2O/vaSphmt3z2Dumr+xEQKBgQDfcdTNBP5o0mvqkMUR9ODWEfC4JgZSRvG3cuHkPiUkJAVa1SH81d9mlqS5fzF2e2fUB8C+Qa9ZlqzBAA/S8Oia3D7T1SvAG9Iu+N1o6nrgY+BwfFGQfkJs5jp3bBa8qjVntcA0SeOipO/q9F5iaFK+2WvZa7vC2XOe3R36Z45KpQKBgQDEOyiOLcwRphATycwIRveAtqyZLKd81kYBRLOneEbhUpRRbxyPXstq7WngeaXCn8ZhfhiBgZCjs37Gf8GuQNyUNrVlF0OShplzegbiMRErmXkHe2g9CHbUm3IEwGxJmfOub1nIwCUCAbyp19/lcEnd/N+woEuaLnDUjSkHpZqmXQKBgQClyL578zWTrnQVUJ53KTpcemkhKE1OZIbZdqp1f0ptWzCB6VrTThf39NN5Mg8P+pXZsnrmbrPcg7ffZt1WxBnBNKKE50gTvFChO1KDkl3i+RfAPe0CiTtdsyA0FQV1q8/+B9L4uM3lkfzUVcVlvEOQiJ7FbXKdKlvnxeWFMapYZQKBgF01pIv0oQx5DwX3Qt1jqEkRfGa92UjpFxOfKJ8R+Mkqypzr5GsNoh5Ga5Ze8ifCcR76IHXTr3qy1jM/mCZHVP9qBTvhkw1Utist+XsTx44oNl8hdWAYVymiNMShCk7ju+ZNqh47dti/LniWvBll/xBc/3wMiBzSlnHAI48oUI9ZAoGAKRycRjjgIZrrqeTA8fJ7iR0MB8faqDrP81LD0ykEdu4spF1cw0fKb7rLWAMxYzrbIQkbaYMGQLDIVzGlga4xS2YNvDwcu6YKg89DtpAsW1dHs10rIgkb71ryaD380qtg/ZOCkzR6HVgtRumndDZkZb4b92t3DxlqBGa595DyVjk=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrRsmO5XAh6ObYK8t6BTU07TxuJvwttZJ+3OgTI0Ek/dyLztxEKY+/HXd3WLEb2uzvLHVDnvY3y2GFdtE5hFygF8vGtj+bz+fU8ax0kIMLNhyOlb8rv7twgp9syK/4PI10DS2LOAPNyUI5EHH68E+rlZwG/AftCVBp5lLCq7wxad6h0VizeoX/RzPXNxWpf4NiNUlbwAA/EH7rOUgZO3YWkTVHTehAmnJjQW0ZOfHFBQ2WTdhKQkLJCzFKt9466N01OdphW1F7JhVCqFK2SQZysHR3dohrsIGEu1TMOUFMenxeq8OMqzwqO+u8iFmxATygdqM5pC4nKOTevFYjWhvxAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmVjmfRFrzBbhAUNQ45RcTik47MJe26933z8EHosgVEsu4", + "privKey": "CAASpgkwggSiAgEAAoIBAQDCIO8WRwEqMJeuKKCtZrpj9UPtmeLVLo5V0u83sklprjxHD7hG35/YzeFJzECApslKNMExJVb0dw2n8TZYHaCiBB+MJQjjyite3OebAlDVmqRGKIFtbz6AAwsQY8f5TViDKzSIjsOKPYPQz9prAAmZ2Ah/vhlI/azfSyi2Mxu0zhbxtw3txtpUXy3VPkSa4pLeGgpBr+oeitQxeBmrWVDkVoKeH9Po86QDuUTIVRiRNYraCbxawomnlYgNEEqWIhspw4LAicvGjLd3fIP6XM5WtRHGfTWzf2A+DCAzMQ9E5E3wXWS4OHISx2Dz37FLdYdn2W1A28/u9NJAu5281xFxAgMBAAECggEAIOsGv8dQij/tKIoZHO5DgvmvCBZFIZMgbas0B0TDMBlsfTxMKjB3YYMfxazN70LY9S1W6SeExDV/6k97wJtdhrueQdxx0naQvihFWcKdxGrRmlf6An2PopNhh+jzmvGjpbJo2RMkU0e1F253ghdiiWTZpBevH/JsIv0SrTqjYxgXo7EQAspYQ6eMwbk9G/cRjoSoKqOxQKBfNPLj4gE7ZbD07S30th2udB2qOiB1r0j7hRR/UuLkbrcRqgLFN+yeCU0nw08BVpThoFDWRF4xiQMqOWjvEIkomPp2WO0b2z6QFfrYqvYbE7kMYU1U7/TFPxYAY1evUcdFBg4bAI6DQQKBgQDmwrfLSWvPS9rwUSYaZP+PbGWikDf1BdNU0xRK9Z3P2rWzxx/jxmrkvRKJYaYoQui7pQKPc5OKcmTqvOOBDnvF2PyTnv/0QLC8n5ifDAW4/bVmS8MLHODsSp6ek9HzIumnvsHoRb47gZTc71YUrwTDNXbjSZVqV4VP2qomqzFmCQKBgQDXXIX1iytD1xvDHnWUfonaDs5ODBiFeriPn/LF9WbKhkSsJPTiGrFepO9tD2gnNOwEKmhyjirMB9fk0Lq1Ds5k1/6WejuSyvCADnO32DzqqDQj/a8HbKpEcoQ2YLPvCwChhyo5zudD3On+6DubJzdyrOh7m0Rmhn2Q4YP/y75qKQKBgCNAxAtOYCX/FKd5/jQyEci7apt3JNVN2ocu5/67nyxN4Uxhs0F84n+nUtmiDVxBPITOJKH9qiCQcVJbIPZqXAZRq+RxefC6oUVvrEU/9O/Z8oh6MoXUF5iBndHkC0L1pnR18/GkFffJSBCoj6IBStz3of3/E9B3JmqYoT3fEWDhAoGAGhagN62DMTWmrE1NSw7FHkA656N5ePnzz5o9q5Ndv1zihsP3UkiPgfqS8nAyWsWDbcHBY1crggnVMmfCplpD0F2F/q6R9udUmP6nL/cm8fosTsvVXx3fxmjk8T1nrqZzjh20lMomo8boJbP2PIZUpjSh+Q9HCvBx15IqDludFnkCgYBWDyb6zJmWYA6f96e3+qAX8XO9MPUkQXCIGvZZllg3hladYgcy/GEi17hWenXPIIB014ldAuYbttclh1dAQYBWhxxLofVnGXnGlHuzkB1YxPucSvfzJeRusyPMbYiIY7V2OQBN2abtbnau+FJUnLKKUFGQdoSZsOxNYAPbCh+B3Q==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCIO8WRwEqMJeuKKCtZrpj9UPtmeLVLo5V0u83sklprjxHD7hG35/YzeFJzECApslKNMExJVb0dw2n8TZYHaCiBB+MJQjjyite3OebAlDVmqRGKIFtbz6AAwsQY8f5TViDKzSIjsOKPYPQz9prAAmZ2Ah/vhlI/azfSyi2Mxu0zhbxtw3txtpUXy3VPkSa4pLeGgpBr+oeitQxeBmrWVDkVoKeH9Po86QDuUTIVRiRNYraCbxawomnlYgNEEqWIhspw4LAicvGjLd3fIP6XM5WtRHGfTWzf2A+DCAzMQ9E5E3wXWS4OHISx2Dz37FLdYdn2W1A28/u9NJAu5281xFxAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmWbAeXxuHTEppG9BRP1mw9gYj8ZCHT7RMowEUeQfhYks6", + "privKey": "CAASpwkwggSjAgEAAoIBAQDRAiJ40gZZKj4v6a2lvxnVrmNT7DSjC++V5C+lHnAhlGg6jmH/FBHOfrdjXitqjgkoSj6mcugO1onNOm/yBf4f97J8iSRkNFkuuaTr6b/80FTWfhX73zjM5w+TezQfPzIVxZdi4KIzsJ925BjamZvtksqGurY2Ng2fjzMhCvTPTsqYWn0gyhSNvJYGy5LdGHQm7e72RN5cD5pCpjyrpA07UWo4D7go9OycHqyVxFmz9zQlZOUrx9CsWPCnH2LWdX4H3FOOsi9F46uW4fAN1g75BXIiWkRS21NEkmNBhdOmCY5YThUjT3WcSJoainCa2W07rriezft9dIJo91F+AyEFAgMBAAECggEAfU/XVTMvJTSjllx3hWGfXrMw0HdVU9BrNCZcvpYSSr/NAhauAJ6K0pC86THju/4u1V42U9ue8I6GjmqUBbq8E3SSKgKbtAyCz/X0QJGkTzKlOvjbu2ipiIicmSMMLBPatp0CWAEwnuctpL27fQ0OJRGWpdK6PqSH5HuZ/xyvjL6uVZLYoQBpvFK3vQS/x7iWkGRLJGAEN7OsiicvdPa7OavQF724M9m8yZ/iLoytmI+pBopyHwSYyNQoz8uXr1rGD/gTLIcbi7BBsbOAT7C1UNtaZlhaZkM19aM9ngz6UxgZo7GYe8erfhR28UT55vWbWvXlAvDZU0FL2zLcb92U/QKBgQDtoVFT0z3smS2onuPAEQORHLptS7owGv9FJcAvCYIpjefvk4NBUA8G8uE9X95q/a5y4tnjcjQqgWPsBEM9oEso7moqY2vjVcMNYljH4mkcP8tDAPjvYq1gfEfzh0rFbzO70MY9IfX+5ESBZbuQcXKeTBgd+f2U45HQowSNBMuLlwKBgQDhKmTBr9djZrvDpudoY3whdIXfx54p5ONZqwj6HpVqNMpKD+nEpcR6CpkcRRD9fKLtZ8LRWMvD8iAyRm7tvezYn10zXIBTnuXSnrLumA15mmZUQXZiSKNm8tcGetCWw86yUDV8CpmY33WDHrtmlTRdr45DzetJf0sKWZ276hQ7wwKBgQDXbNiCys2nsZI//JNyKrp2Eno73VwUglULRdb9jXwv2dL7UVq7mi2VWhiyADht/D7rLhbj6EO8iQKiE5c1xhx9Je6fMPS86qHif1cHFo29q2PFAZurwWR2RRUhhHRXmqFm0jT1dNVDV4N3X1fz8bU8JrXybxDhqpEleLQGd+NjTwKBgCmbOc8IfRZjD2MR3kTNzUwpSeuV6UX4g4I4NopxSE69vnt9AUdTEkEy4CP3JzKP61NPDxK8A7sLbKOdnDXWGIPWvtQUzaml/PW0WX/5HNRRkYMULZnvrjIBwXXzD8QsHm+YnqlzE/rJn99AuIQ2Id0F6ZXh4Q5NtUIOWTU2BdMdAoGAZUfXHiQW13yWkYQ1HMoy5clhqmfvTjf2xENJddudBGwU1+1X6Q2rJZpgfXVJ3yJepSetuVPghDfNIXT8Pcgn7LyMhPxZhb8RD5naafImDS+WjM6oxSw1vAouzKa5LaOzEkjylg+Abi3wC/kE6b+ncbzmGP7k0pfZMAME9lQHfvU=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDRAiJ40gZZKj4v6a2lvxnVrmNT7DSjC++V5C+lHnAhlGg6jmH/FBHOfrdjXitqjgkoSj6mcugO1onNOm/yBf4f97J8iSRkNFkuuaTr6b/80FTWfhX73zjM5w+TezQfPzIVxZdi4KIzsJ925BjamZvtksqGurY2Ng2fjzMhCvTPTsqYWn0gyhSNvJYGy5LdGHQm7e72RN5cD5pCpjyrpA07UWo4D7go9OycHqyVxFmz9zQlZOUrx9CsWPCnH2LWdX4H3FOOsi9F46uW4fAN1g75BXIiWkRS21NEkmNBhdOmCY5YThUjT3WcSJoainCa2W07rriezft9dIJo91F+AyEFAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmQT3xZJ34uwg2aqbSp5nGbo22g9dk6FurgmKV1kFqyjht", + "privKey": "CAASqQkwggSlAgEAAoIBAQDXWSE7zuoPE9GKt/qJazpxZZC9R9qYRpDQvQI8nLNbcmnGnpryPo7jYxoxe6rB0Vpgj6FTvpxDBLAdEq9uuqJq7QWhRdbzi4KZfRTqMdT06QlYNNbkVH6vy9hFaUwJQSa37FYaXNtrc1eL6AS9MU+rU+W0fDo7GFzRsz8m2616RHR9z19CWayYc6yv0+zECyP9GDSASvL6lnQvU36sqpZZiMgbIjDPwBJmpLTDZTz8Tp6CJzZjqq4RkVEWU/E98hJ506FylvwftHT5ufZxLHZRhr0MsLpn5QGeGMnbEEvMCzpUBBMzW29Bz5lbzNwdAh5B5pIXSRS/YUWCY678M0VDAgMBAAECggEBAJkveteLka3WADm4M8zq7PDbOcGbSmEF2V/TA7NQGLnVQm8aRchKPeR8i5ZljQtAPBTyNuVWctutiwWzU/3lX0HGhzm4b3ZhaC587pLFjeIFnzMSq0ZS4Kd2zspZY9A1ezBcOseYBDGEI+OO0Ugvuqd6D616rQV6iBRXeHXQ0K9mkb/1+JGg6p7i0uw0BC3t4+At8SCvZCNiqiq2t/kYfGVJ3fzt5ZY6jWiF2q6C5petc944BYHxCGrUUHwR4d58Z+2fN+mX4fHSquJlyqRUhyH+1auS5/gLzne60YH8BBTAMWSzn0GqGzLKWZdwt/ERax8LUZcl50Dw8rO2NxaT8fkCgYEA/BX3ZzMP7ICvB60a/uUxk9QamhHt+zpK9oOH5yklc2SxmgcyRMoLEIwNiclggc74iIkVKd/68HcPTi3uZiinASJOBW2ID5iLll9Sm9aJrVj50ilX63bqcP/RBVGvGDnZiJlXoM28DmUOJ9PtLq2RhHSeddB7d6ZNBUfQYmrlZe8CgYEA2rEh4oDDfHOpuibuuFdlHuVM0ytkxDSQUlTbdqeZ3RSfdUCFmgOhbVtqXliQnG75S8MipSmTjqR7SGMs1bEXb6C0N4TCmNpRH194/ejrVBAw10KE9KO3ks0GwpgC3ZsOPGnDrk5EF2OUwiwHl4EPPRQOkwpUe92GS/GUZgEpie0CgYEA2kKOpezBIc09PpEzqXR523uu2K0jdvy+wPebKJsokOOjHjCS5ppkwBvy8NTJ2TqBV34RM+N42tDLEK6WFh+mkUXJdcujHZW/bh/0X3d+VveNvdgMBpQ8YkAsEsXpqzkTTsEt7M2UwIXgnr1QQ7UGJD/wnyM2c58qWqMWGtBg9EMCgYAdvD3+PUHXVya5z/dfi0qNk+IJSHowD3GcMDuS+6D5JYe0+qvv0BSP+QESiPpIuvIcshCw4mFU4Np+cjWzbJviKri2X8/R1sV2/ZVG+Peee4EYk8veM7CPPl9v8BlbpmyeHEdmGPA7OegNKs1xdTPsOyDsL1hjazCKfPOPlxLd1QKBgQCUeBVAqy52rJQJqBSeBo+ULjdxWbSvIatU9A/RTcs5s/Zk+T7wOohFfShrthmw13uLVIok3XkNB8QLkxgJ8YBYm1d4tS2pKL7X3qa1QQfJWykiGZY0Dd5jk9biPCBUfzohYCNmkLIM0FdDjwTDS0inzxslRowOTrYMJHAi+PmfGg==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDXWSE7zuoPE9GKt/qJazpxZZC9R9qYRpDQvQI8nLNbcmnGnpryPo7jYxoxe6rB0Vpgj6FTvpxDBLAdEq9uuqJq7QWhRdbzi4KZfRTqMdT06QlYNNbkVH6vy9hFaUwJQSa37FYaXNtrc1eL6AS9MU+rU+W0fDo7GFzRsz8m2616RHR9z19CWayYc6yv0+zECyP9GDSASvL6lnQvU36sqpZZiMgbIjDPwBJmpLTDZTz8Tp6CJzZjqq4RkVEWU/E98hJ506FylvwftHT5ufZxLHZRhr0MsLpn5QGeGMnbEEvMCzpUBBMzW29Bz5lbzNwdAh5B5pIXSRS/YUWCY678M0VDAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmdwBFu8NAZDKRvr5N5CJNYbQkAqt83MM2CkpHCuRk5ZW4", + "privKey": "CAASpwkwggSjAgEAAoIBAQDF3whIIfICn+U5ciRAqEsU1dFlv5HRVIQlrQHbNh6ev1YtV9l2we6zYcY5HafE1CBISgyKQgI7SYww5mDH/468m1pFPgMDfjCYpFQETVx4V6uB/CqAuQbxXP+QSgSJPEim2aL3UBwoAB48nKhPFRTcePfmli4TLsA3HxmEqdlu+tE/GZNOcQzjaersffCCP8OVLdKecBPxq67tEjw1UZVaJzlhGx8OE4K0aYwgGsL+1l+/EwoUqSrwsaTBpIUtWsXKUVB2kATJmxvQG0oVMtRGMll7C/zFNDHbA5P80ieL+owfOkKVeWuAl25cqx8tshMG4ead/P4OcyO1clivPkPPAgMBAAECggEAXfYgR6ie9LIbNuFF59JC/Rzf99I1m1LoAcAbHo6fkcDIWnXaFXPYNySZ7atwbJ5SyiEnvUvFJYQyZ1Iu6SopDNU006az5ae5yfJW10gpPhhboDkvsbqrWlhQH6OWbdjLoze8FHbdN/1+XkgCALPBGUT0a3IrZP6RVluVUZMaZoEsLSpWLZE3LCs+eKnMw96EmA2WIlgXj3na62pTgKC29OG5yXKV30FI4TAuh5JsSZEASu5D/rrvvZwjKQYkLl5BOexMVtvM2qkQv6E9T8xk49z4ffmL+GBEKvqRVlLZXuoLJL82sr4pbXKRUKreliZiSN6Kg1eCUFyEwrIsYqUnyQKBgQDxf1jyykVjXjeKQdlFE2GA0UY6A3G8p9GFz06OpoT73aTFOva4AEYP95Vzvj/bHX8wBU1821HJ/4gBnIATx7GRr1YACZKp4PMdm2pSOuev6w1LNvaor/jGijs221YCsIR7WHUk+gRhlPL12PcInu1aNmgOxjBwX1ApHz97LcNbZQKBgQDRwP+ikLp1bi1YpaO+rSLpK/HxXTTdB5a0WtT0AVojh4sPj4Fi2g0/YyYLZ1m1xqlS4kvfuN5v0XxJDZbGGpQ9KSR5hXXzM0yZaE8rld9X6gn7LqNPFQp8msCtmzHVTDo4ogeo9I/YgqeVBhEhPB1BG6/zSSTxtnvZ4OhJvpHhIwKBgB1rljp9ydZBNCLzwrRXmBlJZXTL1p9VEoFqr/dQ8gJ9DgW5GTVxUxe+4cYn9z+KaGRBQR9k2KHzL26C0leWjFtjMObwQ53Oec+xj1JVOsSDrirrl0EVrwkA7hXQwrmxJ3KfZCYND1uT+cVZmT7DncbPuf2Sx3PpKKrZ07H98T7BAoGBAKqs35YZLA/HshBS39WUrjaLcphSnmRH+4IP8v4FZ6JHdYkY3VBhW6w7ckaPNzkpSLhPuSt3E1BrZjVPYGMcV4kYxDw5s8tL78VYUiuGDTFNGAgSYAJGfbz8c1IQWVFVcH6Koa8CKVYkolYplKC1eJx0+gv9dZlVQpv8XSc8cRl/AoGAZXbLSJ3ulzrJqQYZSlBJA75VikpJG20qEgvipc2wYjLs9MKLyad9vkLVhsPYrYDPzbIG2JquZziF7qjtWOFsW1epgb/DsSRG0sC0yrwjGH6cWmCkL79coYLO0PE0yrIlm+H/BA6dinIOLp18wJd+qyYcjesRCLB5Z4C9nnvRfAg=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDF3whIIfICn+U5ciRAqEsU1dFlv5HRVIQlrQHbNh6ev1YtV9l2we6zYcY5HafE1CBISgyKQgI7SYww5mDH/468m1pFPgMDfjCYpFQETVx4V6uB/CqAuQbxXP+QSgSJPEim2aL3UBwoAB48nKhPFRTcePfmli4TLsA3HxmEqdlu+tE/GZNOcQzjaersffCCP8OVLdKecBPxq67tEjw1UZVaJzlhGx8OE4K0aYwgGsL+1l+/EwoUqSrwsaTBpIUtWsXKUVB2kATJmxvQG0oVMtRGMll7C/zFNDHbA5P80ieL+owfOkKVeWuAl25cqx8tshMG4ead/P4OcyO1clivPkPPAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmQdkfy5Cz8AHXfRr22NNo9s6xUtzD5CfZMeP3H5WSaw8d", + "privKey": "CAASpgkwggSiAgEAAoIBAQDNsZvWO6HtI285SOv//ynnZfnVNEluC/to5NffooIqcxiIxaeDR2gXVPxQpG/nkfK7YddqCqfWYM33i+Ng92zZAw0XjtBDcevpyqO6u4i9wF4avI3QTDuf+VRqjvOATQQeivCYnHFAdTbWLbgZ+dpanjQMBoW5r5+XfTZV+WGFwOtys0ATjr20RDiYS4qUrUWs6ougnIzqnohcoCkIDolkmsjZOfjR5OhrTUlSWopt1w6I1mhjXwLa0Rc4fBAVzzZbfDDMCcw7x9aj0lh4hpOXYo0vRiDbdNOOMfAHSlnc4/ikan+yvXJuHIXR8Ru5ObWN2lx1ijTb1E0WRz1ekENjAgMBAAECggEAaLmvxRBRbiInY7wb5Beu5xCFdaaMaEoTc6Fnw4XCzggRirlPg0hc19w+JnTCQN2O/xZeja/lKgHZe9quJtVyhr7F8KOWp3AeE8dHOzB1+14wy14Kue3GQbm44BPuJ/mOSlqlCp5EDvReugdG/3q1UIPRrfm4JgUjtQZcHsO8glL/82ev1TSft/eiEGN+zRzEPJwBlYiymeeI8y/u7BrwxH5nK0F0C1R5Ef4goGG68R0zfcAI/1WJ7JlhljaT0I5G68f+NBqahfb0yDctio3o26Fvfii7LlbzdpsxJxpy94VPsfZmY+JS4IEwdkgU/OvFNMKq4MBoRSnersjecG9nMQKBgQDuwYVNpSwh/oXV4Rpqk74ijW7dsNxfwTEKpj9r2z8/YcyHsE+RrTMP4oY+bXUYyuEErEtbnQ9M43Vx+ixakEplaawdRKqAeNC6uZLlPnzjUPO7LU4+IGi+RkcaB0lUCpl7DhSA2PwDD59yJAXywEj6+8A39mrDYzcM7m/CgOHeCQKBgQDcjMj8a9mPNRHWIQygbL93gdbqltW2HVPYBkz1hQ6YBOIwi1p/9vjHyD2okgClr7IoUCMN8hfBTgV6HPV1zXATDlDc4OybN/59333doKaXMrSNb6wO5jXUUNHdVxBnslOE54vEgjWxygHKrpT3yR0HA1CYZebmCfi+TjDp5XwxCwKBgGgDaNaNua9Jmfa2bXK20KNu6DiuXyNcH8ha6tBLIL+1FIycc92sDc3CyucRem0FnYgSo3XS86J0iWrRKVd++to5ciECFCGKAK0IQYWbdn71emk18JtCNT+HkFw3hmuVfo3McYQ8g3W17amlJe4+dMzatj/rG1HpvEbm7UtYKI45AoGASKm5rjB6RUxezAWne1NY4a7NeAyp7I5NCWdKA7oKzNsPCp9e+boMzQWUCu3PeMciE1YTtoyEdxOVil3wIRfGTQDyc1NHoPwZxK7VcSd0u2vhQJgCQAZoxcK64gnFReTiz27aBaxAtIqxfG14dwqznZPiAdPQ9wliApEQXH9XI3ECgYA0kRZ26i/Qq935wFtGRmoADDH8q2zcGcl16p08SUPzf3dEH1eT/BXkDWMd7IXZrWIk5Bq/vMKf2yIMlHpek6Nz/pZ9llyByAyxGggC+7ZO5PDq4QHWc+WcqDFpyGnHzvPlEMr3nxpfu617fI3GNFUCueyEAJzXOalRkpduODSAJQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDNsZvWO6HtI285SOv//ynnZfnVNEluC/to5NffooIqcxiIxaeDR2gXVPxQpG/nkfK7YddqCqfWYM33i+Ng92zZAw0XjtBDcevpyqO6u4i9wF4avI3QTDuf+VRqjvOATQQeivCYnHFAdTbWLbgZ+dpanjQMBoW5r5+XfTZV+WGFwOtys0ATjr20RDiYS4qUrUWs6ougnIzqnohcoCkIDolkmsjZOfjR5OhrTUlSWopt1w6I1mhjXwLa0Rc4fBAVzzZbfDDMCcw7x9aj0lh4hpOXYo0vRiDbdNOOMfAHSlnc4/ikan+yvXJuHIXR8Ru5ObWN2lx1ijTb1E0WRz1ekENjAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmQ8D7hnLCMEXe9adEwjugWgKeZbDzjX3oUUzQYKbQ6CpC", + "privKey": "CAASpwkwggSjAgEAAoIBAQDSiEBozfLjRVvHlCP8OasiVQ3OLiyGhnm0jkgntuEgaErDvkMtKOSe5WS9PzUhN0n42WB/TGtYLsk6fsfmhL+sfD/GV4boOJTdieuXmL0cwdLUoFXkdbTUXeorhVmuTzhV+7TRKgZBOzf3qNL4L4he/dqFrdfsgZ4jXX0QjTcGpUcFoDm65lfYvoWAnPu5EWcqcwRFLXaHF+//AQOtnxMYv/BU255pdit2eaOOrKVLzAQYWRmCYRNTEOcU00Lr1QgGyJJ7f+Hyv7Y9WbTInj0SOxm4bz/cDZa05Z9Sl4MT7mkD3ixpnFAyQVRkdc4mZbbWbuH3vjdWuoVd9iFNbxhXAgMBAAECggEAEH7qhQu1/0a89TtPQoEGPq9pYIFPrc61lIcdcjcrFo31ZbbvrocouqaAqS9dq1eYrS3jGLZVJtirnbC3WwGFvy8RFCphgKqGR4F5+yvVjX5GVbCmajsqywT8xyIwr663XE1Xkpf3W38XWIla1mVrCv5a8+R2KarSSDUYCob2C8gdBiE+dj4O5t/SkfUYrpetcOSa3ifXM3Ctig9X6mKDxT28MoOGAHMeqNtXiAJQFJqLzp8FAW+k9ATCMqlkSkY60FPMr2BsqmBktHr7rO3AvL1WG1dTLRY+eVuBYTMGvqFkLYSqM71id6QWxTE2RYX/7xvgoOFpWJ84sElJQN4V4QKBgQD0NH6p6tZB4XhKlZfmy+VpviGjfgawt2nOvD+iwMbjn2EYelR8TwxWqKSpL033nryE2OGiLn1tGpEAtqTUV0is9FBWnCZeITfNNs1gVhtGXNXBbDb8+3P7fidV52YOKCi/hWbAuQdu+wbHAxdPri0unrV7Jt3oq5BXotd00dZgsQKBgQDcs2egfVRHX+Gz0ygMHikMAHtEbEhBu/Gu2+mcqetFklJ1IWJdewY3tyX4qPZHoRB5QdGFXSEzEyxiO+b+YCz7E1YiFtTmvRZ9DFjF61YP3Dp6afYHh9bMigzepXPD6CBBmle6PUo88hp5xhMxAoCMWaJh17RGZCT6dK1ttYKLhwKBgQCS5wFLNfmtp/S06Uh3jjBza+zQbP+ZTrxXoOanAVCjnTzLfMtV/Ddv6gMjw1EjpFnDkLQq28yX1WNlCnodQmR1poKtl0F9Xn4y9MSXLzU5Hp93u6FYjes3XqxLAOhjm8TncVhelu/h0yBAl5tuU1jasp55dugHDy3FijASFijgAQKBgHK7uYWPYf7w847emRUjoMcigPKjMDUsFYqHvLy7ARpb5Q4LWu2qBSN1zQGmJNI8AypmcxvXvGim8Q3ogj9/lCK6fK6gG/IQHt7HSmcp3sXEAYqeB08G6T3QDry4WqRfylUQfcbOEgf4/JaNyHBUEqvj9SzUTF3Dtg2WForQL5uFAoGAZAg1h6sim7bNBOLV09JTucuTHndWAe7N31yUqVIGWqxiyZWcSx4AL6fcy9PhwGXv5Zo9ylZ+HaOYWrPAtFt/6F32tBvylpgjU7LX8DEg+95AgSA5rPGvxwm8yVnWnb8r9FWE208ZhUKrorDTun9LKOCRZ5fngguan9wapxTGiDI=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDSiEBozfLjRVvHlCP8OasiVQ3OLiyGhnm0jkgntuEgaErDvkMtKOSe5WS9PzUhN0n42WB/TGtYLsk6fsfmhL+sfD/GV4boOJTdieuXmL0cwdLUoFXkdbTUXeorhVmuTzhV+7TRKgZBOzf3qNL4L4he/dqFrdfsgZ4jXX0QjTcGpUcFoDm65lfYvoWAnPu5EWcqcwRFLXaHF+//AQOtnxMYv/BU255pdit2eaOOrKVLzAQYWRmCYRNTEOcU00Lr1QgGyJJ7f+Hyv7Y9WbTInj0SOxm4bz/cDZa05Z9Sl4MT7mkD3ixpnFAyQVRkdc4mZbbWbuH3vjdWuoVd9iFNbxhXAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmYKfrXc9w7FKvcQSL1YsBejuuN5PBZKaYuSe3wYge1KUq", + "privKey": "CAASpgkwggSiAgEAAoIBAQCrUJc02dXVwzKc1zc0xuS/yEHTb8hz40N9aRydtRc6Iu5/7UTq3TFQwseg96PUS7NLCkPcCjAWu+wK0Snd1jx1vspRdgI9ChkzCIaG5hh8IBkyV6DMdoWs398uTs2IXbkXNI1bxo3WwxH+IKwM0ZI0UFlhnm2SqAYB0Ei2HVQsH7Dul6bk7f3aMnOTFiIKHwatxzQs+EITa4blDxaecI3vtjeOx6PY2hXD5RtPtIFd9pzo4pEbs2aDakE8Lh9gO8DcjY3WJpLQxYOWjCUmE+AwQ7x3kTVlyOxqlDmpcIMTMLwC4Cii9DO9EWVsKNwF7XqkbxOo6wMeao22iOqDt2WbAgMBAAECggEAJP+wyF9LiXEw2yK375QND0ZmwQ1hU3X/u3QaFA1qSMoGjGZn/flrjy+iAae6ID2BKXG8GiexHxfS8LsfuaNtR1i/RTyhWyF1M8phk3zaSOR9zJuURNRMJnvrLYsjZJIpSVO2O930AC/9EM9pmRMh6l54D1cx/vx+36FmMr6+0RBkoLtKpUxaBX91wcvo+JC6ka0cPW3hwhRBAqETb3buXOpCZkkNAcKDvOYWn0/VcwpNS/DJ7KEl9VydhR0gIu1QqAj+Pi2mYi6dZMrS545EwoXuLZVH/uEta6DtQTVeA5PjozkSOqfF1vkm19aIYXcxCSd0moDMQRPo+cmJPWfagQKBgQDWQrlUEBXNMIBUzTyf1PEAU9yQe5u6DgFN69Vdcx1NERyf56oi1ILDVuQjEEfIpOIAQEThqxkoW/2xRVNoAN+TFSNuOIToHR4iM00oqsnpI6iqGK3+xEo/BFz5suGaa+Y/3976EJZv472QAEl8Ft253S80FET9wB41sA5gONRgoQKBgQDMsCNtHnCHciSDrJtGutirw/JrEk3lUDi3rGQwmrunPk3I+86x1if63D2Rq6XKJI55dRpzQfSX9rAeWSBKokp/XKw+YNNlLeb7LAqTiQzA9Jw3dRJa6PPWg5UaqnAaX/6kqsmFUh8/jINedwZ5b6qHzHxcIHhR8y959ie4btLQuwKBgA3aIHsz0wUCBrn0zt+Sd8ZKpa7dnvLHZwQvpAq3n4RU/+HCq3g2/wE8A+HUcp+hMU9M2GcylZzLXbpxPfQyYkHzEuhUVRtgjostf+aKLCWbfZMJp24aKKasVIp8KyO9qBQnGBZYrjErqxy9OAMCw3D5wMyAJvm0yv8zk6pa4jghAoGAOfYOshGSj+g0iszP04GJZWpBNSyjvjGvPeOlI1ZNmRg9cpJLf3RDMfg3vw46Djm31pDggo7Eslt6l71pNXkrW1FkvO0yL06GP83C2PBQGjuqGNIf9npMwgvUpw5oXC+ergZmtkgA7T/e21sdDDogsf+nn3baW2pfoUuhB8rqC40CgYBSI7a6mtBD5mHivfib+TyzaSAp6Lxj3zUJOq9l79BDb4HYA2X2Akqh+ZAe9sbOK24Fig3iZvGfKRDrCUBU5Z4tRzPBYXeP/UUNXZQ98Ay1ZJAQZdeDd4pKKFN07rO5gpDiuZKlYZvTsiaK/nT2xdJozCCXnAqYd0ODL7QOyQ9oDA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrUJc02dXVwzKc1zc0xuS/yEHTb8hz40N9aRydtRc6Iu5/7UTq3TFQwseg96PUS7NLCkPcCjAWu+wK0Snd1jx1vspRdgI9ChkzCIaG5hh8IBkyV6DMdoWs398uTs2IXbkXNI1bxo3WwxH+IKwM0ZI0UFlhnm2SqAYB0Ei2HVQsH7Dul6bk7f3aMnOTFiIKHwatxzQs+EITa4blDxaecI3vtjeOx6PY2hXD5RtPtIFd9pzo4pEbs2aDakE8Lh9gO8DcjY3WJpLQxYOWjCUmE+AwQ7x3kTVlyOxqlDmpcIMTMLwC4Cii9DO9EWVsKNwF7XqkbxOo6wMeao22iOqDt2WbAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmQpLk8DTM5Wqu19B1uo2GRjMJyLQyZh7Vz3ejwfnETNHL", + "privKey": "CAASqAkwggSkAgEAAoIBAQDeJD/uc++aiPTDzGhaobaZwQGxUcBTOD65utvylkQx7DJAGKb51QjlH2O/5AC3wqcMn7D9MkxSX8IUUlDjbJjE0ohCqNnAYh20zWqT4fNTzPnTmcanuQm3aFVxEf9itD6GRiiCcZJPGnxdetkaN3vRq8ik6pg+yb5acLSeEWpw9FwhUbWYQeIeaPwlbmtaD51FTS5jbpIwl/oDQf3HRS1u99mf3XrKVWNDfEEr98ciEn2NJgHQxC3hf702xCD52F8ZIJbd7Lb30vdaxzNWoZbDuzVI6D/RuYbxx/oxtHxnyoH21fbtK2JXJVNzUNEdmgbglQv4w8U30PlZN2UDrjyBAgMBAAECggEBAMsb9eB+3Ks9Yh7MfPWxOpYmpPeOOf1dRezn70dFIaFLxz5XzARORs3H/5pqTEW4kqi2Mkuve50ttPSDtzXaC2ya2r+oR0Dh9StlTndcdvE+T4ar6bldNIcfvE+gFxQWnbyD1XI/iXkOTHvkYTDZXjr9iH1RilaOe5+RwXNtlRckgaFfZSTSODpVVxcJLmx9HUQxAcJGbeD0iOrLZ/5BNRO4tnwfdbgIbAvnCIGmy3SsalYjOJeQYxnUZydV8IP5FD1b8WwiAIbhvWfhFOKIOePljOac5aAhTRCNeXVzQFAH0jNK6paDvMNNIhU3JKJApSUppRwdCv2TsDnucIitPskCgYEA+pe+YLnwZCJYvcW2w4/W8Oyvr9yleIz0RmCcRkp4/qDRcDROO1L7z2wtsMOE9lGain/pQeV3/ho8B3grbe/9S/Ezfz+htV6MNONjH9wNVB10FZau26YGcVdPT/rjM+fl1IcaaVHc0RE8OubKTAvNW1yzBmU/zY+fCrMg+12PS9cCgYEA4u9YDnhIiHdewJ+uD/Tk8FH1OpEsvqkfi521Dyen2J9AITLvj8B/jqUG235eM6ZwYh5YXLkuJmvZgcLhkSbQieM8kb5jbGaFcu+z/13qlUG0HzD9iVWqd2u476aeVW4uGVBV6LON/MZZ3AkkEkcNMQ6baMuZvhLIt4EsN1Nv72cCgYBJho5wWP4kk0NQYxuN471gMUIXKnlOlqTxpVUU9rLrmwn4jxBJLb7+jDIXxDZWA3mBm6g4EnkTkGT+mA6+EgVS6/F9K5Fp4tTmi7VA2tL6VC4ES5MAlYUcak62G9ngF/GCWyWvszpECXePnLnMeEYHwXoxrTF8QeCbRhWuSzRJPwKBgQCkVvfJ4smEKg3wKLMA0zRH5NJWS3O/zvINRXQtOWaPtSPX5u8dhyXYwyGoKmdFuC6Cn78VxvTo1gl5swtu9lDmyiy+zsVpZwUVKwmK0RRkamRqgivZHLSKLvSKeHsJGvU/V7IfBoi4mVvRwLzij5m6AP4Ccg8wWqIIYf8HQeE52QKBgBQCEVLGzF1F6CNhu2LUso3+72usPip3yNP6EUWCZaiv+/r9V9p2KRxYrSNFZgh9O5kOc16XCuFqvEVBCSK93OYuaurVj/lw0+GWL4V3cjcfkEJP/wJbz5ZG1pVsT3ZMYLD5MerY/I7MzpDK+Qt0VgnT78/2B2gxrWL6uSsuTsFW", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDeJD/uc++aiPTDzGhaobaZwQGxUcBTOD65utvylkQx7DJAGKb51QjlH2O/5AC3wqcMn7D9MkxSX8IUUlDjbJjE0ohCqNnAYh20zWqT4fNTzPnTmcanuQm3aFVxEf9itD6GRiiCcZJPGnxdetkaN3vRq8ik6pg+yb5acLSeEWpw9FwhUbWYQeIeaPwlbmtaD51FTS5jbpIwl/oDQf3HRS1u99mf3XrKVWNDfEEr98ciEn2NJgHQxC3hf702xCD52F8ZIJbd7Lb30vdaxzNWoZbDuzVI6D/RuYbxx/oxtHxnyoH21fbtK2JXJVNzUNEdmgbglQv4w8U30PlZN2UDrjyBAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmdhiMT6xxQoJhz7AEN7LbeFaxYMXghAZ8SQVofNbdg773", + "privKey": "CAASpwkwggSjAgEAAoIBAQDkiM7cicZwosubnFMqdW2aWX4pkHbUV21ihnfY2ZWGlsc9/tRyGzjKVORdedDLyIHduVif14/AZTOML/DnlZ18WhfG5XBSu9ksJRKpdQgj40Hvuel7yZGs/HJ7s0p3nR3+CWK/ACo1rvlSIb2UZIG2TdVvDYpBM2VZLU1mR0HlG5aNz12T7DPgN/r9DjMNtxIZCvk5rJwJnyeaSzfkOVwADIlxO7qI7jO4SkYyzDIIyDemsSr6hd0ehSPWp3E4IuZs9wVJ4HvqzlHedG8RtzZtqC3gL9K1IWxY1ioy7WrgMwZzGPGXSRs3z+5JPIUuscMd5Xwb+7reqQg/41SaBhq1AgMBAAECggEAJmLUXDbIHiM6D+kyDu+qeUKO7mxViVUmCmaLuuDRPMoWrVMgXAo2f8XClfDgIVqMdbGsMS0D+E0HW4Sx8jQvP7PiSoY/V6Y11DRl7hC6TUzexmVz0lcJIQVGNYDoAS9i2ki5TVu5u0qoliMUtNgs8XIhZ4XesxTu8Quq9IMDjnfCcXtOOFF/9YS9HsqaTd5y5UJFJrmjiSz3MR0r6xEpXjwNAkgBfT7iopdVkShxu1k7Hd072+yc+3MsGWtTpPr/JxlSOUCqTvsuOEMdYOtCS6kVFsK2nwf2EULTFkawohc3wdqTKrd8oLJez4ZZ+BRghWyzumqjGExgbABo5fZgAQKBgQD/eG0Fphq4Ne6PaDj2WKNJP0/BjvJhFfWmonr96hlMXYEVkQ7gx/yi4f4I5Vm7oR6yj4Afy/XZodKOQT3GnDla4YxGGh/yO69GjBp96CPYufODtrturCy0t8tCM9f27uDNw4gGhpFOQmMLY3yFX/9MulMz4MH4SSCUdMYkRXXf3QKBgQDlAhZxhOUC8Z6Rc+i/HW6Ot8AvRYvaJGUHtdn4TA25sgvvcwkKv3JQDv8Gx4o1kpHte9WnnrzUanYhMqKqOtPeGbtGMkohIleq3plwUwyX9ax2EpNV2tlvmcQbgXYJUeH+DmVEPpwYTaJ6qtbZJW7p4caIz1tObD4z+H1yailkuQKBgA4nburkNBDGtCvv21ASwyE4x8Nylw03+T89O1E8GiC4AYHfYpKjoeSoXrnBc0JI//lmp/ObCkj/hTnqdXC+kRLu8iWkJub11ZU0B/e319yXGN3QTvwnv+ZXVISbeLiurXfZAH1UEVLjrLch0PFWyz9GB3wVVMnby1lOSvgRfSFlAoGAceTx6I9hnm8wn8J31OT8YTp9+ISsI1fKb2U//L9GbD5itToPGytP3QU4TNTcpfw5W1UlU3IdE7/G9IfMYsFTMbi2bRkBySzdUPvYcAa90q26khZ29FIdpeVhpRRj8gqpTMM4FhLVazjhQATLSb/WQ7eoF86Y6I3o+cvyB/9IivECgYEAzqTpNA5ZZXLdzKAjf5kysgvlmdsk4psGu8a2bq8qDAbh41IDWqsNko5Eefv3RIHLqg1gGB7f1qnXth0SUzNOx01o+5LA7jVggzWhq2jgMnSc1yds3Wqj/EMWVaGP9kNyigbGHfuTRhFhgegCiPz4xf9p6tifDoRChc5tIy0mocA=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkiM7cicZwosubnFMqdW2aWX4pkHbUV21ihnfY2ZWGlsc9/tRyGzjKVORdedDLyIHduVif14/AZTOML/DnlZ18WhfG5XBSu9ksJRKpdQgj40Hvuel7yZGs/HJ7s0p3nR3+CWK/ACo1rvlSIb2UZIG2TdVvDYpBM2VZLU1mR0HlG5aNz12T7DPgN/r9DjMNtxIZCvk5rJwJnyeaSzfkOVwADIlxO7qI7jO4SkYyzDIIyDemsSr6hd0ehSPWp3E4IuZs9wVJ4HvqzlHedG8RtzZtqC3gL9K1IWxY1ioy7WrgMwZzGPGXSRs3z+5JPIUuscMd5Xwb+7reqQg/41SaBhq1AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmQedrgwE7CLDyJa5Bv9hTjf7Paan526sQd5gVFCmMmsHt", + "privKey": "CAASqAkwggSkAgEAAoIBAQDoGW857wBAmW222eVe/8OtzHX+7QKwOCtdH3fJ1xEbKUrSezIYr5xwUwlm2LC3AvMPVvFFEFauOqzOJwuIitLHx9S++J9N2ML6rjigp6OLS/j2jtWViQPMkojjMMGONirttAvQGKKoyAXZ1ExnAIXBHZ1P3U5jLrQSCrdKKmrI5TXuI7vxeWfEABT2oHTfZZrdBb3qCY7aiQJmkKQDIQUS05jazhwt4wqaN4zByBagiHf/NU0r+tHKsIqWDi2uKkzc6BELb2wYPyODIiqwDC1714TyKqCV7HqT7OlJ5N4fcZ5M1BBk5Oa1ZMAGlXGn4VqHz2agu2Jqxq3tC2FvSemHAgMBAAECggEAU5qt1QmBZsOdoKr2k3S/0MAAlPZc7IsfG6k1JhCBSe5i1FSqI/hF+rP+g/x0E0hNs23W9NDA2HusOYoY/nM7H9mcibnW8FyvR0swfLZGE+wm3vFugDHdm3gBNQ0f+5EJf5xGUQw+s1txuBhf+Q5YH8sCGn2WOeXd2U3g3idPVdODL/IZXiqR47rpFVlUIheJu5pkXCaqMrSgh/JfZVl4aBK9BoXu3hXCgsXE+lBa0w0yl6BDwI9U6vi7USy9VnehW278ZagI/i57BT1Zzgzjj1WExQj1J3t262DbIHhnM9P4uLocXs6PMKfpozmGkKucL4E4MyUGi0YahV+7TPO1mQKBgQD1Hm+ofJIavaGTDtWYoUFQp3mYHodeeOfDbZu+8JqQl32xA2sZSyQlFlh/OPdlKl49eGJjkcibMINrvOabqgdgG9Cw6TwltYawd5HrvzBASjQIVGLWi7N4wVlRwvw5AO02IsGVHXPob7xQWx03/9ZnsxVBNR6j2IJfQRSU7a24pQKBgQDyZwrkP7EGXE0VMGluMNmsLKzuICXIC372+3DlHmavHFakWA3bqXLh/u2/4L9fmtcGTX3u1MacjnfgqFVLg/f7yJ/UmAHnqKklXvOfO73svGwgNOBOVbw6ms6ZzP1GN//RubeCFxOq8U9x96CAxVTHGEsPm8//Z+QvqbHjIXyVuwKBgQC/aAz5HI1apEnPc/4HOaSvPpgM2YoLk44nZSgBahDIaAOWfnzbO3n2HATvE6TcMsF0btUlu2lTBgcZ0mChnZw0yIOmIfr910pd8oDX/mvHSCppdrvXnS+AVDtTRVd/i+GwLGPN9TnVf6sldIDUgcsDHyyxxrEucJsdlsxjn1XQoQKBgQDQoh2+vI8KEXGK9kMYQ1VmmoEw51x9ZF+gBmRx34uz1ilAhEVRNfQaTcel6bPtfqDp3NKyOFLFtt248EmRmIFdJZ1jZn3lPMZw0tvOxqW+V6KcycXxxlse+dUujT/FKze09Crc/i3AaLffOKndi3pfbipUwd/xTSMaXu0rt8u6NwKBgCXXYCSUjEfi2qyeYiwt+iTM1FBNWE4roswyaM+HZBO6mXhFgg0JMbiovCJckfnVa0pNEo2RxM/LMVDCN9UmqOVwhNc6tMEUCerNhei+OTYugKcBrVIhcOt8YkXAAzdYlAXjiV2oU9cHQQ8jWHIMUNiIUsKuZhLP6I8y6NmQ3/D4", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDoGW857wBAmW222eVe/8OtzHX+7QKwOCtdH3fJ1xEbKUrSezIYr5xwUwlm2LC3AvMPVvFFEFauOqzOJwuIitLHx9S++J9N2ML6rjigp6OLS/j2jtWViQPMkojjMMGONirttAvQGKKoyAXZ1ExnAIXBHZ1P3U5jLrQSCrdKKmrI5TXuI7vxeWfEABT2oHTfZZrdBb3qCY7aiQJmkKQDIQUS05jazhwt4wqaN4zByBagiHf/NU0r+tHKsIqWDi2uKkzc6BELb2wYPyODIiqwDC1714TyKqCV7HqT7OlJ5N4fcZ5M1BBk5Oa1ZMAGlXGn4VqHz2agu2Jqxq3tC2FvSemHAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmPxSGSsvpFYHvsNYPnDRe7D8YFp5sFc1DRJyJjA6Z2pZw", + "privKey": "CAASpwkwggSjAgEAAoIBAQC9UYzpcTpZ5pmfeKJ1+RKlXbVBloV6Y2xX4pmxDcKmlOYjLdlPTd5o0/xR1Jnz7yABwNmbqeoEywvQ6DxIdSBqI/fY+Eiq5voSAb8b75o74KjJKIpzpX1IfLjyGpPHF8dNt/2tOe2qWNYfYu/9byt6I3Yj28x9UJl7jQCq4a+mxZnQRfb+7StUEeTOumbYnx+YkP+eyt6a5TfrDqRbqcEVgS64Gbne9vJcU9Atr+y/QV600JHSXVr0l0KzWgN1ihCUSBhAiq+n87NgM1//hFlm771/DwtREvaFBMDIBoGgUP6mhAMMlP9IuigLMaL1Pp/DW12TLcE8vWM6XT12XF3BAgMBAAECggEBAJThFuFVy797GwBPy+Ledo1Y/fuQNXOj0EXky1xzJ8n8embb3XMCF490dY6clF1ChXcbg4Vov8H5M1eb6hxJD66ojnYv+mV7stiKSxHbAP1plRJsMUT0tWtVudOalvAQgQlbUcDyNzapGeog0f4JeLVaQcO9TDiYM7r3jbjUNl/81tBiQgHWP+Bih+nXWk3531gOhqx8abJCWt19W2AU62SnafstJ37WCMrKtM4ZZgwBEJnOOEdmDAOBU7o5oUXicUuAKheJg2p0CNKLpyf5/PFItqLKASmjgmS8i1C/NtcWsza1w90A1j6ddiYfHA7h2zrZGh4kYLffnUdXhmu6LkkCgYEA3YE0wF3jNY9L9tKuRHKRKe/W8Eifu8Be4fu6pxHvAAXWDQtXdnaKZGr2JohCAG/PyWrY3qtH73bXI7uOv0tWQbAZ5wVG1SKuODfFMuPy0iw8qcTinGXGSJc4YHtQeunKg0O4ueea9kKdobDrz6+PJj51iDEGyxMpv9wrU7DtFE8CgYEA2s0rXmfvQft636W4kLlDqx8bIB7oamr2A0gC8zegpiu9OA3ctJSxsym574BDgyhRAVTSYr7SAgKB4rpVPOpGm7CLRReF4gf7NH3VjiOUccO/G6hJ1uJ0XgPl0/CWKJ4eZcgPiEYawMYJMEr3riW3h+uoYmVyrWveD6NvEhQxGO8CgYAbjynbDVNppIyVBx17kq2RBDA/8Sk+mO61Oza79rU/0XoSYWjeal1JpS0/GhDsMP0vWEXnXnQyzRxza7CVCHCQ97IhVjy74/a9M+MrM8VQdQSPMtnnD5qeCYKQLoeS42e48UIYj0JuhVdLeNG+I1+yKG9DJKZtudKl9mTFouu8bQKBgGsZSGQyfbOPdAqq5Je6h3vogu+LEXqdloPuqLsCfJk6Cam5Z1HhAsZO41tvLhyyDEyZh02cV9FyBr/DM1vY1Oz6UoFkTT1haL295l1n3w58oTvZeSM8v3cRc1r1hZqmIvzxG2E553h6tx6zY18TyS031bksLSDkDtMazZBM3+dzAoGAXBmm63xkkEVJlzCfBtlumcE3OsIbQchVaz56rF46O1whVw7tJnALDx8IIl3xT3W6arp01mgJSzqWN/93ZGl5VvbCALcEwX2w9I81SCrgsyXXpA0REo6d2ex/EVavRK0uZQUFD5ZwhWPTPpqT2bXCW8aF1MSh+U4Do/3MkLNgxuw=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9UYzpcTpZ5pmfeKJ1+RKlXbVBloV6Y2xX4pmxDcKmlOYjLdlPTd5o0/xR1Jnz7yABwNmbqeoEywvQ6DxIdSBqI/fY+Eiq5voSAb8b75o74KjJKIpzpX1IfLjyGpPHF8dNt/2tOe2qWNYfYu/9byt6I3Yj28x9UJl7jQCq4a+mxZnQRfb+7StUEeTOumbYnx+YkP+eyt6a5TfrDqRbqcEVgS64Gbne9vJcU9Atr+y/QV600JHSXVr0l0KzWgN1ihCUSBhAiq+n87NgM1//hFlm771/DwtREvaFBMDIBoGgUP6mhAMMlP9IuigLMaL1Pp/DW12TLcE8vWM6XT12XF3BAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qme9BHBNLCqt8kagc5K64JwHHbVYrB1o3AjCZvpSUghUME", + "privKey": "CAASqgkwggSmAgEAAoIBAQDEEH3wzUPnAbHJ/p3hwFbGbu+bGLxdGQrq42iprklRW8mK2IKD7vOv9nMc3i72nXBDeJWtmrCjSuQj0KI70+X0luyPWG4jCUDq39kOxgc2w40nWJwjD63mfVNiswkFBvmQ/ll2nxJRTW4b1qz1EcUNJwXNWSi2Lb+PcuzB8bEZoLpCPsRbiHkDuUPb3DLDm/NUtv3MLqUfPmLGvy1iN3UfmCdItRtapC5ZKeGiUakzjTHBzN39UnNRFHHTfMFcXt1HWx1bLXqru/kAZLgVVZ2yQJ+oQ0CZoiLgJcXP52LGWh95m7hvUA5EjNxSVGcwESXkJc2z8pda+UOJ6gZCcwJxAgMBAAECggEBAJAXHrdt401ObX7p5NYYKK3EscrmLuiskt11K2IoeDGWp1OnMqQLZIQZNxgsIY+UvQCZCkd/u/kF/QxlNBWL8SAEGu5uKuMM1ezHfhnhZ0PUC1SzRmxuBXuy9yk+Mo7DRX5NryoCVc/ye81xw8KHwK2d1CHKOKVKkdG2wFD4cxNFRLU14QJ9ier2b9EWlTpqY0ug5y0J6GfISNTGLUsccY0od9TdCxCy4HbbbCNZfVegx5vX+qaYM3Bd1xiF0MyBpwLMT9+hVOgUkp7BM1UG8DgvnuW8gKhQVqtpwvUvbEI72uHiK4OMruQx31rxc9I0b1g1GavsVYAwsJ7iH2tlRFECgYEA+tuRKfxYdUJ/sntLKnvGIVKJdNID60OO1mopOgryjYZ6pVzQG5ZBoOWq0m/f3gnAjAMDzzIyLUUxaDkEJ0118sCHhUiV04eIZ1R0woKTLRvCcwaekiVVHuPBqD21eRzK7MiCsuuMADbg3glk3C7LRJMzUw+0SH855Kg/sDdblAsCgYEAyBVif5pHW1Mteh7btXcDxuDh8DrmYu95zEl01i+GEK+/Rlz5uoh2RrqXuiO5NGBitZ+pc33e7b9tNq9NPoTEHc4Ykh60X4yVZXlm0RP9wCD28KBkYFwEDeULZz62fJuBZNYmR+Gm6i6UT7ARKadx93H2ceBxaULp/ndusAgh9PMCgYEAoRf7YsEAdVzc8Fso7AFMPP3p87EifySFR8Ao9XMuTCA+Bo9RvUWCo7aZOkZJtycAFWmiOp57hoLWtZ1Xw32E7v0gikEQpiR1PhYIXRjJNsCK4J8xmZyLyyhrpoTqUvpgfipNdGS7JTAYu73AnX0XX9Q/s2l0VtIM9X/uVlVWY/0CgYEAiTEolcgqj3MsJqVMD1Ro8ZA3O+qXGFWOFUZ053w0l/J52/xae82gFAVTjh16m3BPnqu4m+k915U/hJSVCX4tnyY28NI+6ZlSwv6IQmpLvtabnAjOasgNO53GwOdeZ3iVM5gnLXiLY93GchGO4xneakXpLtIv0XZBTeuEqQ0ag4MCgYEA4xlnp+GerKONdky5ThXKXzrxAPqvP8DbKETXc7nhccHkDrzHFjfbcdAeSs9dksbyo2VMw8nfnW3vbWSC/ZRyaDx38uEg8xNmbkr5rET81R5DSlf0zUlkpld5wD20ftI+aoP5QqlSMdcaEFzHzvWSowbrfnEbdKol02VfniAA6qQ=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDEEH3wzUPnAbHJ/p3hwFbGbu+bGLxdGQrq42iprklRW8mK2IKD7vOv9nMc3i72nXBDeJWtmrCjSuQj0KI70+X0luyPWG4jCUDq39kOxgc2w40nWJwjD63mfVNiswkFBvmQ/ll2nxJRTW4b1qz1EcUNJwXNWSi2Lb+PcuzB8bEZoLpCPsRbiHkDuUPb3DLDm/NUtv3MLqUfPmLGvy1iN3UfmCdItRtapC5ZKeGiUakzjTHBzN39UnNRFHHTfMFcXt1HWx1bLXqru/kAZLgVVZ2yQJ+oQ0CZoiLgJcXP52LGWh95m7hvUA5EjNxSVGcwESXkJc2z8pda+UOJ6gZCcwJxAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmUEi89sQq9Bm3iNEEy77DDi7ZDb4HUJBfdF21wMYcGqoc", + "privKey": "CAASqAkwggSkAgEAAoIBAQC8vTEEHjOlrz0+wkTdN1MGC2LYlOly6bql01OBqf+gS1jC2UBd91ltJwPKLzDNKpGH0dayR0eaHKcfI9nj0tHlf5gPQxlDIULemrYS7SkJExdJ1RHKNLuCUjMDHQgOLtMm48p968YwRHgF3LBUb9pnWHh/tGTkpOs207qSP/yhr5yOwiyeoeOYlaUW5hXHfePpdQ3gzx1TTMKN620MQnaTqRCTI1dIbetKxre5rIXacnMH5RXE9jXI/CJk/+0DR7ZLsAjxjxE3S+OFENWNv/EidxkVguqOm3fukfe3n56j3hPLJsDwFSd4IP89VdtEGSsE2g0q+Enjpz6NCBwknO3dAgMBAAECggEAc6xoLCPud28tVBdwaTwNEDlOPXsWkK0bDaK1HVT5LF7BaboIrw53qmQs+G9vs26RfvJmaSEyiwtgib9JPU3qAoPux/vRscji2NdtG7BqY/tlXITPwGQNP9PtG81hMIAWPVGCuyYTc2WjQcR99WIQMyKPx4TiCRfiaNnfEN9SkCypWEHKMQ8wRXZxnV/BGb8ydDTY3qYs1tnUAR5Xnf33lemDUhkQAVkcXqfkN+Gb0Nam+KUqB5lf7cwYniMuspZtePiwpPidLWkhA+2FqGTJG1FN0dGg+XaTqTKDCjiox+qbFl3SACSt2IqL4SOoBq1H01Vve7LTeJemItNBozkCqQKBgQDk5AQJ+X5LGe2VDTC9eZQApHhai54eVA9uE0bo0yZj637pE3GI/d/4ngr/92HxroZ0SlFrlZHGPWJiiz36zuE3OCi4M2+SX/20KOeP4WEVsJ8iL4pF/4T+G7IQfbSyNoC6iUIHhuPjOqaovt4VBUUgt2mjzQppu9m8Zj13UelfGwKBgQDTF8YwSrPLjjQR5nDw4+tqiGKu5mZSCbAct5wciTpTDlaiQX+/T46WTEl8SE18sEWiRw2s/BBFBrmDNg+FBvmsjIxqrCQ/yzGXLatLk2Vpkv8G7VEt2do2kkv1eQsQui69JnS2kYuhfXqDfkeVOw8/UFMdEXudq5nDZqIHVF+eZwKBgQDgYNnIwWhZzNgHFoAiLe21V4WYFWfyiSr7GDCaCmuG5hNp/qJ8zYrimGNmGydLmW+6ziPU2DGn6QLqYV9n36gNzqK0N8/26Ny24KZneGQItDS7eWkOR3ci9xluaxxY228D7Yvp/wSk+xjnMPxaFOl4MfSAG39KuViwBHXa41Rn4wKBgCuPeGJ2x+t1iOE4wI21OttdEaAuA2digGksqpZo6xRAnTgWdBoyfKYfT/rJoNPePEBkkTnlOiZEYPvmqAU3j0ZAKqnIpCJV+AHOds69t+u1XdM8HchscE9amToqpFHrWcHGsccK+dl1X1bLNFJjQZ47ISuac/vxcWWVRFJm4uR5AoGBAL6P8mC1K8XwmKxSf43QWWi5Ib56y7rQEqihRhNRaZHHpfLDj1oRbb/OFYwOvqNK3IbCBH6LjqO025dRZoAKMmkVt0T+WqZp7Nq3zS6hmitZ/3hZhagaS5iBxDshdB17mtBPD8/WygDf48UNNeM8JbGY22WJ9lPs09G79TK8RQUu", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC8vTEEHjOlrz0+wkTdN1MGC2LYlOly6bql01OBqf+gS1jC2UBd91ltJwPKLzDNKpGH0dayR0eaHKcfI9nj0tHlf5gPQxlDIULemrYS7SkJExdJ1RHKNLuCUjMDHQgOLtMm48p968YwRHgF3LBUb9pnWHh/tGTkpOs207qSP/yhr5yOwiyeoeOYlaUW5hXHfePpdQ3gzx1TTMKN620MQnaTqRCTI1dIbetKxre5rIXacnMH5RXE9jXI/CJk/+0DR7ZLsAjxjxE3S+OFENWNv/EidxkVguqOm3fukfe3n56j3hPLJsDwFSd4IP89VdtEGSsE2g0q+Enjpz6NCBwknO3dAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmfFpRsArhLdQdXHsB8ft9Him69qZedcK5cEbfqvEN2atd", + "privKey": "CAASpwkwggSjAgEAAoIBAQCzE0FP8bilVeNMzjBZpdBGADuaAJlD+PgRA6xchdXIMh6dyJtHbQHFu4o+u0U96m1e5aieNKyNhaDuW88DcbYwkVicT0Z91LQTGhVVStZwmRGx0XNekcybU7RyK9+Zbhnd94U1wycSBj+5MelWEpZfxCKHUWB5eKkurYR4Jp40TqK4EqXpLxwR7LuT0iocOPQDJHRvkz++XSKKi+9AL2RkM3f0a1ldwV99k8Wya7UTkz5i6fz0xjffcbuu5dWW92FZQm5Nl0iUjZwoSq02u2Z+pTU7nQ86IroikE6Xuukkhr24EXUVw6gC5FYpc39segik76zGLfrTGMSh0/729c4xAgMBAAECggEBAIYARaJd/k7ya0mhDTs4Qhbvu6ntAsODfZW1yvfdSnEpWBG3+MJFBsuBH9z7Y8AGOVuGvVvNjMXGFfvnhYxNPgkv6j/lbplgXnPg08/kVX0ifcQzOIKu1Y3x4BiDTinQ4thfjTYC16y8MlkRyUqYVCBLc48QzQF40hjUzUjflQkMAlEkVbcE51OpKoHzaQ+ow7xInCni7PN9OoKpHnWYl3HfsY2cxNhFaLi3MYAPRJfxzdn8Ouav+I8na1Ggd/YoLtG7mFFNPFWAAkhXRVE5edrmhDsDbzUSf+VdAP8eaaaa7Lh0tIgznanN+KflLBR87QBZD7WFM0+SVFjfyxPQGqUCgYEA3IPpcHKsoOVryZE/zMNQseeRRLCjxErEflFRTPJy1ydvGxQP2imiE3b4qjrv5lQBkJmK5mPqC7AgubSaShLVQP5PlJJI0hUD3I5992PXkcjxmnTR5m48KMJTEheFwpyvLgxbLjRflFapIAwJSV/VcwtaeYT7VFYqM2JE0Ga/C68CgYEAz+Q6IMS9jNykySwj1sRX73poN6Qr4+zGdWD2GTAuECPTF30rDpb2xJrQ550rPKF6a0czuaXrLzOPfXhLVpy2z63A1hVVxeBypomCjhM/+zYgBUeoxfS/6Ga7yoTQmgqZDcQaeih+UbDbtPRBT8VMqh5p6NFjdu8TtCjN1toH3B8CgYBoNn8QAWHL+CBkdhxsrLFqIkHo8IG0tpD+EXgWoU3cmGpNpcGIHLzX7hW+fXP6qiDDMY0PLJDjTS1qFgwEjbnyqTz6vddkUUIt7bliPPEXmJt1n1fDSr1rlcqkdjFks5+mZ3h/8YhqFjp/RrDs2DmL0QXFAC+2v7HZ7ssOokAPSQKBgHTZLuLkMjZOfkCkkrBQQ6zS/Gjp2dGOcC3hhfG6ZumjeS6mp+DXcXQoIGtOp9K4YHqT1rruSzaIoIpBZvcTtp0caFrsOv2xnj+E4uDAaSHl1jGhiXdajdMuizbVV/p9InHeW5N11ypLYfJfp6YSm3izB4xYxLNAxa5pkOjGO8y5AoGAcPv7LKtI/y9dABCgxoqQx+sMAazwaeFL1uMbp7FEy3GRx7QyWI7zOzgIAZIUKw9GCEVsxFISeYDUSyYyMO5frZmI0mEN7h8/A13bVS8wuCPK78muCHLiG+mr2FJypNYMXQdGDjZRXb6L3wK0rFsOA6cSGV9dSQLRf+HqjX7LrRs=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCzE0FP8bilVeNMzjBZpdBGADuaAJlD+PgRA6xchdXIMh6dyJtHbQHFu4o+u0U96m1e5aieNKyNhaDuW88DcbYwkVicT0Z91LQTGhVVStZwmRGx0XNekcybU7RyK9+Zbhnd94U1wycSBj+5MelWEpZfxCKHUWB5eKkurYR4Jp40TqK4EqXpLxwR7LuT0iocOPQDJHRvkz++XSKKi+9AL2RkM3f0a1ldwV99k8Wya7UTkz5i6fz0xjffcbuu5dWW92FZQm5Nl0iUjZwoSq02u2Z+pTU7nQ86IroikE6Xuukkhr24EXUVw6gC5FYpc39segik76zGLfrTGMSh0/729c4xAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qmc3Y2dKQEQzv754NMz2pkXCL8ReHCssg9Z14UBCcPQiRN", + "privKey": "CAASqgkwggSmAgEAAoIBAQDNJti1FsTPq4FmeUbyEoWkS+YHypKjCQBt/jMKLyyTXF+9mFi7sO2iIrmUmEO+mhfcAF0VkZbHr1MZwmIG4J8UUpBVbIX4y4aPrK4tUfr7/HTSuxP435C06z3TUxK6e8FK4zuj7e6Z189H5qt9ZlO59DyRG9u8PfVjx+qg8FYqlxGGfGQaZFstPMj6OWeGCHeLGlVA5SVPS+xjtkjrv56eFJ3JhfBr6Txv2CmCklTeQctplAwdq701XHqihDVLEWFrj1EhXGuNfq0EiH3TVE9VBsMODF36cY8vjKPSYCSq9Z31I4MC2BXID9ksYB2SE9Hq4bDyYxfSXtfisE2YPdjDAgMBAAECggEBAITWlpQLvjzKTOvRs8Kjg62zB6wb239+IK0YYGxDx5VTxxq5PxupoPXPjmNNhPAyTyjBg4Sn1P5P5HtVhqv1XoyGObdWohlLkEIQCmiGIQJxoiOhx3jrKoQ7nrjrncDqyWp4YPHw6wLq3ukrz/dO/v/1yhIb+9iUNgT6Ok8j0GeaaKQzoym/rcVq+JVVD+f7zGtMHl2QmplRRQUpNlBWBxacTPOO4PSHmp+xLMohwpZxLxYfX4GCKZtWG61SkIFGtnyvA80BnTi2FJcm6gtIIBlQoSeYtMGDfxWP3pKG9iZFseuOtOgbKjS7WGXcgKD87ZvVPN+DPoWJjWEWA2WFK0ECgYEA+AVOXdmoW0R6MifotlF8OA7eWFiiAJw16WtlEhe7JhMJvifEya2po8Sw8+i/QgWqI+N+pSITE4mYeOz32xgyR2i5Mk6qXe6UkTW0OjaAGaD73Lxg0/cxqxR21ePFLcmnHBlzfcchBvkWwNwd1P5iswmubHQk06oYF0S8IUogmKsCgYEA08B457ICfNNyzUINrKmVE8pdkUZ5SoZGyg5DMpJnmi1Y/Ip+Z0WFN8PQ0ccBZlYSeBySBriZoiIaZk/+Z+4OX+WCQ58xTcUFS7k8Qlg2hV+U4wkx8ZE1IBBH8lrF3T8BlAVVPSaTjEmYOn/EL9WPAjVHGTkDImTkQihSTZV28EkCgYEA5ULiYdZkzZjK67oAXyeLj7YOydOETNQY8Z+YWdUd5eALTX8tZM/m079pYs1unfTmhS4xTyvkPlceXgmOQzRmpaOkLWCSEyoKov/ljTn7x7ULm8t2JfmGLAJKpwRYrC6PDmZoX4fGe8+cvMG7wbs0ORNl7FKgCBhfFIMw9AS1hOkCgYEAvs4apDzE/RHTyp0QkVsl1/VrprJoLP0d4IhFiNZfwI/INZfeGtSMHBm4mq7F1h8M+WpVMvU4it5MB5FhXuklzseSP7i8xqUYBondgLLYPgpIsOPiOxhrVH8XNY0R6jESDP1ZN4cBQVI3d88VSz0WZhj3/gRfjKh4/hwzPXHHAPECgYEA3PEpJbRe3ezreODAIyUpCGQ5E+vvGJsPW6S7XHHlfK05l1ALIx1sTKFXRvf1FiRpWBqbA76d8CPVFcadws9ImyXzppm23pe3cBoDvEGUt55AgdGdd+hztSfRuI1pYkyKYCvbKLKIdqRHuYgooDWj0zhs+9jQZDrz8vSxwLFGLT8=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDNJti1FsTPq4FmeUbyEoWkS+YHypKjCQBt/jMKLyyTXF+9mFi7sO2iIrmUmEO+mhfcAF0VkZbHr1MZwmIG4J8UUpBVbIX4y4aPrK4tUfr7/HTSuxP435C06z3TUxK6e8FK4zuj7e6Z189H5qt9ZlO59DyRG9u8PfVjx+qg8FYqlxGGfGQaZFstPMj6OWeGCHeLGlVA5SVPS+xjtkjrv56eFJ3JhfBr6Txv2CmCklTeQctplAwdq701XHqihDVLEWFrj1EhXGuNfq0EiH3TVE9VBsMODF36cY8vjKPSYCSq9Z31I4MC2BXID9ksYB2SE9Hq4bDyYxfSXtfisE2YPdjDAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmW8gRFnwbho8VpMsenJrRzur2oMDnRE9ZgEgXG1gNdVTp", + "privKey": "CAASqAkwggSkAgEAAoIBAQCwwjGfo5auOUnxe3jNKGS/L8McRkwCETpQXohTsYz7pXxBoej5tMJc6b8URDO4KIcmDxXUqBuO26GRheZjvehcRY9Bof25biMyPs1WzHImF8rHh2A/B1vmuTzqCknD4d1KHnGrvIA9DCg94S8cuYYCjDOBiiuKFFU/CzIWOv22a2xlfjTDvXKu/o+06U2TZHYkwkzQ/SwXlRJ005xjnWZat5+iO9L9ND5CSXuqJb56qmBMgux0XtAFPR3k9nDj6H2Wv9y0Mr+RKDAHnIErS/msCNaL0HchDAKc9utkARJsrgYwbKtWvJ+bqcpULwAf6oR5VHdbSuoKZ1Rc8hbDbOVTAgMBAAECggEAC6z4LCxZIq8EFGBsjViytvJHuBFoqeZLbM2hwa2Du4el2owAYKYxBIQoLAWJSQvcSYZLkd183IXjeUJYApSjyZyKpvI1WU9OId6GH8qna568tUta7y7kQixQOsFtN/Quctvp9EciTWYFLnk2bHZQxNBQAqmG0LshGmX56///jFIWFMTIidl7XTkIfnvs7RzscPKLm02bNxBTrGS33O1tv4+5/jdsSdShKMyzhr+ypYo01Iv1j/bWDpdzaixNqGQhrslhR/YaU+JfCXhY/22klzO0oTXMXlAgAHpezo/8EoNtRsEBH9x8L1/HXPqAU+ZpW0/eLpyfDiMtxN8+x+9fqQKBgQDgu7yIZHOUBlPFqnZC2smCd9uh29oTkiLhPd1YI1bpMClKTGAnWc7jiZsEuFo5+RM22Z4RF8JAwp2EOl4xky8BGNGlGOmoJsgvSx95Zhe39jsh9avKREVhBLmjPB9PngRO9KorQ+MkFAMXWRiof/tvFiMp3LK3vJ2e6jPS/gniXwKBgQDJWcDi6tkz81UeKSzh2xcp+Ezhm7X1iECm2lTto0B56hHRs66ye6lNY/KhFPe6XXePtavIvQn1xuF6Om4nB0o/O1bxc3bYftqYua+uqmCqr5OkzVndDT0AxKDoxfcDLU9ta8L7BoNgsMC8CwC9UKXboL1tC3feZ3BrOr2TW4YpjQKBgQDcfdWgTE5JsVuH2JNnTJng9A/9YmM4SG0IaVY+H44qBCK+zuiYMzkVbfE2VFnR/1qmuiSnyJPCTi+ViF7abPn1LZCjVyoI3OQT4rTiuxQSXffufccrEIixg51PVrGxv+uiO9Kp2FWHFEtkIPpceBUNDL87V1nRg7FyNX7bSHwSKQKBgDaKMU1F//+qcevxi07CYcvkji6uVuNjPN/1U/vqtJRRavI6kZ+XD4z+/cHURCYfGzu6IgYF7qS8cmcBXMUFnH70O+C7Pf32no+v/H57eCPD22JQnX7bDyMeH9fth7M8mr8w6WfFo+CVAB/vewvMxKBxMd5PtPBxZGonRyKbMAQhAoGBANBSWbIFkqachu1H5ewATo0BjvesEpqcZCgpKEA/lgW48E1oOn1bIq2UoJbZpAC7S3sSkF4ZtAX9sVg7wLFhWOfVeBosg6nDJE77ws+f2g47OunqsuNd9NB+gl0o4/jYvgERQLluVlhFevnHNkRYoMLI3D/uN4YRlAO+RAXjzp8/", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCwwjGfo5auOUnxe3jNKGS/L8McRkwCETpQXohTsYz7pXxBoej5tMJc6b8URDO4KIcmDxXUqBuO26GRheZjvehcRY9Bof25biMyPs1WzHImF8rHh2A/B1vmuTzqCknD4d1KHnGrvIA9DCg94S8cuYYCjDOBiiuKFFU/CzIWOv22a2xlfjTDvXKu/o+06U2TZHYkwkzQ/SwXlRJ005xjnWZat5+iO9L9ND5CSXuqJb56qmBMgux0XtAFPR3k9nDj6H2Wv9y0Mr+RKDAHnIErS/msCNaL0HchDAKc9utkARJsrgYwbKtWvJ+bqcpULwAf6oR5VHdbSuoKZ1Rc8hbDbOVTAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qma9mvZgzDdsTf1TLsNvDTHr8Z8mFdTDYNPFP7rt9DMPvR", + "privKey": "CAASpwkwggSjAgEAAoIBAQCzH9tpjgcWCV2Hy/ig1irSoJ5rsYxMeDTTQs4v32N9r1uVvGNDGhqeDOApP6CoB9f+ScQguxO+Y0PPum6GEtltkwGllsJRLsLZpeCIH/e+CxbNf7rGNkAGFk0k6kGQSllVlQKxxcCkeNhQll50/hDLTRNdnUydaIVdiYdABejBkVN7SXW/7zo+8lGXOU8xG1K/V67QXekFB4EhcLS738kVCM6qj7lCa1lH/u7H8UIhdoqBW/FToHeYpTFL8XGc6qnhVo4WF/V4eH27KxZSI6MTwC+2by0/4YN+x61dfM6eCUHF1dBVfAs420fkFpia4wZeC2wffLJMeIcvcs/IFIJnAgMBAAECggEAKQiCNdMAUo8AqwwRv55wHuIGiHsavaXHzCGApDzTSMZz/4AxaPzA3jXq3+gggH2TgEAburfAVRveO+bkTLhisJQ9i1ZW20wP/NXf8q8IDLPznE3HVoK09fAD6hHzxP8TKeTBwkGf2M2KGCPqLXjKFhho+EgBdgmsi3nmzsbLxBOI9E9D+A98HDqJJBI0h7JeQ+BndPyyugBYb5r156yzobTRnbwapGKfUbz7fh4EpJk1WgbFI+/W25JDyqhVW9CHr477t7caokibVFlJyVq4juNR+Cu9+m3gih0ssvmTeNoHuRaqO1AIVZU2ciXnlaWM6AndGnK465UvTyIsiAs1WQKBgQDrZzhsKJoF2VG4Ae8DoOs5/yzkk4vwurvw7ebuWXBHpdU1pIBUzBykcREJ9ilY5i7/QSC6HtbFgpLKKwl+h+rNSjOkt8RKg2ua1BpVs+Gp7L0gmxPVORtEgblq0vUkqalbwxQh/mJQPrfhKLvENVr6WMEZ1qxoC4WppNN82UNcXQKBgQDCzA18ZVzxfYGKyfDHkPT6erhvMN06oI83vKmnPKfBKtmTSOiGVf1W/zNgV3WA3Q2i91C7dzSQNtOT1wShawLWVLDYyDjbNRw0nbKbTDZhJDeu/nnQIxU/e7AaQxPs0yYiSYPp4sSdBgOdt9Gvltfbf3zyMRSTmxDuAhjBlDDNkwKBgQCxDmEc0OkQTyWs3h91PjrO04RjpCqUdQ9ZJscULUdLTIryHvm7Tg6ZDMYBFRqCWBevO8Au3XUy94QK9ZXdisNrh00SrnnAhdqQiMoJ/hNUqNCTzrB7JsnAnEXm+CcUXVwZvb/N1bUCoDnT67xW1r7IH6uWEKZ6V3hAYc4EULHerQKBgDBLVqyYlMpqS0uVdVSE47eV5VPr0W1PkTJIW+dSamTBst+JG9zyRLTk4F/qTv97zn2wwxs3GpkGfr4QeN1sIm/w30dfnHj8WdnRnw5RfsnmqMeB38FycToj+C0KpE36q2GkyEecKRKlAxB/GkVmKG4K1XdWI7vUngXkDy8vBkpxAoGAHflRwYwJNkdAvn94rzTCP1EkjkO45Q7n1SAeC0i5PSYxckpJEJlZ6NOCa0zLWY6HCmI/t6v3/i2v9nhJ1IcqlpRWycv8h04tjI+hHZIFw17/3WsuFdoqmYEupyqcgq5JptN8q8hWNA/EHJfP4eThrhcPlUWIm3+kTuvb7sty4pU=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCzH9tpjgcWCV2Hy/ig1irSoJ5rsYxMeDTTQs4v32N9r1uVvGNDGhqeDOApP6CoB9f+ScQguxO+Y0PPum6GEtltkwGllsJRLsLZpeCIH/e+CxbNf7rGNkAGFk0k6kGQSllVlQKxxcCkeNhQll50/hDLTRNdnUydaIVdiYdABejBkVN7SXW/7zo+8lGXOU8xG1K/V67QXekFB4EhcLS738kVCM6qj7lCa1lH/u7H8UIhdoqBW/FToHeYpTFL8XGc6qnhVo4WF/V4eH27KxZSI6MTwC+2by0/4YN+x61dfM6eCUHF1dBVfAs420fkFpia4wZeC2wffLJMeIcvcs/IFIJnAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmaccPcfpmfL4LLtcRMotJ67Hc4iSCSAtEUpmvPbjdQUhn", + "privKey": "CAASpwkwggSjAgEAAoIBAQDSAHBObXQBN/HhtO4Xw2RWXgX3L1LQ58ZXReesjYIZfw2os1tK3zM0ubxJoPq7ICjRtx5jfrBUPwPNn81GxZlHp8Zoj6LaQlJL8peTsMQ+3rkJ+7cVTutcXT612b89sPXjl0NlNJMvThzi46vNp3dWSJ2PUc0/xGETTqw+s6xcj6PXlFM8qcDUCA/1YuQX0uSW2zHFrJ0tP/5O6dICr/eAtMXAtOLwkVUi8liPq3JDdZrNmceYdIcmzyYqArRCt1LKi3lmG3AogR7K/DcHo+RGFpZU8wS/ydhgaiiFZfOo0dEUgNFRFKe2lpUh5zvS65IB2M44GgXqhgmruJDjQa9dAgMBAAECggEAPOUbq+JZTTEn1sdcc0+ZfOHu4Oq8HQ/Yl94RfBvcqgAJue2of2GRu6xQSRmBG1oL/CQZj8hg4U0UkT/RisAp3nlsM03Tb27j5loGUjFj9scm6Row0OD9pt7zHFB0ADOcWc63IFXKiGEiRzi1zQDOvhp4deLGncMYUzzw/Y2kYYJPB3QnMl0kjq6m11ylqoy1ZZ+X6fdpFqLlZ1ZbNUbVDcs4roTU1jg/z7Uq8sx/MvHNO/Zd6CGOEJ1JRP970BQ+DaaMSzFUAdu2QRyvqiWCdt+kNINyzV304LQ5Y6yMiH7IYlUkNCrCG2mIIeriTKmBtsNQyMTa2jiSIAk0Y2ZKkQKBgQDrqakDy0aTZUgZCCbcKt75zsUGwidSxWiOo68lwijS6m4/hq9JG02YO1gUs6hsw8S18nhCCTSJcGkibLfTi87Q3CdVd6FIkqi9sUYwlplktHyNyNUigyowzfa6Yi7qCiM+lKy7BFuOoRXOucavdtw/CjcxtcgkVX/dHgU57RLrSwKBgQDkH93bj0nCUJX4B/exZlHxwUiwn6FE0/xYhdZckD9yVRKnt/saMjLmIEZVNdfHs7qXL63qqkC3QfcY4oQJgpYy6aQueCCceCjFlPTliNd2Z0ZdaV3aQEcKQCf3HEqzxQCSKTehI7tUmI1jzrv/uuWxsNCMxiMPxcveF1PoD72+9wKBgE8Kd4qzOjejp7vllQsRQfotVL4AjqnfVkNJOSyD46diQ5oA9XeitbLSbKd83oekXazc52LWrY1Pa6PFLR7B7Jr2zCaJWkn6DqiY9b7ENCynsILpkjriHVuDKTa4SZ3ryohp20lam87JzoOoobAmQJbQOVTt8HPnTVx/fidAkbDjAoGACr+1pHLL9uv1JQq7ERDRK6L/2dKrtqKGcWVdBF+HncuEZYK1wjY7T7yVk85FrJM7Z4RHnZcIFZp2GiYSMqCEk0GPCuF+J+FBio3KPEaGYH3dQumEEpSUxFbhizM6Ed5meHyYsm8MlJ/biahkE1irGgRKz1dGr6eSQ5S1z2lud2ECgYEAiYi26mKhBy4ASiNoCcmbDP7QJ1IA3A0P/zhRE9W3ANTgeMpYXgyablEGmbgIzeC+8sFhwp7WCJSoTQRf0ulEXUTfcbdcOKNl/6inhL7AMnZu5Z7XS8e5GQsGBrQIiLf1nwFCcib+JV7PUbenSDM/Tnnjd7dZ0RcWofON4ul1QJY=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDSAHBObXQBN/HhtO4Xw2RWXgX3L1LQ58ZXReesjYIZfw2os1tK3zM0ubxJoPq7ICjRtx5jfrBUPwPNn81GxZlHp8Zoj6LaQlJL8peTsMQ+3rkJ+7cVTutcXT612b89sPXjl0NlNJMvThzi46vNp3dWSJ2PUc0/xGETTqw+s6xcj6PXlFM8qcDUCA/1YuQX0uSW2zHFrJ0tP/5O6dICr/eAtMXAtOLwkVUi8liPq3JDdZrNmceYdIcmzyYqArRCt1LKi3lmG3AogR7K/DcHo+RGFpZU8wS/ydhgaiiFZfOo0dEUgNFRFKe2lpUh5zvS65IB2M44GgXqhgmruJDjQa9dAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSvhA77qtKJ5nrVBXUPjbUkXmCTErkoz1rhS8gAeXzzpb", + "privKey": "CAASpwkwggSjAgEAAoIBAQDYDTAPWDfUR226p8Ok/MKft8zNsuFfBbG3vk88lDi2962fYgwrVw5LwFMEg/yxTLEBJVP0s1pljY7mnZmZdh2rgVyyVP7HEWoKuIuIteN84JZUovqkgw7Ea05cOnwdXofv2IKxRdEaQ5onSLYFMKUR1Impmy7FyOjUYQb5CBlK8tyqHUNruU+wK5bkF1kyjYrwsWzQK5Cjhzl/PexD5gX2qD2r1dFncY8ikzGobDFU+CZFLXG7BaCN4mv6BxXxuisxp45LUVUtfNCMANZLqwNZBmADfMQWplwGki2CFMG7YVmTskHjz8VZNnTOWtisEy6epDZROEwSOighGscHpYfdAgMBAAECggEAceOJyRz02ScKFdHn1SoUokMuZ+R63y9OPpDIjiOIPhMT6Ce0SIhslcv9Ny0oYIIP8I2v0xdUeKIFiVXcqUPVYhogNjWN1Hw+jQY5L8jJ8YMmW9lKDLy1ZR83wHBoCsdRG0LjqfUmxBSMx1aR9Oxup5aFNu4B2usMqR+4oD//rTye0oTpbrBZPyT0Kal6PdF2BXpZ5yQWGGgHKnS/Wl/cb/gGvyfef8sxA86YPnZ4dTiTfcZiFBZxi/M50UDwcAMcWIWf4g++VF83v40GqCiQccsL2xl0Aep5vrqYsWVjozCrcctX31H9vIQMvoVFjFsd/qdSq0+oCvCh2vAOc4hpIQKBgQDurGbzZPeMokdqIQe1klfqhBQ7anvV9S345mJODHhXSVvp9FdCxU+avLA1Gl/cAFwzqByFp3zZTXD0SJUbUS7uVTAKtNkpG+mQpDW0Z8dQeudxHGi3mQX7ucI6jNKmBlS4t2j6BW8m8HzY/zHOpAnJA3vua/uycui4yXGiJFF82QKBgQDnvF7722EU44h8eezVjbN12mh7Plpr2uuIYivZgSxRgoQCY3cxqP1Gj+9cdvAZ35ZNo0T1KGATq48tPyymyd3SW3DVnRE4KyxhYuxG0jyaDFtX/jIiJeLc6nB+xg3/3sgBWF8dF5PlnCGSXUmoicjHA8l1JRK48r6Wr7OvmFaQpQKBgG65xLk+KiowTvlJgY4W6np98/Tsna7RJBbIquqSlnHIMsAC/0iWySt8RjMcnUQvVpcQcsr+vMkDSFfMJICb1S30j2koJWcQ7/aOd+vOCYWovx6Wk245q7DwqM8I7eDgJwXa8PSs+LgT8ZeqLK01JOUAnMorhoVvEdBIhFM4jiVhAoGARTHxJsEl5ufeDFUXy9iI+qrhwdMniscOx2WQ9Fxm0FvpcREkOTbdkeFOtsxo+0DRD5Ot9oo8zgLPONKBUbg7PSHCunYw+xWhJd808By8rb7803R6ocmwSQjT2HbpHTr3e7dYh0ZQCiKpv5uNb/7cbdiKoikUwxbwo+wI+mjBiGUCgYEAnq0mC5Ixt2ya5GGhum4KjEdaC3wT6gpwBzZ7PAtn0ytdVpQrp/2QfcfmjfANFuU/WpOfz4swxgntY5Zf10EQXY915llg62uSdp816X/l/QUwll8BtgmDGfSc+ohWhMZ6n4B0lBZk8ZokJ7QZ8DY4PofgCASoYEaNmoST7n0bRWs=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDYDTAPWDfUR226p8Ok/MKft8zNsuFfBbG3vk88lDi2962fYgwrVw5LwFMEg/yxTLEBJVP0s1pljY7mnZmZdh2rgVyyVP7HEWoKuIuIteN84JZUovqkgw7Ea05cOnwdXofv2IKxRdEaQ5onSLYFMKUR1Impmy7FyOjUYQb5CBlK8tyqHUNruU+wK5bkF1kyjYrwsWzQK5Cjhzl/PexD5gX2qD2r1dFncY8ikzGobDFU+CZFLXG7BaCN4mv6BxXxuisxp45LUVUtfNCMANZLqwNZBmADfMQWplwGki2CFMG7YVmTskHjz8VZNnTOWtisEy6epDZROEwSOighGscHpYfdAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbjRBWZxJSBsFhKsNeHhTSfL7rRcuZ2Qd3NR4Z1aiKePS", + "privKey": "CAASqAkwggSkAgEAAoIBAQDILimheFvXtSG32jx0B9DLy5ow+VjWqs9DBylaXNb6UTn3SJR7k3TZJVx983zgOWPXit1Q8k496DiNzrbvDcqknYb32KL8v+uq2LBOWQ+KsRRC3uk5ZGkO92CFBrmbGMi4H9fBeiPNbvMmWInLxDhLqlLtLQeB/JbqzbSRAdAc0JaNHiEsa5CtE2JTC2Eh8v1LZs1XugBN/wKe10nScDJqRDwPJdxSYBC18jxAlRLq5ZHkY5DZb7a41XUkNA5tjuh2WOikcbFzonLgesmFxhOOzARiRzeTAJ43EOrOrWwm0vCvHrgeEnuDHuKPIeEXAtBeYvIveCiWPW1UoAEIcbffAgMBAAECggEAYcLZpffnspLNIsK731apy71lUiGUF1JX4j4vHehVPO5KRs/1Y9yBpkKuxvwQsliUwAEbUJrlRyqP5AFeKaUsn/QmpAfyoUkBSPCGOd0Yz/znDjla4SJ+hEafppfAMVSLQhCbB+wkbAGRUdrPgOoVLC7ETPw+vGalNYq8ckzWXBtL45Qy0DEoEH0xCHON/unJORpLacPmGffPuaqrY7D7bGFQ7XwuwsaFfyV6jyXeQaM2XheaMwcNCoRSX0W48dJIwG36OkBOgvGDwwnR9hrC6qrnTwwnB0moJeXNea28Gpu4V61i30uDV0p8/e4pVB/VRJGOPPk0PxIPAM0xbCktgQKBgQD8NpHbCdHhl53wNkBecA7Ed2OK2RuFsbNwxREqCoXDwM7did4/1Tfkp6er/IsgzCH5QIuuaCsyhoIQFRsyd+uRrTG48qhElqoQF3zRFORYdNr+6Gs0vA/yg+nuPZ8gXZV3Ip0EAbRdTXXXB2K78JS+hBnYd/K9U0g63DE4OjAK4QKBgQDLL5g0YBfRdtaluL45sFduaTh6RpIxvskRky0Ob/H9bJ2v7EaJmtIzuJZoXT8oFP5/RjqlzwxNaQpksbzkBpGsedmgqdkYoQNm9LcYg/n1SXhS/3Rl3ZLJ8A2i6FeAA3h66dXX6Bo0pZ/sqy/RYzWSvL+do9E8KggzdJNuhhbavwKBgQDFfCUxEbtZnVJ56MD2MWAezi0PZ3h5cu9Cecw60wpygOJ57Z4s9VNSo0RTEugNwklH1haJdd99LH1jAmPNXMEDzE2Gt9qx+hcninydanJyIO3pcyuemzMRfeEKPw3+VcjXBC9WF8+WzzRaLtpMttCBbQafzSwwuqlwDUIs+MLtgQKBgEBjNLhkOygFoL+ja6ScXRh//4XAF1PsQYtwODb7ApRsdwvos/GnPjVlqUQpSHpLLNroRm2Ez0E4qDKAoHsiGceuVWi0ajeDzrAxnFQIfo1cWuTyTtB5Bqs3hxq4xgGrF+LbdwiUZLmKQsOc++o+pht59L7fys5mA3NK3e2IUHXBAoGBAPlDAIzBX8HsKVjMik5EuJKX9V30xWQPFx8LugzvHtkDj2n2eZQduy2wyQWkTY2BmG7xzEX2r6Nlnzp6iJBEF+Sa4Bhh5wxVjYs4/n5TmJfL2FiX+wOW1ULWwSPDsnWZTtVLk+ezezmgWV3Defirhr8VSct4qh/nk5c7z8nvkSTH", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDILimheFvXtSG32jx0B9DLy5ow+VjWqs9DBylaXNb6UTn3SJR7k3TZJVx983zgOWPXit1Q8k496DiNzrbvDcqknYb32KL8v+uq2LBOWQ+KsRRC3uk5ZGkO92CFBrmbGMi4H9fBeiPNbvMmWInLxDhLqlLtLQeB/JbqzbSRAdAc0JaNHiEsa5CtE2JTC2Eh8v1LZs1XugBN/wKe10nScDJqRDwPJdxSYBC18jxAlRLq5ZHkY5DZb7a41XUkNA5tjuh2WOikcbFzonLgesmFxhOOzARiRzeTAJ43EOrOrWwm0vCvHrgeEnuDHuKPIeEXAtBeYvIveCiWPW1UoAEIcbffAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmcaPaHp7MhjvWdTSCyuvJZ3H2WsudgBbFLDS9J31eZwSj", + "privKey": "CAASqQkwggSlAgEAAoIBAQCzd4cl9ugYvYGTbxgMF7Nj6GUKPvBafUzuyrfKGwnlwGtVirfmd6jpCLX+OknCS0TaxiL2CLtKK8z+RL0Ecq4iUG7h/D83StOnRlcp6x3fVODGz7jwRjdFivZw7Y8WZ29sadRmoLb2gFjmwsuV3xPKkx1mk/1Em2wblf2TcdAQSdr9tobSCvb2oZE9tk/k+llZ+X2WZKvQdTpiGNbFSM3+fuB+HO4qthxD2+a1nTgzn8qKvisW/opFpB7L7nHhJla/exgikzWThN6l6i6/spqcAs2N5rzFVcfhdzhUwTjIevt3070phf9ck2YugSfbE3p3CHAFNNqs4z+gLkDi1RglAgMBAAECggEAS+GYFSdGj19hMDNi2YoT4YRbZG+kNL6SDs1L1HqGPsyTFYInq5ygoJd8S9fdY/drT41DLwAWIJBQhpoNyZmrovqbR5XeLMTIpQuKw0CUSt+agrVFnuIxcIgHF0x6maB2bkJ4+kOt2J//9uIaLm458gcuATdFeQK2PRu4MeWHcbryZfl+gBNgKTttaHDYZVEKwCzkcKB3ePfsfTWdSybB34o3HLzeDcAnmn5dX9vL8l5WoTGYfuFYTzkHmPizVMFXT6xSmN5jyrlCj87LmI20LikE4F0uzJY6JD4tl+SuzMZd4/Z/EjDZSdnFE1jKHb7FzO/pX9Ibq/vT7hpp98dlaQKBgQDsngFwg6L4+k0SzhVMpry1ftEJnFsd+4Ypf+Mxfox6X3JWDORff129JHbyexC8PWAbnUbH4YRoJJ4x5U3w6aQ3y5oHHIFffeVsyO1N1RW77nZRCj1ZelAHcGuNRY5X3T91ad0j6/JXmZDfRVz8YQ1bFA/48ChvJIDoBELWcVCDuwKBgQDCKwx1/A4UmJN58oSt+EqvK9nKV9GRSs4D9SqEi9uixjzx2YY1jHMYbF7D8i6C9pQmvMI4+/8QoD51K1vlQ/XS5EA9TWHRRSeXLVUFEEtErDUUh+3om3sOVi1MSizPy65tLmyHPM0t5iACA2FHTFchXcf6eak4pWEa5N0rV6flnwKBgQCxKvHq/DWX9VqmXPZnyWT9BLKiXpd/EKj5A8/qbFXk/viOY+LPen+Gsvn5P5pdSBthMdcgrMRGcjydIZPFcjvKp0FyV66rAIo7dQryPz2h1MB0l5UuHT41A8EUK2OUeI4ebSDu16lCXDK0aqxgMI8ehhwbij7MUWnPz/j3tirSJwKBgQC34/VlOFZNg0MI13p5GRICXNFjJVDA/cunS+X8qkhVHNJTauQEiwPmOZx2j0MlnUoqddKsDV0/7cO5TFs4Aukp1ipQ5JyjiY85SiGfLhNa8o1C6ImVJsughFVaT1WpZwnHNZRrcFYSBkSCI5lZ4R8T5rGist5lW5tf0Sj2B4pnmQKBgQCqf+CCjTD1/QdMsf39ZRuu3BclKLPbDaxO6MZQAJU3m1wGjMl9UxB8T3+ZXhr5NTtSbYIOTyIrSpvMN4ZSA9sunkiU6Fxp3ac4WlWTJ6tIeGj8IuMJ+RG+SHl9YXS1yMUhddOBpl8CRF8lDsxbMEYpKqJuoww0xqHR3Dt9p95iKw==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCzd4cl9ugYvYGTbxgMF7Nj6GUKPvBafUzuyrfKGwnlwGtVirfmd6jpCLX+OknCS0TaxiL2CLtKK8z+RL0Ecq4iUG7h/D83StOnRlcp6x3fVODGz7jwRjdFivZw7Y8WZ29sadRmoLb2gFjmwsuV3xPKkx1mk/1Em2wblf2TcdAQSdr9tobSCvb2oZE9tk/k+llZ+X2WZKvQdTpiGNbFSM3+fuB+HO4qthxD2+a1nTgzn8qKvisW/opFpB7L7nHhJla/exgikzWThN6l6i6/spqcAs2N5rzFVcfhdzhUwTjIevt3070phf9ck2YugSfbE3p3CHAFNNqs4z+gLkDi1RglAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmP2nWtwRR2TvwCxC3CjhRPvkiyV7bFc9MfHRU1fdCeBeo", + "privKey": "CAASpgkwggSiAgEAAoIBAQC0OKmKroyraUdXs7KMa/zE3q1+KDXXecqYeZ7iqOEiXs1KcRpDr85XN8vJsR3NyhFArM9b1LpH5LV0+dEW+zxFy+PH9BdhdYOqpeW2gcLhM+uZyfqXE/C19Cf0CFtbUOsfPsTQ5ODJ+5zyZlxhq/wL/zaj3DPCTrL0VEc++BJqLSsQcnkp+7vKkc2NQ1YPg4D/Y4JvH0Hc3ajzIc4xnooEVdYa4Zbi7EgVG2DLZL7I3TPS9nbE32ysmp8eIpjgq0s6hONynAOYtzhRPDVMF6vs/D3WuI3wvWPoe8mAupscmH1n7S7EBuLrIJ8dsM797J9OXf6+PZHzwbb1Iy7sJR7rAgMBAAECggEADjV1cICoiI8pV8nMJvQQnrjrtsmWzSFGDtVv6HDmJx6QUvEt3+5Jd2jnwUQclG/9AjtdseDIuwhWIh3cFVLDgsE7eTVObpmkQt0HimcapUTBq4NYJXcmAEJ6r+vEwCNWFkWNoOaarnIPArF9URoNKij59ttSnVw1EbxfTaCjWwmIsx3nrp/pneYlbvq3TxXxlbdsS+j7gPWDOhSeL93C0BBJZhsnJ2XC7TKm74dXrOmgN5oywOk2H6ms7CfHr/APSYfXhM0sqk3Ca1D05W0d+fOjjXFoMpjtEruP2LJij3myQ2Dt0ewSQz083MNe0MkStzdP7ucIUZhNWq200BVx8QKBgQDi1NCb24EQza5OlwmZfIMJybF5kpEy/SUvfBeCSro+u5g6CyhAFBu9npACFrdEDYQ7Pj2xTyMJa/w3PBvSuDo/jRZhZennw85yQMOcSdEUWrSw00L+m9t77vDuMc930B0HZLmLH++Erye3/fErcqKmeZjzcDVc3dFB5tJ10ielkwKBgQDLZXfPgbqeaabvbFV3t1sARMG9Y0Ekueq0PunIFnUuHFfe1DFfzD4RuTQdP2Pxugtgd0V2SAHl3Bn99rOYcRZd5KsMvodT/gK/xLKndQWRn2DkmvhtMdkNy28VKgugdPKt/q7/NTbrUtZdY2pxJh+JVxJ51FnMHi688msbNh54SQKBgCpFSH7TABFWkxYYNXTB7FWFnaovMxnSbPyVXngsXtrT8MFYVO7kEGtcwi9xdkObVToJFkwVmEzoL79HV1QEeu5e533NFTLYnX9TLGDSrMDjSmrtY72448ULuSBabfRA9zfqgF053VPXpEo4a5oSKddmL6emEHu25okmb6//Mt47AoGAdQsp2+ZKTrh7kNFliWOg4VGvr107cnfuINUHUNXjjqpOwnKXCwqMOUS7QY1l5QdrXpKkDUG4nd5/so5RoQqKlXNuHwJQ+7tzN4loSUbk8nyllEe9Z5DE19RWUvaEBEzoDco+R6wGs3pS0yDPctc+VJkfj63sErLXsHFLwzfsZskCgYBtZJeHpKStBoSlk8jviGe4stgiGpgycytEpRX/l5l5431lfQwByqrUwoxmSh8JIR3q1H24a2VM+Nmy4r7IGvFMudjGeN56hbcrlN5IZyc0GOYS5C8c61yGWESm362xIQZ74yNSQuqDYvV6w9FdV8rhVTvonjd1koJHtNNNKJG7hg==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC0OKmKroyraUdXs7KMa/zE3q1+KDXXecqYeZ7iqOEiXs1KcRpDr85XN8vJsR3NyhFArM9b1LpH5LV0+dEW+zxFy+PH9BdhdYOqpeW2gcLhM+uZyfqXE/C19Cf0CFtbUOsfPsTQ5ODJ+5zyZlxhq/wL/zaj3DPCTrL0VEc++BJqLSsQcnkp+7vKkc2NQ1YPg4D/Y4JvH0Hc3ajzIc4xnooEVdYa4Zbi7EgVG2DLZL7I3TPS9nbE32ysmp8eIpjgq0s6hONynAOYtzhRPDVMF6vs/D3WuI3wvWPoe8mAupscmH1n7S7EBuLrIJ8dsM797J9OXf6+PZHzwbb1Iy7sJR7rAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmThR7tbPk579XSHjkYY2nFRdHZgnnBCF2vUDb5jB6w1bx", + "privKey": "CAASpgkwggSiAgEAAoIBAQDQLavVsy5kL7DhbHHYobrvPRRq5CV2iARuh2AFYxRWDEUcN1lX8AXXX8/mTOP7578lIo8azZnFjzLXhw+NQ4GJgoHecMHSrGSpK+4ZpCNptSy296taAPwLgV0/GUCHy+iZ9fOkcZN4UaDIxJbnJP7HBnidpVd4aUkcoofA9cbGtUzqL23hdj6a9NGlMR9bc49YZvqDyEncWkAuq/b+iF8kyMJoR4LMT2xBNTnBWtpqCqvRQKeVqQ9KWuOFUykBzyfP91iGBU7NWd8uhf1R/w6nS+ZSuHRAd2IJxVrA8NSQVQl9Dj4v2fDrTVqKmAlXR0x9OdczSeGHwPDXOX+UU0KXAgMBAAECggEANzHkvWQkiKucWihGhwlaZtPq9exHgoXNpwB9lPAQFEBskm6aYZZh9hiRJp58U+294DqpdpHMk3TEJiDJHssnLS5NAI0k1paembvsBSBfw0cl89z2sYZRTTufXXt0gIyvvyJW1uLGFsCNwK1e1SoZ4ur0T9fmuSYxHEZ7d82yRjyQ3D9LOtcjTdCTZGzsrOjAp1EAL5e4wPDo3T89DdoI3WnVftUFDnlo/inEegBriotYpfFVGSQq4GNUwXZnHk9xAGkO7VNr2rh3u9PP+f3w52wU3k0Td2U092btFmmVwcyE82NRP9r8MqZ+fMaBX/IHbYfDx5/DNxgQZ0At0M+aAQKBgQD2P3+ZyT+x/vzrCO0o3Dm0ULFr3bqhl0VkStW3jGFWXcuiI+kKQe1m+oY4t/nekJAVoHPuJO2iKPLjzSMS0m2LeKf4Aj/8as2ev3JXW9dGGaJWXXPgzdFB19ibTi4XI87qCN9ZBmncntgSD4fvFFQbBUa1xuvxHNf8IcKuuXV5/wKBgQDYbDd/UbIZB6N+HAZr+ucmspZUpqTfERQ+NypAMip4o1qqv0OKZ4SQAgvXfjo+KcKsGCMS3MtlhSU2Vm6p6rAeOqOKnaqMoxLQ3xznSlc9ZSlhmj+ZgslNgTCSOlLTaiITMod12g2admDCEWIpuXiBn1P+x8bp87OSL1OeKLHHaQKBgElPeDaZkov0ZOm4O5rZjZhgGaIKXgCzn2YPXXcKpQPoYrJ/zGZQYFQzK3iBVTNsiGjX3wu8FL8dP8qQDOwSl6hZIHCWguQsC9FCH9FgN0PYZ9sccV4xCCZ5EzSRXulmsLg+Mfg4D5Yt+BfQZeDIhY2R0Y5WjXG365lVl7ca4Z2TAoGAT0B5pi8Fd/L7JNAgbeRIRzx4nnETyPfZINtUpoN4WAsBxasakZFM0utc6MG5lE/4kMqZ9WtTNE7ojJhkF+bwLXGtt7H65VtGJaS+UdhAUCQ+XhZ9Gbrx+mbHoZSoBfFEnyEOx9JczuZwkkCJYNwhS95LhO4lYkCyzmJ0TWN7jpkCgYBHabtedfXEPrcUfclXB4o8gAgMbXYJXJtA7UqOigw/a0Sxv4aDuSyQCdagBicuGZ6waZrtzS9q9CHZi6ggkI2uBlpBHHFuYfFdQq8qFvG2YUZqRcTiDxFvOkSbspNRWi8CVMITZeVjx0PgUF3IPFDHM9hWI0LQTrmH5aR/r5oGBg==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQLavVsy5kL7DhbHHYobrvPRRq5CV2iARuh2AFYxRWDEUcN1lX8AXXX8/mTOP7578lIo8azZnFjzLXhw+NQ4GJgoHecMHSrGSpK+4ZpCNptSy296taAPwLgV0/GUCHy+iZ9fOkcZN4UaDIxJbnJP7HBnidpVd4aUkcoofA9cbGtUzqL23hdj6a9NGlMR9bc49YZvqDyEncWkAuq/b+iF8kyMJoR4LMT2xBNTnBWtpqCqvRQKeVqQ9KWuOFUykBzyfP91iGBU7NWd8uhf1R/w6nS+ZSuHRAd2IJxVrA8NSQVQl9Dj4v2fDrTVqKmAlXR0x9OdczSeGHwPDXOX+UU0KXAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmPbHJAYhY9wvwU8uct7PZxWoUBTn1bjjTiSqGBLRLaX37", + "privKey": "CAASpwkwggSjAgEAAoIBAQClxhN3b1UZdp2r5ge2RiAU7a5j0CQ02V4yXn8gll6tyWNOrblu70pZNpskGLvBFPlM6knavV9BrJwWCucw5imwkZ86Lz9phzPERft/aJWHu+vraS1OqS1TVuq6Qhhmq+fd05+0MHofnnsNQ4HgUnvz3t8CEpsadc1/JaxZEMnUolHf+9u2eBxemMQUr3/6vu1GQiXnzveMa9BBXCfKEYZt3VLDRLBAJXoJ/fE7AGyF1mVKVc2tcX8eaxUannc41lGUVgEuqDGqvAqSNwVBilsjsXYcdCEWtIO4v1ofJzjsX2piUL1apxbHYWdLiLcjk7BXXKFpjv3o1hJ+oL7NkmrFAgMBAAECggEBAJMjnv+xx/0T9ZswT8QPtkYdOV7KznhCP4PBsGECVwM173lUZXT73CgXediuQ2h771O/2NHYqIYoaVp/TvluMa7Rcl04trY6FU6vNy29bIvP1vVao6ZgLyT7ztiH9hSbnPCd9/D93kfWaS46rzqmu/KX7aVvUlBII6ApljJv3lVmV/UcV2cE3FhuQAcsyGdn0zf4m6utsB7It7Yi83yzE5zsghsLwCf0Fml/TtgasGZxgng6CwjXzReDDbA/pHITkLDllH41pEqxpVQleLvAKOs0Yw4IUgBGSK5xQVFBemJDik6PWM5wCV0pAbjMkpmdHxa5icv0NXLeO8m6hJMHuoECgYEA1sIwdrMEFGi97p1BJukrv29DolYrL7zSLI6nB47NR8pOc0yT6qiZXBsUaljYzyZ0Wrhl0LwaBTMia96AJ7NSuozujNho/RkL5e/XMTgl9kCeDO0W3weUIKXiVQMYfWu5zVUB5cov2XCn4tZ1eR4bjrKq9apGB08mxl7i5f+ss9ECgYEAxZu6qz7qvlzpjqZeDsNceSPX5u5X0CupxVx0tQ/+mEI6NnilKDDfl2rXtee4MxGDknQG1ztjMRQY2nCdflAmE435NLfv9ezf9o7N70ybhEkpec9Lp4GBJk/Opc91/N/h8n2RR94F/yYcW4wm874Ef8431ZEVm4PCylnAuUc8yLUCgYAxHGlOy7NUI3vDtGxwxIO/nGcgGYp4uTpq/BhQTyS8lRQJo+pzkCi5+mtZwoWaIZYcJO0LpehhZgcqGdC+w3BYvt/Sj666ql6hL47Lb6amwLIkDJfdWvNR3/15KWMRU3BC93yemvUESZHq+tYUY4EzycH0ugKXq08XsB09MZHB8QKBgFAaLnMYUAPWmf5vRhVp7+RTOUOtPf9uk6UjM1PqJeQGhJ5sDVbbaOdyMfrU8YASC2mkitlYg37zjJePquf3CVhH5ssN/MGNwcOqY6QrQ6c+GQf9lcdS4c1r8HKaRFO7VVX8vJWLVJb3FeuuRmPrlNtR9qQl6cJeiOmJtGvmiqc5AoGAEl4NSQcTnoS1V3fSCbYODYANvqdK/vOCIHY83fCAuztL4PmI//yP/9E/5Q5JGfuhaGlhs4/ponWVKkPrwntV0J+pEo4O+wzeki4Y/kzTIRSYNSEDhctYG3mQYbI9UvOQ9scy2DShuY7FRKmtOXeijP+AynQfA8t24fXv9tiiLs0=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQClxhN3b1UZdp2r5ge2RiAU7a5j0CQ02V4yXn8gll6tyWNOrblu70pZNpskGLvBFPlM6knavV9BrJwWCucw5imwkZ86Lz9phzPERft/aJWHu+vraS1OqS1TVuq6Qhhmq+fd05+0MHofnnsNQ4HgUnvz3t8CEpsadc1/JaxZEMnUolHf+9u2eBxemMQUr3/6vu1GQiXnzveMa9BBXCfKEYZt3VLDRLBAJXoJ/fE7AGyF1mVKVc2tcX8eaxUannc41lGUVgEuqDGqvAqSNwVBilsjsXYcdCEWtIO4v1ofJzjsX2piUL1apxbHYWdLiLcjk7BXXKFpjv3o1hJ+oL7NkmrFAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmPx9N7M52T2GLn3xmNawQZWzFhy7HigYqNPCqU8F6LHE9", + "privKey": "CAASqQkwggSlAgEAAoIBAQDlZOKQHk8yuE1qNuLqTUblDKF6KUszKRyheVJ6Gmc35UXj/t8QwZlHF5VpOMTklWEYqYX1R0MD81esscEoiriaR2SN1hnsEVScm7kRqdhjHsZi68deiXkMfPA60NMLWxIf68/xASKq39XMYyr9MGMytQzVPqjtAThls0HwkMZAnD7uK4BsUVRbtdk3VJSZG4xJ/atbYPocDBpLuyGDSbbNqIN22E9dybOPyYo6kUvsRTyP7FrpcCRaSxIMoGLZT5feW8X8uqqx/VfavgKTxDbvuDVnZ0GdCBmZFbBB86hBprLuiNfoekWaafvPK/LJn1mtNtM4431dwz3B7iroMae1AgMBAAECggEBAK0AguYSFcS4vpnGPyhZk4gXGIlbLz2sWc1mBE/WLdY38Zfblju65nB5VtN+Xu/NwOaqoz6yudX25j516Kk8xbCE+08FE5O4FknuH4s0vt8yTIg6LagcodBLQZn599BupKKyY6btJkocec+lUryUi5uoc783fIsSCoiYwrg9V2dNgWkuEIJKFmX4Q22EHx/bQ+y560rKQGU96tkw9ncSBNge4tNrP1E3TFe8VeQ1gjyq/tYeOkJIsiB8xxwYVPTuBZzIUPm2vYUqV6YbGDH34mNZjlUIE6tEQwjGBMW5ancrW+rILr8LEs+vpkOoA7BiRZwcdeOjv0Zklc5aKOYeC0ECgYEA+k1ihyddwiHuPv7MdPB7lvtK6QbAx84IF77aWVV6XDUa2/UO3efQ5gwy6CRwW6nDjv8DLHFi3pVQpXdqXMdydqXRwKZP9I7gIU5blDs5UTC0Rd9GWPIJOa2yLjca9yYXbeeqbpvEAVhbBUZ6EdiXonUHyomiNKzv8nP0RkCq/r0CgYEA6p2ozO5rmLB6qNP64wct1cut8S4ntKykjVKxZus7DlfaWMxe6IN0vTwbvKIvM0/qO69HF/IttuyWBw+YHgNYiwsdmwtmJawR8t8I0ydDyBewIjcEHieKkCvQ0/jvVd+lAePS9PEhM9h3s8uHdliempCQz9BH+JhGg/E7n9lY+FkCgYEA0DTc15YMbLbyyl4CzudXtwCzkGE4rTuaCb6NPLBYxyi5few8AKSbZTESi338JJNzg5hnGGn9Fy/XVLyfsiuJ8F4Au6LccY8Dq1DV5tjY1cuQuWp/xu8Wc28j/0OBX8LEzHxfjgBuK7xGgn3cfsnPYKi+4WBZmD2enuyLboDOfHUCgYEAmmIWcoutB7ORc0jSPdQ6iAXYNu1NOWmlek1g6T1/BegviOEqzsu55NAJ3G3Iq3Y5xv6GxK4bANTbwFe1nIJNIGm3GJA+ril1QiEbmH6s7p0PzOPw9LrGRipe5y1WqGZbGUxGQ+HsHEakNg6G3AxiiYj5kZYX1fC17hquRnhqQDkCgYBb+u2ykhNqUaCyrzFzizBYFPFboUV8gz7V6reI2uxNvVXQXPAzLZS/jVeiuQS/HubGEwc/yj9PW+DWFjqYKFnVAaUul4Z7o2MeFsEz9jf9/jOihFg+S+Vs+hjTwhRRCfRdWq/8olp6DfuIw9usN/72tmmjUmltXepDP1VnxuSG9A==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDlZOKQHk8yuE1qNuLqTUblDKF6KUszKRyheVJ6Gmc35UXj/t8QwZlHF5VpOMTklWEYqYX1R0MD81esscEoiriaR2SN1hnsEVScm7kRqdhjHsZi68deiXkMfPA60NMLWxIf68/xASKq39XMYyr9MGMytQzVPqjtAThls0HwkMZAnD7uK4BsUVRbtdk3VJSZG4xJ/atbYPocDBpLuyGDSbbNqIN22E9dybOPyYo6kUvsRTyP7FrpcCRaSxIMoGLZT5feW8X8uqqx/VfavgKTxDbvuDVnZ0GdCBmZFbBB86hBprLuiNfoekWaafvPK/LJn1mtNtM4431dwz3B7iroMae1AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmYRvGtLMb93Cbbaa5N39rGVaMUzpzkKK6Pqpqr2fMvyh2", + "privKey": "CAASqAkwggSkAgEAAoIBAQDHV1dmaS4iKs8SiZ+/Pt6QlGG5mnfeu0wriTdH4ofhYvYg+s7/Ci2T9ok5jkq5RWv9pl6vq1m8Lg8LRWZu3NN7zRxkPE1CvH9knGbUdSYh+cHWHSHq6u4/qANd93yAl6mhkmX779KwDkrHz88uMHagrKUM6Nto43I1fvPQ+U+tfFFHned/OKXvKiuLbOpKkHdW0vc1vXIZRRzHGsh7OjBYFLLrKMGwLkAfKBmYVC4W9Gi9Uk05aSTOynjedsIZlp9Jp82BByTKn2dycU3DVivr1dHXQZhCJgPk+qhRsRMv2JcHJfsgVkWYg1p1/MmkMviaWYfKjIE13T0yjdU8pWhjAgMBAAECggEAJeSafqM7287bciCrN0WSNVWfhhKw+qwL/LKmyYlsXxHay8YhlyWuKFRTHZfI6JMjxiHcGfSuqDDxNylIIYbkxMHmxb8YyLjgVpXMjlJ+nzLFABilm+xwwbUEftZO2nr6Cfa0YEHkgQcWfAkqzxLzWfO3pE6XdsbVrQmm+3CJDuce3ltwIvitgq6ZnhLsjqS0eviYjucm0poHpNhGTHwd+xtmNAZcBQXTiXTMrkd/ppKPFIHEMdk680sbOwFORaCOXlklnZ/aZzS8PcksE2sQ1HirBSFCyr0uTDPENiAkxG4F1PcHIg4mUJ215/YNWKgT1Q4kmKRu0CikxSd/EiUccQKBgQDvFjHZ1LsywGuAyoCMlyqazgHHeVAf+7lg/bo4ZIUDCINrCuTYL4EWlS3xbBu6g6bB77HGm8r7bEkqZgnZ8Ekq4E0cLWKFBkSdL4AdTA0y9J81WARqhKucLanfYkkg7KluOwDsQniP0U0JyJkKtBelL1ixHZ7SpV0zHqVlSVD4ZwKBgQDVcV1J/VO5uFbDz0FijyofcuPFwR5A8QTiusn/PlFXFRkANno+LWoztHc3MUWaswbYwbDzXoDClnOxOhGPiOEz0+57bmipUjOtEjY8qPL9fvh7QLkXTPO/GnFeAAsg5aD0YIhEUCIsAGuRSk2RLmHXEq8aBOX3ddayNtX6yYeCpQKBgQC1DH2bkvhfKk8+LBrEXASrTa0TPM5sKdbrl7fY1GXVMjEycgFxpCeAzl8IHvGwf9lbqwNYfslrM0kEjliPbOI7UbeSytt8GI8E6N9/UAP+vjeB0bEmaGj7z6h/vJHcGNsE2jGMt5lMbxaDfiBGdrIhKIVlOiT3Jro459AfrzFdqQKBgHPJa7IXmrPFLExMwkuVHmSxDp7YhHD2TpAwhCPSyo1TBJz48JeKS3KBE6r9L6UcOTqc2EEtouvschZSSfRzbLeQ4G5VFrHDxgS9PG7rt+WMW3+BPOdG93NUBOvZWjAeYZIwS7vDPMZh8/h9NlbrsmfZ2uNihN4ZLr6+wJWrfbeBAoGBALVhYcxFkxxEKeDe8cVBML/c0qPJExMGGomDOtf/9QSIsB27DfFhO9juGxuDH4ejxTz7ME84ZU2JvdPz5NCxGmn5wGnixKojrjcl+0DKTpT8TuLe5/LGyvKs6w0BoX7WeVUHZSNjIMOUjncxGqR5fpJ6rD/h38jvSvHThiNbhL0S", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDHV1dmaS4iKs8SiZ+/Pt6QlGG5mnfeu0wriTdH4ofhYvYg+s7/Ci2T9ok5jkq5RWv9pl6vq1m8Lg8LRWZu3NN7zRxkPE1CvH9knGbUdSYh+cHWHSHq6u4/qANd93yAl6mhkmX779KwDkrHz88uMHagrKUM6Nto43I1fvPQ+U+tfFFHned/OKXvKiuLbOpKkHdW0vc1vXIZRRzHGsh7OjBYFLLrKMGwLkAfKBmYVC4W9Gi9Uk05aSTOynjedsIZlp9Jp82BByTKn2dycU3DVivr1dHXQZhCJgPk+qhRsRMv2JcHJfsgVkWYg1p1/MmkMviaWYfKjIE13T0yjdU8pWhjAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbxaZzmNDdW3krQy9tQQhE1QFuuoRrvYshihX6QgNa4Xg", + "privKey": "CAASqAkwggSkAgEAAoIBAQDBE7PBwQ1+5VT8oPmS6d8bTPSBMinWrG8UJ28Y8d/Lf/pjz2iCu2F88FRtiOcqkqhGU1jyj8jAwRX5YeQF/OjrMYKFv3SGs/mmmWOwA9NPVIxAI+MYDsrGZSCyOq7bbEwXByEgcvqTWbF5mpTb+n8w81lhdTVQ0pw3m5EJHKcVsi6u76QvQ8CT5ZXyF5fgNLQSN7Yeby/w2AFkNnKbtN11ZOVs7k92AxxwH/z5iniJlydY65jsRQeixDbUlyJpfJnyx5SsYe/Lxc/rcnhqirgTXlDhcjAiGPiQqlTSquxCacQ0yWauqJFTLi+h/KcUBK11d0nge2wPufelqZ+e7BRhAgMBAAECggEAZ/SJtmqRL5+ekJ7DgXx2aaaXhvBRYopZDErnIFEqo9D2KcNEjA8DwFdNveQWQu/Ptn2tyHvuJQpRIIK6WRcA+ZEgq46X2OcSJcc0y1Jj9bSaBvbLkOp19zf/0LaT6wR2O3fVODlv/OIwEj9OotpOnTaJC1YmLKwY/D/AaV2KAL2M2gosgcZyyIZFot1AenVcoxM9WXLHeY939BNWajyOHqFnRqt5CW3NKJVukM1KKtn7doaYY/63t1RMhgMxyiqRZlcw9iCzz6Pd9Ppv8n9ZaboHwhovHPVT6jbajxff/E+Z2bD73kxbJQ26SJV+jsnyKWkIyJFQSA1vb+AHTZBUgQKBgQDy1Pb9AimUoK4go68Xl+sB/RgAdPLBKjqvQoaj1PyXdWNzlZEegc7et7ZlZYXa0L4JSWq2Q5g0K/fiMO7/io5REE1PFBNLwrZvuR7AY2g0Dx7h5dQK/rC188ibSnfFVOh6uD0YFzSaFypwISP8JA1ldqcujeIykni5fO4WeO2sOQKBgQDLjAfXTmVQn9HqgoWODfG+F/f+HrnYzEf2RaXOiF0Av+sdTjIOG95LSM/OhqBYTiA+QSu4MsX1nsmiAR4lw1DPj1h0P+K69W4sLA5L2Viq7LO8JWgwJKMt0sQtP+weJdmyAdht/xioiVUF/ZrgN07XmwTZZF9hrA06Z/En+lX5aQKBgQDwImwRLZdC9FbdziBzO3daIxgeM4hwPzuDX01YLGKRwLNVdP3qZkHV+2SzBt+E0NJsyp5tmZClXymmE+/04ub0ASQCZH7kd6wD9dQUOvmsKZvHlojHSrAjbu3dq5mfmeTAnvtDnIcXLnt4IT29tUVOJjUTk5mxmykpfQLRVErs+QKBgDZkeB/wAiD2ZFj/ggMA9O2waAPPYChwBnboC7PSOtAdeQ2+vJ+KkO+bSHTPAwA1+GXKco1pe/7z7LvPAqhitjCRBLkj7Um6ljNVnohkT051rF4FvP7Ie5aeMPBKmaVAxhjMZ3KVbZh0AnV0XLO38+inszcInHh0SqCl8AqX2eupAoGBANPWOjAv98XqSJYimaTfTSs/Fkf6/xfo3bUOsarittbjnAz3NHqPTXYeSrgSSQC8UhzkD2aL4CA59A0ZIBsw9k1j52LfZ7+PT8V2JTXJxzfGU1bBqyyxJluIqoEn7wrQTx/n42RTBeIDuP3CKNwsu89rZTWzsAZ/eDsly7dSIaLQ", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBE7PBwQ1+5VT8oPmS6d8bTPSBMinWrG8UJ28Y8d/Lf/pjz2iCu2F88FRtiOcqkqhGU1jyj8jAwRX5YeQF/OjrMYKFv3SGs/mmmWOwA9NPVIxAI+MYDsrGZSCyOq7bbEwXByEgcvqTWbF5mpTb+n8w81lhdTVQ0pw3m5EJHKcVsi6u76QvQ8CT5ZXyF5fgNLQSN7Yeby/w2AFkNnKbtN11ZOVs7k92AxxwH/z5iniJlydY65jsRQeixDbUlyJpfJnyx5SsYe/Lxc/rcnhqirgTXlDhcjAiGPiQqlTSquxCacQ0yWauqJFTLi+h/KcUBK11d0nge2wPufelqZ+e7BRhAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmNvMtvYwxgzJwinp9br4AeNSJgtK2XD7AF5YECR72R9b8", + "privKey": "CAASpQkwggShAgEAAoIBAQCd+JwQZTdHX/3+YyD9DB6i25z1ObF8j7T/BkXF40eX0AmIf5sYjGBqDnj/Ybdnitq0qQY6NQM43fKwHTxjcJ15z8rr2T0jXDLftUx80Szs/WOFDeVjGkj4jMfEJTHpNstrtS4DvAu7zj9VOzuwQZ9dIgitmVDup5hDFlwXneJnMGQfgOBoQ5+N0pcpHmPhyGRiUUReaNP57uOm27cqUDRR58aT1vdmIW5J62UvktsGjPgA27kQbjj2yEi01fQux088pKHahmQsvbIYPlMYoZ8k36zmY38Qw0RVwaOcQC8mDLE4+Qp3JJg+uXL62b1a/XSwlNKzEai34RXp6aaRaHuVAgMBAAECggEAFidyg54eRYVB0rZGPxa/CSnxdja0HHru8EEJ8fmw5aqIW7tBngy5zMXg1Df5B61ihKmbtPgQTp5Z1bcT7AI0I4wvsinSOC5K+DKt2mdffJEArv1G6UIbb7gWn/xzZniHyMAtBtsNbjY7jZF0CoD5f48xVl9FCWM5qFbvbWR4Bu57BFrvXkdMrPpO/efcbmbznKLRuDK7DumOdWTz56l8hu98yGL3Ve/28bs5trNGBjX6dvkHIiEA2EsFLU/YkyVeFYjDvHJI8GYYkCb0yYbmbke1Rw9cdTNMBxaqd7//q0SMqPM0hMYqWa8b/nGMoHF8DjKVoipIXUoH7rf3a/IdlQKBgQDJLxx7mW/InrbaaWU3Myq7ugo0pb8w+RZkTDOhWu4DKsU19GhMq4NHcOTDfuEk1S7zQSV01sjBhDuvRmT3IkW4GEcHhqrMjwU6cAKVFvyn8qnm96X4QwplD/qcYuQlZ3osUn9J/pTHUasQvbJRc+5M8l1h0Tg0APYuXNi2cO0yVwKBgQDJA1VxudXYpzgmB099VohvJtTE70U/BQ/xcVh41uSfuAcU37mLXmo1ZUpi6S5c7/CQYQZXhe7OHmh14Z1AJdOVjqFcyy5OUJ8fN0YMtNyIwK0NsHFHDz1ymyDsXKL/JxmN2uuTSx0rF2iGrvm2U68hg0LWcUTCk5arenaD5CoF8wKBgCd315Wj51srT+IPVSz8G8ESYVgswBJie3MXw/U+unzikifgl+maqDmGu0pjBNZOAFT2jdubG21jfLYJEFuvXJAeKykd0ToqQLNTMB6BkPV91LkcEnJe7JYhCWBOwkVYRI6XbKNej19+9RlmranvHWv5DDrZabZCDgnQay93fgEnAoGBALvMto567dTtXeMBn31dVDhskgqv9QUMyLltiRfUxWKHf248G1CfVCEw0g+ZBazkqt9pFpC828CM3lGMCOt+q7AlwpI8bbXTUubKMFL8wrGtOcD5YMvf7CvfzSGm5s31jMVgjAlf+w9gXlK+tSRoCM4JoW9SAci8NN9emc1dZPmLAn9dvNnOAYPPl6I5byHgT6m3qOq77WshzfpqgRUCxQ+kSKKplwUZ84T4+cM8zsEnxePMlPdNaRzKvkHzxPDSSAWiwtPIl7hPjr5cnNoj4K0rokU/nkq+NiZ7pfEFroajOzBJNMtter1kcfGpWsjuCM7DXt8VUgN4JrwJsKxwYFDC", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCd+JwQZTdHX/3+YyD9DB6i25z1ObF8j7T/BkXF40eX0AmIf5sYjGBqDnj/Ybdnitq0qQY6NQM43fKwHTxjcJ15z8rr2T0jXDLftUx80Szs/WOFDeVjGkj4jMfEJTHpNstrtS4DvAu7zj9VOzuwQZ9dIgitmVDup5hDFlwXneJnMGQfgOBoQ5+N0pcpHmPhyGRiUUReaNP57uOm27cqUDRR58aT1vdmIW5J62UvktsGjPgA27kQbjj2yEi01fQux088pKHahmQsvbIYPlMYoZ8k36zmY38Qw0RVwaOcQC8mDLE4+Qp3JJg+uXL62b1a/XSwlNKzEai34RXp6aaRaHuVAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmXuRygXg4acMEZbuDcTE2DKXSJyMbsJ16Bg1oKiFDnCby", + "privKey": "CAASqAkwggSkAgEAAoIBAQDRMeNG+9qg0JUaJpJYnsWljTuIJ47SfYOhQ8SKsfBYlcjEAvWij2F9KKo9BpN2oI2dqLCDL5ArGJ+33Dm+e40WEhRetW6Oeev6hgh01CetNVgGS8LseeaTzpWN1HjslF1UWCNs5NdKVFp8WWhIELbyfnCjymxafpRkczckfUMcbhvAJ1xmrKwC3ItumEtb/GqxBln/4be0O4aM90qPnXBDIbQ9ddWL/31USL6nnbjy6t7AOie7pXL9Bb23tBXcsw3vYprGGCDcluAdMiFt792bpF3HSZlYhh5Gq58ac0YDoNWUL4A4b4FUb2YGlmX6qIqT/3y1x9RDZ5ws8cpVR463AgMBAAECggEATQRQ6JFQrGQegMIynu3VVl3ozPfDXTtYesa4VVetZO/AOmnchTzEZ4/RHSaOo934RVMVqTaZnUQziT1LBRX3m2iMl1G0oj/A4Tr3Ygu5j8tT3P2HhghbG4+y/8R5wJ/evG62nCCkInlr1twTyHRe5mgmkCa2PZrchx7j7ksvqgc1RxGd7T6IjcH/ed/5bMMUdUhR+IPDfpqJdATu2PzxgsGyfY+INPIsd4PfJEUKA1WIqZL59ArD69v4es+jjGQ4Yjw2Eo/wBhTje7FZHucZt9rrIrTeoqa6syAMLe3tcOzxelC+mwU3GLg/SLTByKBXvHWtPkmz5bDu5wwiu/s6AQKBgQDqL++xlpYWdCpPG6AmkxC8QOYaxqH61UruQ8OAnYvFbZdDGbTreESun0zqKVjZglu6mPsgQfRIvZkyw41mAOBENKGwHFyOUMbftQIfD/KAf2ysT4csDVd8DD16CPjHbPR8xfc5aPo0RYGSHnrOjeFFrrAOLZx1SIrktz7o3T7yiwKBgQDkrgW0VOEMQof+kyUYbUlgbciSvMDMdrovjv3GO57MHEwVefiI7RVx6h2Kuv/MVmu0Hs3uRrauwtIDlP+oxVUdLv3F1nxk0QXiWmK3f/CKRx4ygvay/FsjpssubTZMsOBEslr7pqzKXTIoGSA7yBZfwH/haxEI6tp2BFnScZq2BQKBgD35B4ZIYll4zkV2+w+aNYCL8Bi/3deiIB0jY5Yimv1Y/gFsyRrTDeHkGBeTb4bH33xmxXYI3httyR/M7htDOhXyk6MmLjwfFjHXFcOglbz5e4mx1gSLV05lctNbknI73As03DKeHDA/AIXpePg2RZoKG171JQVIeDEEaSp4ehL3AoGBAK/hHCgPJCuOvBPTTjOUUlwk85/QJqTbJ+XOH2aokkC//tCBx+JgHh9IBcKegoDBcwLMsmvx3S1aT7ZLkbpXU1gnvSy9A11y2gi2pbgmYXWorxQAYAdXSi2Iajrh6mJfo42Sc6GbFshpl1r5wC3afULVxkU0WJy4LJ+aRw8xKuGVAoGBAOUPMQG+tf3Veqay0/4caZqqNvS1Mve5S9pOlNXoBhWnHAFOuKAgKjzMySPqs58giVMCFDDi4ZsrmDECCzBQ2/LF5w6uLnnR5GRLw2wAGYYyGXViKOCunbRmVHSyM7yhGm4URobU2RJjBLULGtcZ3dDQzV25EcSLxaWWLlQLOlYC", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDRMeNG+9qg0JUaJpJYnsWljTuIJ47SfYOhQ8SKsfBYlcjEAvWij2F9KKo9BpN2oI2dqLCDL5ArGJ+33Dm+e40WEhRetW6Oeev6hgh01CetNVgGS8LseeaTzpWN1HjslF1UWCNs5NdKVFp8WWhIELbyfnCjymxafpRkczckfUMcbhvAJ1xmrKwC3ItumEtb/GqxBln/4be0O4aM90qPnXBDIbQ9ddWL/31USL6nnbjy6t7AOie7pXL9Bb23tBXcsw3vYprGGCDcluAdMiFt792bpF3HSZlYhh5Gq58ac0YDoNWUL4A4b4FUb2YGlmX6qIqT/3y1x9RDZ5ws8cpVR463AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmUFeJFeHPBFxQmAuiXxajjywc7UgEgxMfqoDfL4Bt6jGX", + "privKey": "CAASqQkwggSlAgEAAoIBAQCdqL5vlmpQHlWrkpjZiz/hZq3HK6PKTCCy5/q06uWenHU9aPsq4nCfCR8LGVciqucq7wker+0WLmioE3evR8qYyUHnkycxXiEaTFSymSk9DhCtb3PGORDzmdNRlCndLmDLitkbbQzmD/qia1v0uxRayMDZn7qFsmI3kSgLmyv+1GidBulu5Y9DURgrWCMqpZBiTUSNy0SWj0u4BC0GHDPDmYZNHBhhilJqAyYNCE+74N8UeJqkpQalx3zQuXYg9Tm/OfyrRXWJPuETECU2rORtKNXqEK7iTFllRbh3nq1hLcFTVcgq7qNXUogMu3c34d7EPeGTbNOBSG4pE4x3mBYdAgMBAAECggEBAJwS5qM09n3l6c11zJbfgRe0PChFjVnAz0YM3GWpfDLulCl8+dhUXkUyFGc6aMZLBZm9FPwqELy6qKRq0TrWCTwDUJjdVhlLI94S3m4HrYlhmST4hlYfPCbLiyThVig9t1kIVTEPXYuLGgUb3uaBJP9SaYeG1nFwTEbSDiCfNoiHVFJdp/3AXUyxpwd7q6dNoPcquHsU9gE420LjnU8+bD1aYez6mkRbZ0pOoLHq9peEJw27j993Coidfr9DOyXLM28AmCWHhOrF4MVAim81pmhzy1hamfy6xc5ye3IsnQdyMt/GOjH/e7jPxwWNICIfx/j6RXaa4KKMSZNVNcGhX0kCgYEAy811aJ+A95+W7FkIjd5uFB495jY33d1j36CU6FSCL0tmiJh8ZvD9XaJCW8ebLbPzWl59s/LXVs4oUKHauYecKgJhCE8xhn5vrOVzQYdED678LDS7b6+4tGvFM+bep7gKyuKu+g2yPBz6oS9Ggui48AjgTuFcgcs51l5vVDk9MTMCgYEAxgnXTd0JTfNDp3j/UdvnhnmBDORr+k5R7JHrNxO+it3drylhQ7ucNliRFqk5/hMHTmyPkzo9dSEN42UF8voXX6wZ4hkD5V+qhFaEt98LLmqPjBMEGEUwujDQZf2Bf8DkzFZ2Y7N+8IbzTnhtIIGCbq13myr2urJ6ePPBG2djO28CgYEAjCJHM9xRKnNSrEsABcTG/hBZUZ1ARs7+6HqbSTEqnuiCpTPsfkAAh0yVwlP60K8miqHkX0KAbRCuSdsw8VdcusoN/E+v5yGzGjhfStR+qSYSATd1FnPGVlCwNWLvAHYc/apm1EtsncbzUreWDVeGKo5/5d0x5ZFewJcIh+ofuF8CgYBI3TwTkP0oahX9W36Nbtyr1K7PwIeeDA0GftXNaP1VeLZlCVOZKUEbmdCgRtloizXH/BeDcw1DuEq03Omoca4B7H+FefC+B0nk8TRZtr4VcO2p+yEpkOORzf4PWIu6Jo3IRRPAMT3GX9DLkXGNYTlNYZO9SryHCr4XHJBzdcHEDwKBgQChVvIRDj5TmmO4srMrsMG6BUH+HrAV13Hz6NSKMN2RGH0WwXNC22EYCEWG0liSNRCopJnKEnzGvJxgQiDY9Lph8KKf6ibv6u70J0d+K8Ae7nlU4/Oa1pc9FcQUW2OrIJ8ceeAsOpOikUuGrKHwIwh9zKJmaRLj/bufnBzdG3nhcw==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCdqL5vlmpQHlWrkpjZiz/hZq3HK6PKTCCy5/q06uWenHU9aPsq4nCfCR8LGVciqucq7wker+0WLmioE3evR8qYyUHnkycxXiEaTFSymSk9DhCtb3PGORDzmdNRlCndLmDLitkbbQzmD/qia1v0uxRayMDZn7qFsmI3kSgLmyv+1GidBulu5Y9DURgrWCMqpZBiTUSNy0SWj0u4BC0GHDPDmYZNHBhhilJqAyYNCE+74N8UeJqkpQalx3zQuXYg9Tm/OfyrRXWJPuETECU2rORtKNXqEK7iTFllRbh3nq1hLcFTVcgq7qNXUogMu3c34d7EPeGTbNOBSG4pE4x3mBYdAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmThg3JJ7BLnA5GVm6oxztaL2iq6k57LL8E37i5nY1JFxj", + "privKey": "CAASpwkwggSjAgEAAoIBAQCt7YDoUaRHlN11UD1G8tSsXoyJQp7PlX7QJIkd7kCeZHp6MwT22ATBjXQlGewovzoo4Mod7g3NjbCGE4Todurk8tSAq8d2lVZeEOrQ8aaC0TG58JP88FzIOzJHf3SrJCqo3uGQ37tlNYFIGHnS62/aWC7vcZLvBzZw8qUwbXaOjqaB48Rz92q5VbGEPRReYsDG4j8+0EqJaw/dSv7K6xgNiNgMSHioVVkrk/oYNssY1Ue7BEjUWhJJaDebsomZk3F4w40Ycp/Gttq7krCTmmdT75Kw1MVVaSrp00ORE66TJcS+i8PYAOe0frzuxfUmQMyq0y7I8LlrEwO2doSa7h0zAgMBAAECggEAOMI3/hiefsmi16Teymd2ZeXZAPYfs2h64Nv7bywQJGBv468AoLlwG+XYkD78ZXO6PBrXepr0IC9r+uUly2L7Vsmz9WWZiyZC8CGfL56ckzZHfwF2meWqsaE30ENUxIDh9wf9HnUUx3uFfAyYvO8eKmf6sSMkKyL0bjmRFNO0C+MRmNgw5bpx20KQqchsQQOlECUXs5g5Ro8a4szhwr85mflgR7kdMwW6pfNoBZYmJs9hHqXVLyk2y4XW8xPYOfgI+sdMnyUq0HYttJnlTnG/HMLwP4U+Gsxm2H+wzDqSx4uqcD8o7oXiRy+elvJs5hn2Ik4tcMzj/14kfCoKhter4QKBgQDfpuIrVOErEcwVdaCP+sUCq/d9/TK+MkAbUmNqVSagdarhZgI/si2qKVoOYRo1dpnneaHdHR5v5Eyh59qTKz0SGmmYqyw8NoyrEdFpSnzGSWddCQWM9NTLnUc7NQjY6SLei8XrQ/JtsZ7kqnhb16ItGYOaHLZLnGUvNvgC2saDwwKBgQDHFX5gFfxWvGVgrqjkwOMC7Cw4ViUJc86jXSuiTTnBhFILXkI8yk9nVjrzVAXbWMpSPQQZnUcHvDR9C6g8K3hwf+xv/6hBVW268oZT7wecGnzBGWXXgSTB30qaCLcqPe4MQGxedBAw0ISvT6BfWsVOotGvO/VsyWwtT5iqLJ+Z0QKBgBfLzNKpdE+91AYQfuXy25VeMLYSA50jAZkmmfdNWg/GlUjoLqMSVTN+tNtEz6ISnWt4kJVTLNLg6pprbeEsv5G2h7e7trgtYagt/CcEyuPaGYpXlGScBCwp7tNI4Ekb/R7KpmNS1m9/b5WK4cV72wCLb2otVeQTntx4L8k199s7AoGAKdFD+F7l4Do2eTZ214YEqSp+p17A7NlcgEgj0DW0egeXTDgCZc6BG02rmEz/5fEinl+eqtq0ftVzmQiH0Au5grf8LBJhf0e4gtpKiPreeFW/+rehAsFnvSlv/Cb0gnT7uasWmEh81iQWmtR49U6Vv0zICqzngnBUvrfHc4doBuECgYEA3JvoqCVOaBTZ8LYgZrnFPjlVRKvfOwTjK68ezxfg8VQZBrll/hM5rLjTEN+AccDB3a79cMV3FkXAKV7Wf+f9FFoMjGMtUwpicov1j+Zm6nlLd4B1iQyhruj+XN170cmxqYLJGw5AKRPGa4VcWpvJTOtF48pO4WZ+riKPRYjXK+g=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCt7YDoUaRHlN11UD1G8tSsXoyJQp7PlX7QJIkd7kCeZHp6MwT22ATBjXQlGewovzoo4Mod7g3NjbCGE4Todurk8tSAq8d2lVZeEOrQ8aaC0TG58JP88FzIOzJHf3SrJCqo3uGQ37tlNYFIGHnS62/aWC7vcZLvBzZw8qUwbXaOjqaB48Rz92q5VbGEPRReYsDG4j8+0EqJaw/dSv7K6xgNiNgMSHioVVkrk/oYNssY1Ue7BEjUWhJJaDebsomZk3F4w40Ycp/Gttq7krCTmmdT75Kw1MVVaSrp00ORE66TJcS+i8PYAOe0frzuxfUmQMyq0y7I8LlrEwO2doSa7h0zAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmPXXypPBfaZScvDjqtfhaAwnufqgBdva23ZS6vFnpRE8H", + "privKey": "CAASpwkwggSjAgEAAoIBAQCoasuDjj82xdcy8Y4SiDWVph7YOC0fX3MF+6NvmixvWiUomzN7Gvmklgeg8gMWcAmWZuu2cdKWltoqCu7Y78oFCXSkOCD6xKiP2q7gQG0yCS4b1YVAsK5vP6f4GEixO/orRA2uuqJgn/7iy/42uNGt0crr0e6AlgVSiGNyw/lgMg1GaFF7E9S21rO+/Ezezp/hB+R7rXgZ5n0YwivxblivZw0JEadhwn+ror7GpRPu/bJYLo3sVCqYM9CtAE02cNS3/gSYf8NV+nRFWY2DSIlsbpuH0awfFuEszIj42wCqyLos1D7+/UH1A+4DHaVsp2JYQZZVU9sl7oFoY0j2XoTvAgMBAAECggEAI7J3LoxBA9gNVAP1LCJo0S5jzUqi7cpqc/MxYh9YmcWOqLu0vrwp++O8/DUvyFq4/YMVJRedHkQdO9oTZDH3LPgjHAe1ndF/NPaSKIAfZQKjHk00sFCCuJvSe3iSN9bRoMgM6mMutbJT8ThxyqGD+AbGrxNRLTofKK41/gZh3iyFqqOYDlaiWc7mDGg2YVlGEjiaAAm7ZDHpF733gYuwVQa3f7dhKQA1ptmb4t20LQ9OjLbYeocQSDmNfljF+l+7xjsXSWrLxjf2nVhd/PYNfKFJGNGouaLovAaDzESz0g0zENzpeI1LRw12FwEg2711T9rpMVubOfjxhOIBOVkhYQKBgQDVrOXXmnUYYuwxECGyFSGR9Bb8p52azmo3HkEaDn6n7NxSi32LTVfCNbXLD2iiYtIL1ClysTQ9ZGF3Vv8RgWFOjHtQpC5WXdRaKZrNHvpejij8Vv91G+IC0tCoNi6NNR+jLvR0+VC5RSpZErp9jwyirqpqK65NVQaYGLOJOex2XwKBgQDJxu7O/BXUs5PSec9Uc542DiNXm6xuVYFfePbYp4RXtx1qTA/A4pPcrblyf/l4l4OVVtxysGXslsVl/6i68JLnM0pIGOq8ETLuiTu7cl22pCHM7hfw4kx4Mxy0IQDkV84Jxt0Je9ioFXktED9U9t12H8qSFvHbx4D+YQmEACXbcQKBgHAK+nakwnPoI0vS1qhn1jOPV6JiTg1H4YBHeAGuyhFJ7XnHNSyfgL4QpeP1j3te8B9Nv/IpI2hxw33te1B1lE248kyl2rpk9x3UJR0b+lMsnic7gzaoSUoLu2gJCT34Nj++NmdD+GU99GfCn1GJeimwByInB337cLq+cR4q5mhnAoGBAKSn2ai+vXHdOPvAuxfHYYvq7ZxIROWkkPY/1+/kg3Kw0ygy+YgFXXPvsC1nkUR/H7l2MF7G4+W1A1DA2Af02WwhxrQe4S6nOlC9XCkSorawKYT5pj/D63MLAplbdUbhABmqViWvEpXXMBM99vB2ozIJr1yXrLYUj4cF2KYHGN2BAoGAKWfXfO/SqZxm+iButeCs0aPY9X4moP3NKRxR5wWmEuXD0xuUMmYf2iaWytD0RAdIdBlurswebdArDFDfdku2WCX4yX/yWYhO6ejU1acfTROtXzUpGx3XqA3Of8Dg8vf6VbJfKtZi/IsaqhgDSZj6eI+CDgal4uy1w9EOYUT5m2o=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCoasuDjj82xdcy8Y4SiDWVph7YOC0fX3MF+6NvmixvWiUomzN7Gvmklgeg8gMWcAmWZuu2cdKWltoqCu7Y78oFCXSkOCD6xKiP2q7gQG0yCS4b1YVAsK5vP6f4GEixO/orRA2uuqJgn/7iy/42uNGt0crr0e6AlgVSiGNyw/lgMg1GaFF7E9S21rO+/Ezezp/hB+R7rXgZ5n0YwivxblivZw0JEadhwn+ror7GpRPu/bJYLo3sVCqYM9CtAE02cNS3/gSYf8NV+nRFWY2DSIlsbpuH0awfFuEszIj42wCqyLos1D7+/UH1A+4DHaVsp2JYQZZVU9sl7oFoY0j2XoTvAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qmb2ettwafKhxxyNNCAAwZVfCBnioFhoArRA6EZqcitg24", + "privKey": "CAASqAkwggSkAgEAAoIBAQDXzYCtBwWGMpp8RVuHik+S4QtSuO7jZbJbx+LRzEx1Et9rNDjc4LxGUpWzjKLRyKTgoj82j+0TILgnRcN6vAwagrf2Je53QxDXfZtDWC1JF/2FX2b7SL2Pv+cQ+4OIboJrYMf1FyLeg7Q6n8ea8S6xV5NPJB3up+WCc/ntwBEySt9HNhFXsod3EgyZqoHpgcizE3xeZcU78cLPDAYUQi7V1vDXdvSVtTNG+AFIUDFuc/uU0yHAvatcA5pWGsxxHwdweAkhnK+uSIK/rhVTFuT/tHR9xgxbE0jMWvuHQukPYcPLv869nxQPA9qQ7MGiWZWvJRttNgZcabAvrGyZvwiNAgMBAAECggEAL91c1QPhrco7iaS4kG+VBrbzk/2Avt8nmEPVg0MVEkKFW3nRwuv11oMqwRBIbM9cApb5/lgd9UgkkFFg8jATXy3vL6FqKvmtGp65eU5tfPDdQl/Or52Krf+aeKHQosogE0D8GNhw23nK19Xop+0mth7+hWc1XGHQ/gZLQPiA1+5rG8JE1fmcYKN/W1kZWlo3kuj5JDmwGug3vOGR+Gz1+aXkkvfTWmR+xp+YgCI9aMeDgOn0M49HffBvOH/fZivw2VEK8ul6x6d9JKadrAPTq0yDXU/aDu668mdIgdEjwV2bJz6A+STqx/DmVCUGAWzwhCgVKbcPP+m82/Su/v1u4QKBgQDwwXnsGPfyHyz89GilqlZ8NWoLmL3y1TDE0OuUYrKuvm95ZW/N7k5RG4MQLcXY9UlzI6Hs+xQEITg1q3V4g18E/E4e3PFf0HZ+yE7ltWc2qsubR102g6hlQoe5Us+JUCk3PVnkGoIHQkDP3KuXWWKJCgizHUMMHLvdl13+xVRKqwKBgQDld40TxSqxDzJpIcwiEXUXkPRSz7/6nY4VbokBgj1jg9KTU6ikblftqv4LdIWZOvI95ynKKTY1lEMPaSWujnLReMejeJSHN4dCKt83LYKZ6vS0+KRxjE71jXL6eMEMS4Zh6+vCfUA0Kfef9dnakVTZV1QJUdjlRiSCm/E/aWb5pwKBgQCrJwAD5eQuThdvZFkYnLWK63YN9HHktcZLxLIU9O1N6Lfat0/6N9WZN1O/JqsmB4pFvikZDY03Ol55WQDTwaDFLJBkxHEbyljS3JeqGYHcjSLdqqgLXyFRizBtgP9lAIWsbYL/9BBIFMN6gcfCeprgDTAOFVlavPqZF0iNG79GrQKBgQCUYvbr7fhpfzZOHfjvnvJlRut4EbhHzFLxMQWP4DTqgXhOpS7NBj3+BzE5HyS1rhSwSygO/w97HmEvOgOQGbXOF5ih8Xu65QGmnCq0d82Y0wNjc9aDRwRYbhwINMZBuSUxdWqD3pMCKJFk84rpeEmyMnK5hCAKQ42gmE8tfm+EyQKBgFdfx1FBrtCRBEY9fGZr7Kk5VgAThm076liVhpu2dr6Himpp6QImt+d6RpgeerGuGNrbcphQ5KHXDPPq/yyTsZHQ1mk6P8wME4ETBV2ACK2AH512jaVGyj5AwGI0FUeU+NLnY8o/AWAxCqShrWgKjOb6zVaVviKE3/YUNyEGGwRd", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDXzYCtBwWGMpp8RVuHik+S4QtSuO7jZbJbx+LRzEx1Et9rNDjc4LxGUpWzjKLRyKTgoj82j+0TILgnRcN6vAwagrf2Je53QxDXfZtDWC1JF/2FX2b7SL2Pv+cQ+4OIboJrYMf1FyLeg7Q6n8ea8S6xV5NPJB3up+WCc/ntwBEySt9HNhFXsod3EgyZqoHpgcizE3xeZcU78cLPDAYUQi7V1vDXdvSVtTNG+AFIUDFuc/uU0yHAvatcA5pWGsxxHwdweAkhnK+uSIK/rhVTFuT/tHR9xgxbE0jMWvuHQukPYcPLv869nxQPA9qQ7MGiWZWvJRttNgZcabAvrGyZvwiNAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSasEmREwPDaLqB8nmrcP1w6bSd3Zg9LZeSUVzHwaxETB", + "privKey": "CAASpwkwggSjAgEAAoIBAQDC5DJehI8wKoPMeXuh6xs3IS9W/DLrz5pKUbrkU+YNUtCTLAW6J8CB1clGh3F8dweJ9vXlfmd6ihLyQ4EM58yFzYQrG5w6YGA2HlZO3KZQ1foDgbEwR58wy/mfGOO8zbftzkAP05siee8ruVS33mNsRpclntsarbZHNEPWAjWXyqKFTP1aJW/r+ovnOjBgTGrJLSb0rOrPt5F1muyTh2ymkZWlrBrQboU7YBeDZj7KK8FaN/4gNJmBT8qI7kXZCWMGk4SWamB3VJ4MAR51asom2WwQl4gqAcPLrw440CjxzSOiQWIJGPIHSw9AlEWW+xFXmbXIi4GEK0HRiUZ34zLFAgMBAAECggEAChS/vj/hID6yvpryGDgPGlTvG/LDt4rvkjSUFEd6uOm1vEckrLJttMmYNbu/1Q5bJ3nM0mgtdhs6S6nOPRqoa6tr0McG18Ywc9wx3rZvK/NFkXTd839g7qc+bEpfTV7eysBGdAsgFTJ1eq+FgFVSk0E7hEipUMH3kctUTveiSg2sFkGDhtYmGKBO1TaDXnbkCyQDaKspSDBP7fEDiP156fRwMRT8CDtW4BILaLs9wV8x0/PLYVlz6wf56i3/gNhvqDsbd3U8axVIQmrXullosqI0HFl+Uhqhakyw1umoLA3dsklAUmfUmGue/5fxLNCGJ0QFyTpVVf5+zOLRaS4rwQKBgQDywKhnTx2vrL4z3ltiWMsZfzD/mIse0QpIO4UhUboFsH7bsm/kn4/vwVUzFo1tXDG3Mp2Ph9AsP3PTlRcCSmPeGKyyNIP1et+MMxnucIBqrE7JFMwrq0YLdpDxynmPDlfZ1H0agA1YSUBxjf+ETFCCSfglHiZCwfoMobRgRdYVWQKBgQDNhuaajDABleXX2CLgYabi4cSu738jfeB6JGqQDVFWFqtoux0DziRG/AMT8RotqgQRd/skp27AlzNXTKePw9CGilBD6ogIL9S5EBkEbo1osD20dikaEjhbreqsi8CLQpsQs7eypKw5NrM2TLbUkRHxZCjPjTy500WJgnmnNxEfTQKBgQCObpYgz532dp+/JUdvQ/QfCK8COUnfkf27dhjd/Ort7anxVBgtB6ZXoZNQ/3mJ4h9Vg0BJeAGgBLb8PS0b7fP823NwuDl47lh+FXmwmpfufx1XBHnrYXoevbm79PYwBtVq/S9OPjYWSBykxBFZWcGfQLF1beQ7JT+G69Y+6pr7OQKBgB5HTHviQURKiBT3c5Po7wQnzKkVAX8CEWsNKGHWhHARYOlJ/6lK2k9W20E52Oh3TqggK/CndgqLe/XVhi4I5BSeFdsblzTVjxpAg98CRnTw2fZXHhEINCNViOgoopIhmuSoBV0dI34+T8KlJJ5GTQVqAxUospSRyoHKpg97bltVAoGAY49CkW6RUuSD2TlrdlOWRK2+0n4sJDuCGmLeYAMSm9kbASKQY2kqwgXBAU8Ch/SmGxYfAzhYd56MDsTbcoRS4eaw863uPFNkQOyHZa2gdnSho8Ry9PsSnM0geeRI3qA/F4y2ishDZnNahOcL4Xi9WXX+UGkSVjwLva9H9fzD2W0=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDC5DJehI8wKoPMeXuh6xs3IS9W/DLrz5pKUbrkU+YNUtCTLAW6J8CB1clGh3F8dweJ9vXlfmd6ihLyQ4EM58yFzYQrG5w6YGA2HlZO3KZQ1foDgbEwR58wy/mfGOO8zbftzkAP05siee8ruVS33mNsRpclntsarbZHNEPWAjWXyqKFTP1aJW/r+ovnOjBgTGrJLSb0rOrPt5F1muyTh2ymkZWlrBrQboU7YBeDZj7KK8FaN/4gNJmBT8qI7kXZCWMGk4SWamB3VJ4MAR51asom2WwQl4gqAcPLrw440CjxzSOiQWIJGPIHSw9AlEWW+xFXmbXIi4GEK0HRiUZ34zLFAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmVzpVsXAKu8ocLf1h6YxiGaoGzaoow7mgFhnSayUkrtos", + "privKey": "CAASqAkwggSkAgEAAoIBAQC70DVI9M/iZV6F64OHkYCzatlI32bP6bg0pyVnaEAQHEG8RYMm55w+SlDxfO7NE6MPYp1objt0PkB2MUvmhigmKsYlRoOO3kxPf0fgsB45WjRZO+gxhIejmGpfMmQS5+cYx2nWcv6WYXURlIMwb1YkV7AcvZIcqdNspSrlHVqP6BPfIC+dbRnf1xX/1Urj7Z0X6wUnWAFn8vsiFEy4t7ox66OC/uYQMB/lF8PkZcccAeZIlmflZ8LeFqtuwdUpBa2fS+00tZNd2Xav3OnnLU9fnEG8MfdYXqQFq9LD4e+nBEIARVFkaRo6vT7ujU8qdgA+y1bZYA2Y4MBTbC1tnf4RAgMBAAECggEAV0eS+6yJTzS8kI+6OC4uGTL2dx8asFR0/kMO5tdTrijzg4LqSBIqUehHZXIhp7wQcv3pGLbhekvTuRl/pEmELviBzKDQUnyMCgWkaY5u/UgmO7HTXe+w+R3DkSnhx8dtZd6GGNqn5Uq1FM5niQK0jX8SoMiYNinVzw+St5bEl0r9xnQ/0WQz2o1tb5wkX3WcRlWhp2i4OHuuCcV5CWrT0biXzAOGl+6releHceqWSkv57rIYMXOlSp5Eu0JoWsgdETn7kP0GRfHny9pqKNZ8sT/cw/Iq15+cUYELyMLfXLAPWsTkfdM7PVGSVTXnYzr+jsC7o0yqWZ1q/IAO73sk4QKBgQDzcqdvX7M6AmcN8Y91LYV+SvvtNu0igESFR1QcHnF7vPKSbDLIchimi/vxVfAZ548hVgvwoQ8nfocMCWf5ZCn8LSXaZVNcHJjFHnmaoyXeRxuSv1lSGuanBSDBRx02FYIr0K/CHjk+zjim+CHE/RYJez8G2ywmeVGx0f3wGUW5ZwKBgQDFfzdE7zfHiG4DpHvdrzHjyzygZzf4Pv/WtUQZnUSWCdC1D04lDXi/ivqWslnnIO2oJPDBElnlJ7fXIPh1PqJVtote5+xGbV0W/dW1laiUmmF/rsjJM2275mhCKEDbdp19C9d3LYKxhqK42vt4wFn20QDCizZGsTZjwWv92r/JxwKBgQDxKsS5rUlkjxq+Em32O/lBqlC1pzL1ebHngkjNbk8nsH9xFCSes4C+BHC6nFK1ptIAyTgc0cCsdEieYPcSdOquuZ8FIlmZJ28j31PCIBsUfsbO8iYvEx0pmgff0G4ctOP2Oc7Tc5NsJ2ix55+0gK+DBwfh599t4cNPb+KrJq4OwwKBgFHZpHVMUyi90SJvU+qPRjTrMQglXxviODOq0jtvY1JvZPD1E+TlTWrM1YgJCJtymSw7iw/pZBpFuLpO7sngmHS/f8logxK5FoCF2ME18jUMOmYpcQt55fuexQzOE/sgkKqXcsfws56RdvT3xIrJ5T8WZaM7ANaRcUIskm4V77BXAoGBALNV4aqbu6rnMKyl6i2JTvQPsoSAY865Z9M5o3WmGSyR/7DUOPwkX0hUtMZgVQXeto0ENodDg0vrwWsUvNc9tsB1yk84tE+NnAj2EecBxdcgygsyIJh1U+SYAlbEGK+gYuk+cD3K5i3+gcrMYQ3tzv8Ee9TYJkPKod/LEQgtmmhK", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC70DVI9M/iZV6F64OHkYCzatlI32bP6bg0pyVnaEAQHEG8RYMm55w+SlDxfO7NE6MPYp1objt0PkB2MUvmhigmKsYlRoOO3kxPf0fgsB45WjRZO+gxhIejmGpfMmQS5+cYx2nWcv6WYXURlIMwb1YkV7AcvZIcqdNspSrlHVqP6BPfIC+dbRnf1xX/1Urj7Z0X6wUnWAFn8vsiFEy4t7ox66OC/uYQMB/lF8PkZcccAeZIlmflZ8LeFqtuwdUpBa2fS+00tZNd2Xav3OnnLU9fnEG8MfdYXqQFq9LD4e+nBEIARVFkaRo6vT7ujU8qdgA+y1bZYA2Y4MBTbC1tnf4RAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmUnTYhJiofsHuBysR5163GP4a7AgXno2N6Xfz13gEhKLW", + "privKey": "CAASqgkwggSmAgEAAoIBAQDSO7EWwmXElyq2y87TjaG58rEm0ZZhhuIBVJWhvBFOqmacmaFaJWN3OR3QTtEZN6j9ymiOpDWkgz9Vh92Ozk9C6ay7BA9mKoqd2G0UESL9btPV9sQECqajhrscVQPq9amra2wy0ECjvKPMGQEBchnva81XT60Gg8Zm2ItzqopHZ76FsPYGPGPSSTJ1yv/J+dsyjBOmNRhR95b8fqsQGYJVLKwmfKxRDeXv9wMbB557g+/TOPodDeR4q02sgyr+ONOq0PU40qrL43PqtsQBRT2nLeoQl1DAHouia4AP1U1ZwTuNPd5YgCXvHqkr9YJUiagEOZn/a5xBQN4dzeDE6irnAgMBAAECggEBAJLVSBlaSxPkdNvZOyp8uGEURXCUX9DcEUvWlO+yV/A2iZaEorJAfNkPVmhgNCDFxE0FqsM9o420cW6+hxsvsyJL7O1tp4e23LvkJkMmuOaDGodNY5hjDAIYnuTp5+OaExf73kUbOJpjrY9mQ1KMK9sR0whRSMrNDKxWQAfYK940LQXQhAd28T0gB5Scie9l5oQnIRgmaQskhdOTYvFYyH0AEExR4vlx1+clQ4tV7FTf4irqJbh9b1+x/pvuWAOKxn4oGPyndi/K6HRNBIWu0HULWLHQJMWK57APWTBNiVKC2w72ZL7iLcme8eujIakrwSgUK5oHtqC12EggvsdZPgECgYEA/VxnvZlAP2w+CY3U62+SPIHipUIsizmswRNlwj/Qes8h8jcdOv8M0QibAgVHzIw4z6xXUbBlaGI88GfeM5EOpnn6GDt5wGGE/Pfe2L5+iljYm6j7qLj/MXt+m/0iw8Tl8Reb2fMjiQEuDT9XLsXip3ZtixusdBLqPRoRaSYBuQECgYEA1GxI8n5FwamjCjtD/W8jZMJnfCRVgGshRRs66S27STT0Q44rK6jyEY8unsmwob+Hk/884mbQEkmevv9YFRX1Bx2B2gQBgDe5u4ESW/xZe6zO5UOz+1nyw9KrW8W/VI5C/Vuii2Y+8Hnfp3s8KNwnwKgqV/m2qdNip0/wLGK5O+cCgYEA6JrVg3QXUCMIMa1NNXmRQIvekOpYCtpAiGJOojAELzvLZpzC8U8HbUIBTbGbYWe7IK6Q3Caec179o5k4nw8l7CFAQs8X0E+30KegqEz7z/gRpZdWtGhjogJHEt8r85/pm5aZN1fJ4BZ9ORxV5lM265gGqhgWE9rpwn8UTPzfyAECgYEAhT3288Qo1TUmw4AxQYK43LbkWoYf65FHKSXPafv5gg3pOYavpY8vZ7w8LfWtCYgt7rMm6Yw773ymSn+4LGG9dF0Z2jqxBk/t/KMVdQVwy5a1oDE7b+oX0KUQP1xmiw9BDdKwvmfACu8nTtKKBccyWDIjfVNxNE0XkIMfz3eNYPkCgYEA7DBOsXD/lca6cJ2gyb1QRrESqu2zVgzA6eU+Aj4W2f5JGJiYyED1+Z096PdU62Hz3YORW6STrxF/fvl5dpSY++FktTjQqNvoogCIaz1Tv7/2I6qmghWOV7ykznqJV757H7W01LIbkihkTUD5mtrSLLuhZC/eGixBmD+SC6WQbH4=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDSO7EWwmXElyq2y87TjaG58rEm0ZZhhuIBVJWhvBFOqmacmaFaJWN3OR3QTtEZN6j9ymiOpDWkgz9Vh92Ozk9C6ay7BA9mKoqd2G0UESL9btPV9sQECqajhrscVQPq9amra2wy0ECjvKPMGQEBchnva81XT60Gg8Zm2ItzqopHZ76FsPYGPGPSSTJ1yv/J+dsyjBOmNRhR95b8fqsQGYJVLKwmfKxRDeXv9wMbB557g+/TOPodDeR4q02sgyr+ONOq0PU40qrL43PqtsQBRT2nLeoQl1DAHouia4AP1U1ZwTuNPd5YgCXvHqkr9YJUiagEOZn/a5xBQN4dzeDE6irnAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmcMTe658zwQDgHHnyoRhATfhDtugTTbCxwGXNzkZAzdeZ", + "privKey": "CAASqAkwggSkAgEAAoIBAQD83VaAqAvo1ZRSQIR7kqik/V2i/9ywEVPdZhl7O+K5LvoD9FSGKGPYav3yjGQTKwvE5eki8Rq4VwthC99OaaogMUygpAsLLEiaoxoRRHvEM5tyzYlbPTlnAE9Xd0bNto34yLV/duaQFKh2wFrCypXZ4xEWz+vjRvfm3+/hSp6cqBTUGV6I9qsQO+8q7Sqxdh+wzC2U9P473pZ9X4EsqkUq04Ycvon4WVbdLGZkrxGWX9sKfRQW1xPVkZtVJlp/aDq9ZK8VB9dCnxNWOmJlolekfmc3tthe6gdcPEw270rSyRhxuqvPgvhgosu9FAkLKSwA2o5vHsKtKTGlmcpFSBqlAgMBAAECggEBAKRD7UPa5xG0XYwpWWclWOUFquSOroC6YO68uuTxfFGskMIs4RPd/S7EIoCEbyZ8mkKo0JDga+lAsqWynrhDsD8Fh6/7oSj69ZdvSSnagURt+hfUKdzZowakjuZVF+vfIc9yI2XQiesjYGT0hIFyNXK8LYfSPn0Ax152L1D9tpgw1fUF69pHbBI356m4pQfMq5hp3RSI0TvRlDrtmb3Eab5ItCDmtz0prqZIFv8y9HGa+3KZXunnhJyfTapheF0PAdoI/9+mkcU5yXZ9VgIX7RL8M75tUMWLiy3o/mpJFcQbneNkTyucEKzKyk32Z3olP+iqI5sX0R0MU/fyK4IyTOkCgYEA/7P7gwWQDbtomKKx3h7gsUbkopsBeculuhSVoyE1VZgJL9YQW8Xg4oQfNA61nsu8km7AJJsnGB4wkAqU8HxMZpk9jjLsI+GubRLnArLLrvHFwnKOqw/PeIxcrJMBzSHYkQ7aybcv7rolNbABdC13t46Y5Nyh/kpICmJUzLftH4MCgYEA/SiC98LtWmVo4i6D0vlM9Bn+gPffD/MV4G9eK2BiYeneawwuJkjhtU0X2BWG13V11KGHmkIm4eU5ILAJn2q91s4EQ+lSOwjW35PrgFEdWn+y5AkohL7onv2MNV6vLu/dKrT2sX96G91hiN2sYwztarGS34aoOnEDeEThUjzm3LcCgYAkbAecTxOI0TQB4dLCF9XbioSQoNGh/p75lWsHFHjbW0+br7sex13UBgvHx3yZRN30YbAexrbX2Z0DN26lnp7nUlaRRbGbHs9QnAupt7wJjEil/NlThmn/+sZMkpgEFxkY+GuzpdM/Bua78fkTClLuI3KlzsOITB5c1ErN6jjtbwKBgQCB8Bc44D4/lal93m4fDYKoD+eHfrJpV1W1OrRVA0W8B/P3cesGD4Z6LjW83V+2mz19g+M8FBQtAiCOXIyz3G/QHzIlQU7JqkHPw/auh/PPDZheXy0C5ZI0eONMSWsVZlxYnUW52TptrvVu8IiY1nvNtZMzU8RpKrSjOIeGVGgShQKBgFPUX9/rZjR7mbzZakbXwcEZCjSI1C57VMLIH3m/IfE0yhO5KsE8rSm7lpHy64K3rMH2hFViHlf+RyUrzIXyvVOEToQUWdDcT/QxbFNHFolPJCjcssQvejngG4IbO4clRMNmTjCdQZHJoz6o4XwKrFN3jalBPeLrTqSF1HyOV1bJ", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD83VaAqAvo1ZRSQIR7kqik/V2i/9ywEVPdZhl7O+K5LvoD9FSGKGPYav3yjGQTKwvE5eki8Rq4VwthC99OaaogMUygpAsLLEiaoxoRRHvEM5tyzYlbPTlnAE9Xd0bNto34yLV/duaQFKh2wFrCypXZ4xEWz+vjRvfm3+/hSp6cqBTUGV6I9qsQO+8q7Sqxdh+wzC2U9P473pZ9X4EsqkUq04Ycvon4WVbdLGZkrxGWX9sKfRQW1xPVkZtVJlp/aDq9ZK8VB9dCnxNWOmJlolekfmc3tthe6gdcPEw270rSyRhxuqvPgvhgosu9FAkLKSwA2o5vHsKtKTGlmcpFSBqlAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmUaekXpyXgarUkAuUq7LgeXYGFMxsiuy1zkUSiMDzY2ge", + "privKey": "CAASpwkwggSjAgEAAoIBAQCV/mBz7chASkoZWB9N0Z5y4bkAb52+88XLdfE1PsXDmgkPn3txZ5En5gq/pCQ/x7obG7zfb1Deppu1hnkK4imsCMW5Q8tfx3ar79SoX09gMUj0ULcQX84Ruhb/JXtjxHrY810CMVeBO/okMIS4JZPrTwfygodpcjz/7CRGT5fBn6D5yT2b2ADAjcmKFc+cVjMiU33ffLGXXc8dn3vUEI94M8fAtYc0Kso7deLv5wd1BnTS4sa87DMNSbexrmjZNmRCd9OvXvf66UH/rVdteU+8o6bwFbjtx73dfeacbz9SWqIHpnxBRk5TbhT/ahsRxa8gTPpZNWR+o/d3YOGUTDCjAgMBAAECggEAQFNpdg5B1SCHCrt6IVuGgmo/dupnUl8lMo6QNW+ITMygmiyhOg9adyv27B0u1pOHQtzwcTpCClqVaJIVEw/PI1JXyY5Dh/347N/b6aGGXxCD4xNCjyknLP8LobynYDABJ02nU6tphaj9K8wK/xZOi5nHJL/J5vTxKChTnjvAL27n9pqo8zXjEsNOrsdQoeVRT/aq2cexzFv6nfJvS0uZ+hfQ+96LcmBT52OFtf8ekoSp7CcLCZpjmgHW452Mi75vC3B1VRkIeAMyV6DM1knPclSI22Ph5YP/xH+SAVriin1j1i2Y6fAqSYmRLRLLlQZpDX/4d3d6AhyIF+FOOKTG0QKBgQDHXt31BVRedo2CJ/vOkpAwoNMVsyYHeEs/uQL1ZoSTHFR7K1s9Zv5s7M1VCQnpWxfSw4jipmPlHoYvKtxkUcH8f8uBGeVpHHODHsNWQTSTO3uBK8qaH81zvL752h0ElY2kDfZ4yUQjr83AaiKjbl7/0lWzyNWrZfpxVJkV+AOa/wKBgQDAmRd7P/oc9GpS1zw9GyJuOmIyNgsITS5eQ1s07brdNgUNe8Mvwuauz8QIipadE0o9tvRlBTIALhJ1VMZk2Pc7GBiT5R158lZkMCWDtEl+SwRN6swCpaDoEAdi8OAHkoUyaDa3awc/Og/Beh5F9nzfQHnohBiqDZTdQ0jcMC0eXQKBgHQxeuRZBdHEADbx/JRo4LYmlL8Z2LkTx69MsUe6RtvB8A6UtykzBGcRH55GlUs2Ns0z/mwxkxiuUH/e1/FzoL368Oy93fEDjuLFJAz6FZ0VVqZykjJ/BGtGfnr5Pl40lwccyB+fFSJDTIOul59uLNmliSMtkjHBTlOMfWfLUrabAoGAYQ5E+QU6g1DgK7LvVlPQPAAL8AWv9ZT/Yt1KnxeV7VgFn8/Ygr8TBNEKlstQLwPDi+ogqq+9jL2q65m3CKcVn5/68ryo6AUpZ/+jSAWYa55eIu3JtSPGPGunbUK5gtdhbA98U14KHuChg/yIOPWH4/FX/cZjr358oCwCEYPtmLkCgYEAvWLMa7TXajVv+2lb01VmpEOjMnl9FfGtYqnp5LQbbCV5xpecjwaT6nn9jXbuhhTDvARacR/7dYbPCG+hOE5kuDDZ0LeRZuhboRgq9meE5F2ujG2NMfkz0cz83KoDR2eHbVd2M00HRtxSez5AV9y2lVH/i2YWJkI3kIsx0X6m+NU=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCV/mBz7chASkoZWB9N0Z5y4bkAb52+88XLdfE1PsXDmgkPn3txZ5En5gq/pCQ/x7obG7zfb1Deppu1hnkK4imsCMW5Q8tfx3ar79SoX09gMUj0ULcQX84Ruhb/JXtjxHrY810CMVeBO/okMIS4JZPrTwfygodpcjz/7CRGT5fBn6D5yT2b2ADAjcmKFc+cVjMiU33ffLGXXc8dn3vUEI94M8fAtYc0Kso7deLv5wd1BnTS4sa87DMNSbexrmjZNmRCd9OvXvf66UH/rVdteU+8o6bwFbjtx73dfeacbz9SWqIHpnxBRk5TbhT/ahsRxa8gTPpZNWR+o/d3YOGUTDCjAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmdAKuU1tkALvTgazZtQtey8UQWqEZD7hEqYadQpfQficW", + "privKey": "CAASpwkwggSjAgEAAoIBAQCg2t7T0Wino9kgXWcv6reFcvY9QQEjcbq/+viXSOWBuMkIsgt3d1Hl4D6RKVWL0Nq51eWwubEzNeufN0XRbnZPvBX97xyD0TJhhjPWEf1iQep5+Ioea8hs1tCW47XkCDmfp54jR/6p5JCoWyQ5473I8nV+7r8I1aptygfnyAmGcHSaPf55t6ZlPbz4M6GCbxo/Op97N0xVlAEFIl7rYdYl3dCTFYUcN9TzhWTUxWKPhPkpEg+iO0W9luHnGtUebEV2lLeZskid/+NZfXxSayueS0B1mwGlPZlm53149RWXyVZtZihkggaXDXVUKStqWQt9o4W4xAa8JSuIol8ZnCKTAgMBAAECggEANlugf449wqERJ+nIjB3SpOtDoVGNU/AD/wqN5XoB7QOIFEMustGEwJ02J5IDUbtjnvdUppMp+bdYB7cDBhJBMxLJj8W1KiqQzvouHEJ6ETFbTpqZ+kvMMFOrq8IJ3qSU7IoVW7Dhs4IFDI+4P0PiB70/zYRa1F54OJ/UahRke6SN6Jepv3Jgdb5e5wC3NQNvgdJi/hPl/Y3d+T1vzctR9bPg/H12uY0OJTIjn+FkUAQIhiskkj4iGf1MKtd94Oojnh11OUcQoabipQH/4hf7K9Js2uizr0d5qKZ0VQBPJwyf1qlP09WNPwZJIcHh0/cYePA4XosKlWhspEFv4NIC2QKBgQDNx02e/nthoFJ7gGH75I8QANTHgvHiAvtkpfPTFCHVbzkQK89FeeQLE+0rgbEXOoRSlDTmKYRoLxU8Qk0mP6lF6PD1Tgxq1f/+zuROzRTOCvdIbpMLB42jdOuuOLCdFjPngn9dwdmUpB+sYM4J3HdHnesfXSTyGKtfG924HoRojwKBgQDIHNF7qUkZr9w1uDsWPYunAXKhUw7MMznvew7FC1WBb4WpPwgpeZ5cKa9ywviwV7EbKh6FM0g0uP5ArFUXBlcHpEh78x/xfipbiER8P73OGxsuvphdWozSWm47zCv2rnV2RwaqfN3nt937WRCIg10tR/y454RL8Z2J7c1DJER/vQKBgQCSdobC4bKDvA65JJmZJgbFhzHrh0IOcbzo2E2BMVUbivx8jBINC0LKt7YZP0gCln3UIPS91VMOrGRa7X3n+WvL/I50qsafzA1XGX7ar5FdTeTPwxQZx5iCfRe6e1MJm+H5p6Jr4yuwZli84nIEBs1HRhkxy6QeRHzFRxo6kE4B9QKBgClb02v0g/g8IY40wnmJRNjCctem2/MWT04Qp+/PtN9olj5xmZVA3pr7vphAdbe0mBUeMmqjO7Qx29KwC3ITzF729Egx6pM12TlLw6POZMM5VPfnSoRY16wOJqRTQW7dhcdpTJZl8lMW7FkrgkBErjhSnYf1yaEMkdvU+0x6LXIdAoGAEs340X3I2wgWm3gpuhhaEbkg6d8XoilBSNd2J7djFHlPJy7vrNYWcKyvj4GDvOJS7mH4mFXFxM9AVD0xIVeXRK3M/tj9V5Ak6e8uXmyY03CLz38gqHVL0VfU7z5LV71oseASYNmK80+RyhiTZz/+6MdKGoAPSnNfr6DqfViVT7U=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCg2t7T0Wino9kgXWcv6reFcvY9QQEjcbq/+viXSOWBuMkIsgt3d1Hl4D6RKVWL0Nq51eWwubEzNeufN0XRbnZPvBX97xyD0TJhhjPWEf1iQep5+Ioea8hs1tCW47XkCDmfp54jR/6p5JCoWyQ5473I8nV+7r8I1aptygfnyAmGcHSaPf55t6ZlPbz4M6GCbxo/Op97N0xVlAEFIl7rYdYl3dCTFYUcN9TzhWTUxWKPhPkpEg+iO0W9luHnGtUebEV2lLeZskid/+NZfXxSayueS0B1mwGlPZlm53149RWXyVZtZihkggaXDXVUKStqWQt9o4W4xAa8JSuIol8ZnCKTAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbjYN3j93tRphkpoPYYNPtVRQ1PfWKBXbTjvPb1YaQie4", + "privKey": "CAASqAkwggSkAgEAAoIBAQCvPzx0PZ7I7g7946nS71ihYr3S44ilmZ9Zb6Dkt+nTf4s51ZXF8c1vbeH1rVLqImSXk0nQyuyxtZbXzjhfzz2lkIHWrld6/nFJWrDj4iL3+dWyrbGduzGH5RxIxo90zq9/pvlQomxWLW7C3dfNqTcyEuZPlh09wAsvuc6ymokDjia0WJ48n8tejgv1XotGmJPriDTSQ3lyecMXh4z+fM2EVwSum+8Sl8MxE17WdhBTduYcEzylCjO55ved6yhUEGQ33KcgUxDLOKve0ZWjvipPha3QyKYFs0F4oQhxXJ1KvvTQu6vIvqEexRPufMtF6USmfNWzJ7VEnoPErKRAw7r9AgMBAAECggEAGDdEw0tAhcNfjvXGob8xIBvk3x9R4pA31MP4F6LSTMdzFarN52xiVuN4Ndqden0GKWvQ52kjC+trzKZSY+rfOeGeD2xH6lb+kIRXrSWyb1G2ldoqkQEs9vpRzjyh1iI5XgpUqS/IiJ/+ji7ZgzG+zsyNxrGXmNDQuueSCFwSUss3CRgeLY8X3jf1tNqw8RrVJMK8dQOn1udJVHwi+4BwDoEvWD8JQ/iwTK6Nw9PI9oClKG26zk0zc/nw3QiqQuuRjjh3LEVW4wBnCSiehRIYl8YY9kXq11R9dsLlMl/P1ak5YsC3e4ZqPehJXc/rN37/ypEl88gPSxQRf6hywomYAQKBgQDnhFjXFvif4H1QL4xU7JlDp4wJ3iTSvJFhS6R0Rs8yqSSdwezcC9OGlglFsxAmOSpy8ax3unxyMhBUUjS5X4ZsAr45eYe2ma9pru0bMqat8V+e882Mtx1eL/AEQwUylENAlYs6rVasmQdWVXYlLuO+Kh+YR9XPr8E68eT7M9nMjQKBgQDBx4rhOEY5lvJRkrNK0uFJClIR27FIyWGXSXiYgGa4SRHlwNtbTxQsK86NT63rnwCWMDMdrbg451jDNi9xV21ZLLG5gOZmnzz9Ku1Ool/rWpE7SnfmukBEqXkLuJpLWYGcX4oo2IaMXzl23fcD9UNIs/hc8M29PQYWg1jHfv7kMQKBgQDHCNqvn4oDOKXDB/2nDPj+Vs5ntVkG6yI4+STa6f07WnqmPY/55RjmvZofF8AsfDzoMKjLDcHrEutC8qFtNJiFxx3un3JzI1DQlJg3J6ZwJ/DC4Gq4LLzMun2nzE5tm1Tt8yKNQXQgUjcim7pEYTldxS0AZ9GDCWAf4tGuvHbkCQKBgDa7tOd+bJ9xmkoeJJQ60jU+PAYdRornjrAbqXtxsRHWWb7KZWr6ABml2faiDd7ij1jcjmOQoNs5xSGGWYorBpDMhfp+hRVxXtmnWVX/mRYyA5l6pDlAXEzIjY8Y+kPUKT7Q4YY9+msFroZ7lXzBttp/MuSVg5cy+Fg9i0L2BOrRAoGBALSoamMnSuj9U+XySBgzR4CFnEt//x09sv7and2Ds6R9v8KTG7hfxXQeSCSrhHzht7zGUOl7AialE8DvwmFQGdk/MXXXGLNLc9BKxDsm0SOhnfpd+3gj1tETZ1MNQwvEvH05/YxisUM0Tf7jaxAoRPQCTK5RnI+/SPRM4WKxxAk3", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvPzx0PZ7I7g7946nS71ihYr3S44ilmZ9Zb6Dkt+nTf4s51ZXF8c1vbeH1rVLqImSXk0nQyuyxtZbXzjhfzz2lkIHWrld6/nFJWrDj4iL3+dWyrbGduzGH5RxIxo90zq9/pvlQomxWLW7C3dfNqTcyEuZPlh09wAsvuc6ymokDjia0WJ48n8tejgv1XotGmJPriDTSQ3lyecMXh4z+fM2EVwSum+8Sl8MxE17WdhBTduYcEzylCjO55ved6yhUEGQ33KcgUxDLOKve0ZWjvipPha3QyKYFs0F4oQhxXJ1KvvTQu6vIvqEexRPufMtF6USmfNWzJ7VEnoPErKRAw7r9AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmYUkVMesm7KC9DddFyoUr96c9ktBV5TX3PJU45BKHT8i6", + "privKey": "CAASqAkwggSkAgEAAoIBAQCvad/4sTNPjoJXFONa+0WXqCiWAr551BwdkHFVEKXS2E8AhtSqFcdU5CANEZUca0c0RPTJV2RhQJuc7HjVbx3jAADyLUwvPWEv+oFAHdgz+/mopVeJjVhmEYWV33LkSwcRFhJdJ3m0gA9c1FRFZbFOe/q/lULyEr0d0sQOTmludDyjWs5S7kkDuv32E0q23wXfEDvLpime3KDO5XslXGVKR957hziJ4z3ZnHII2Exaqbxp2yUoZ2gWrqzTDhZS9Vkxh++yJIRLCwF3co1z0E8BXOYFEec0ON0S607D4AfCvyY1Z9FB+NeBJNPd6Hn1UE6rK8MRRQaQpWLoKw+TQEnRAgMBAAECggEAe2qEeJdEQK9FqTs7E2JC/ocDtzfLCDBib7KW6oDCCuzB+N7kdZ7JFkNDAa7jOJGKEY6Ko7ZnG723Pttp0NFTN8li4QFZ3srSvE0F7zSQT1LzvuJGCrN2BKpDUMVcMp9PI4hh90S07nhDVs7VU9ZOv6efLng4F9VzVa5a3q3wpBLdTJkhzxHCCnA/mMYGhrzemL00RWhxe3Y3HUCfume6W4HdlScvoBL71GZsDTdvq/jKY0DTW4tSK8MS6OulBm4a4flTNCah/+RKsnxaTK59B+TvW+4LrPtAIpCvTNVvvhGtw1LV1M23S0/h9Ti35GObETPF0ydsIL5lBSozYFxoIQKBgQDi2YRIUepYumHzE/J//D5Eyu9oVjYFOILzwz4UnnnJGOJkNaH6kCz4KNXNc7RHgx2+UVGhzHTjK7XKb9cdb2pBul0yMibL5fwUx9TLSiJFiQttVsQG9Uar0w++11SqIVFmVMOG5/sKBu8M4rPnGPuPwKHMPiub3UROPawQGMtkNQKBgQDF9E7U7eLD4Yk42QOPLLZr7NUrbnBK7kkjmsjOf3iHz3srJveGnwMZu9KqeDqh8We8hB2uEAmVY9eXViGb0NDfTTcgKS6N6IyBlbGm+YpF4lPDUP2QU1a4gcEw9IYkyuTRP+Bd/DXmH06hvmtBDV5aiFe2oL9S6k6mS71o7cWKrQKBgQCKaFCvl1s2e7GbkAYbVJnhezgLHt6i3NH5TJyqE+8WZVpr7dVAfYsSdkfMrNXH9BXHsvHtmEOQ/3BRbV+AlCPuqniGUdcd/NqLC0moJzk11+Hi+ldsL2bJG2O1+serbdyuZPVPcGbYvVZJNGCzlaiXEt8lMKGG3b/5ROOghqBCKQKBgQCVu2o1nYq9Z8eH/H64ubVyhT3pECxYQU2JZPcnWzwsXkBoL51jcrvBp1R+JVsUS6mP6s8YboERQug8TKY3WgfkIF/mL8BLDu/YxQYPqwlwOvXo80YY+TDLdzpOcWdWRTI3JP3tmWybmGq95W7zUc1g5WiTd5vAeALtvrSSveeCMQKBgBqRcvMPYIvioU4wX+hfUTK4pZswbZAKXn53UVqVLo3aPXI9NCtIwuJt1uPzrk3knd92zGyHQIL1BbJd+ntrFmgySzq9NfcfN8Aw2qBCbMaftY2VZPcCMl/ZKniI73g3sS3PTyfTtaTLDmaGnTTs9FTwj910BP2qcqM1CyNj9bEc", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvad/4sTNPjoJXFONa+0WXqCiWAr551BwdkHFVEKXS2E8AhtSqFcdU5CANEZUca0c0RPTJV2RhQJuc7HjVbx3jAADyLUwvPWEv+oFAHdgz+/mopVeJjVhmEYWV33LkSwcRFhJdJ3m0gA9c1FRFZbFOe/q/lULyEr0d0sQOTmludDyjWs5S7kkDuv32E0q23wXfEDvLpime3KDO5XslXGVKR957hziJ4z3ZnHII2Exaqbxp2yUoZ2gWrqzTDhZS9Vkxh++yJIRLCwF3co1z0E8BXOYFEec0ON0S607D4AfCvyY1Z9FB+NeBJNPd6Hn1UE6rK8MRRQaQpWLoKw+TQEnRAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmPC4nWM2FExdfdtFPj2Mo8CgD9V39EGYJ1Uy2KfJByQ76", + "privKey": "CAASpwkwggSjAgEAAoIBAQCmJ+uNs+bUavj6HxRVCsoCb7NsfAs/RPm+KyoYP9zMAYAeo389S20cdVJmLEUcv47a3DsvK7OlKBlMlS30nYK7vv+y8t7yk4bgUIcKPRSUWUgRnjPBiC2VA0rdxHCtp5f5BsPoOayN137bv+jPanPWba6B1mN1zQMLZt6Mm+Kgf3xWlSJv8boUx066s7zAGQ1+4neOfejdSboFA6faRjPBZQyePgYkaObgeaGpkJN7KnlLcmMdN+yqvRTAo2Lzzty3GmmNg5OsPwm8Sh3tsGvRtC8Mk0m1KpamIaxOlEQiT3pAj/XLmvn+I19HSAU42ydHzDaaQCor/Wlyi0pxWd3HAgMBAAECggEAdUfKQYxRi3Aya8JSRLDH5C5aFGH+Qlt6eNvY66LwQ+NvPrEjF+3Mh4Dcd5gZ9G/V8u/uqp4LQLFsIh1OgdJIPCNWM0axTcIKOv08RGLWytu2PhFP8PQhUIQxbRXCfyDD6Zf34kwLW1dXiN8OApHeT+W9fpIIRFdAJeUng1JpBeWzgeys+JjBitjdrl8BEeDaecYGTDTVcL7Qle98J09vuBU0AEjiL3wHZ1NOqC6e5LdqJTDBBwd7qwlmJYKKTP7p80y7AV46QPkhGg0IuxtSFz053Vy5zgxNmEhOLG/6t9OViTqr5q5z6ruW1fDDFSup5VwT4OucGRj8i7mcJOh+YQKBgQDPkA4EB+jHgyOs6r9cywa10Y3eKZSiTn9q9vc6YiTmzf/vM+3edzXBTp2DgE+NUTNrLX/KBjCcZ4MJO9pXv7isC1M4RzoheNcEXt/lQiwM40NWtyoBtZmuQsd9VzRoRkeEUfRD30cIGftyLynQ+T9Vs4ohO0i1nIPTHodRVdRydwKBgQDM7jHmf/RkrYdRIUYWmqEDmxC30bRdzwXNuxkgtodjH3O5by2dRIna4VHHC/0Fajr5tDsozLE4y5onapgoLUR9BIeQ0zdHpfhknyRmPJTAI7tmOUAtyk5Ag8V21UAnQa89/2LkiSOXK563k7IbcfhR8QUpyqmHtydXjpTjfn/zMQKBgAbcJfpwIHtnlChE4eo5M5GSyXOMQENVANUSMH2XfMy8BjdrqfLuUbJ/3KjZ9sce5eom6NBOgBDLQwNtHPxFc98LyMZVZFBy4/hbAl9bXoVWhYU6LIM980RVJK650RuZJwfyhXYwzPIxmaPedy1W74bvliMfCHooIBs8KRDBG3JlAoGAZIGV+6RZql7o9MNK6p8fxPLyOhUhTrjP8dyHMGIU+GpeiV2bk3wf2DeVsfeROmylS/423YW2jVJd4mMHCP1aj63/BupwPDWMI11hrrqbgbiEmlgNv+duhXmbCPMBqb8vQUrVp5wS1ntQNly7h3ZYAWghziNVDfin1Ota3lAWVKECgYEAmZZxr4Rjqrdl+Opo/UBO7z8hZCiMVCydjOej5rV0LPeJvPUN26hZxbzI8T/kIjN+ShwXErkbOdm3YLSiqSBD2V84FiL8D4GF/fQstq9kWMHe05bABegFdZPG3eRUTTeVca/CoryBSxfrYv43sNE1wPhBC/mcaKl4a+Nf7fb93tE=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCmJ+uNs+bUavj6HxRVCsoCb7NsfAs/RPm+KyoYP9zMAYAeo389S20cdVJmLEUcv47a3DsvK7OlKBlMlS30nYK7vv+y8t7yk4bgUIcKPRSUWUgRnjPBiC2VA0rdxHCtp5f5BsPoOayN137bv+jPanPWba6B1mN1zQMLZt6Mm+Kgf3xWlSJv8boUx066s7zAGQ1+4neOfejdSboFA6faRjPBZQyePgYkaObgeaGpkJN7KnlLcmMdN+yqvRTAo2Lzzty3GmmNg5OsPwm8Sh3tsGvRtC8Mk0m1KpamIaxOlEQiT3pAj/XLmvn+I19HSAU42ydHzDaaQCor/Wlyi0pxWd3HAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmRD7p61F8WLQxxaXSUkhSiCJD7BvEkSBEJEmDRKsFqKx2", + "privKey": "CAASqQkwggSlAgEAAoIBAQCwqroKmBCeb9LTRqENrnRehdCTTk8eJxRaF6SGUiQDlL7waBkXKGzA3FyA8Z4wlx5zUCjKtwObpRd5Ijvp1bWvivc61kA+RSAMtSaSBXlfzRZs35h+GxYNWvBfZZBsgoEVTQ0zOr+nvPy4C+ADuSJpZ54fP0ZjDnFDy+qj5hDUW2S4qiror1Q/kH0JNwCmEdcQeoo8JgZwvdl8pFegiOouamHXqOi6pw/nrWZBgGC4kInmz1Ui6lszowSI+39nDsRKYFequ8vnhCYz5linF2p+I1q2V6JwNEc5eGXNMSUwdxulM4+zJ5agQ3e5vDjQ+AeRO7NwpWyHyekCfdK66KztAgMBAAECggEBAJ03scxPuypj9UhTqGuWfrTHfPA6VipNOM1cEOwAGVCehLVIzltPfEi9Ugzl+JLhSRXxlfuglrNiXdtM3eigaMlJb+6KUC2aMoVciHCWModQ6c4FxZ0j2aIU9ajPp5EJKnqcUUzv0TMi+fuHhdmKXddTgOHp22e3qJBe3fbxfLSdDb/jqVzQeaOg4p7xvwn9cghRNWkOqRqMhBL/5FIw03+HCsapAgLB9i6+y038dnbhlJWqVhfIdoTRpc23s7vlra418U+Khkak+F9rymdPDoh26biTyenQSTGhoXDGozeuletJyz5x2uszP31WV1jPkECJa6kW6eyQWCRHDZ3gJIECgYEA3sNF5sogTGM7EMfoUgSSMYYbTrs9Gz5Uk26h/8yOZl+/eEzO3gFgzVTlu2bC/jJj777gRg23oNMu87f+Uay/gAcdz3c15NYm2wUHvFciAk1kE8QNhnIvkC2Kzk+kORgWD8x3qHOuaSLT/Khmfc7V23DqgWWKyFOyF8NoXmI3ob0CgYEAywbCQXdQRwqmCbaZlVcUBJKVY+3R5l882ZXcqtBrCOShQ1Mx3M+2m417ZYQDulDDddLanTG8WkuhFLVLO9iOK0CVgMbQt314cTPa8Ro3hW0T7kYGOGlATSpO3Y+46/9MfOsyehT4WdPK0lXu/Rcnow2IKLNQJOCa4eorZu2ksvECgYEAnqBXCn0seri+urhfyufOYs2obGwQm3HLMCE74rd7P5M2+SdYt+YrVIv7+3K1r+WaHILDmZ7y/+biLFL9GpP02eo3ZCDzk7ybdqMiWw+A/Dq35Qtaxj5ReE215iv4OV/Zde6X1rBpphxS8DvKoBPFXboOg44XQYe37gwMKgmuq9ECgYAdOO7S73J9lznI4iB/D1aRRev8wylYKFMg2mI1r+QIFqhjgWEG8FrPTvD47qR+t8s6dUwEHjmHIaWgzmtyxLvJ2/To4TT/hC7G1HjqBSUCrm2U+T1B91xK/xD08Q/j4A5JWK0eR1Br1YE2/yl0AlYxMOxtN0oM1MtWQxdWLFRtcQKBgQDZu5bIG3PrKR2ySDnTwlY9nwPqKSVkzSlzipF3xs0cXtZv+caONI3oAeX4V0CUZ/q47wvZ7b36z3iEQUQqnfDDQaGafqHOaKpTVBuBrRGfwRb4sO/9OLAU2vyYvmoYzuSkBCVNqB3pP8Hc3/Yoz8jJ/Dk8UBkHJuNPGNdNCrhFvw==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCwqroKmBCeb9LTRqENrnRehdCTTk8eJxRaF6SGUiQDlL7waBkXKGzA3FyA8Z4wlx5zUCjKtwObpRd5Ijvp1bWvivc61kA+RSAMtSaSBXlfzRZs35h+GxYNWvBfZZBsgoEVTQ0zOr+nvPy4C+ADuSJpZ54fP0ZjDnFDy+qj5hDUW2S4qiror1Q/kH0JNwCmEdcQeoo8JgZwvdl8pFegiOouamHXqOi6pw/nrWZBgGC4kInmz1Ui6lszowSI+39nDsRKYFequ8vnhCYz5linF2p+I1q2V6JwNEc5eGXNMSUwdxulM4+zJ5agQ3e5vDjQ+AeRO7NwpWyHyekCfdK66KztAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmWEukYe7VLXaSFG27QMR2qMKLuSJGBiiFQCVA2yrm4LGx", + "privKey": "CAASqAkwggSkAgEAAoIBAQC9IEf/7M1moPkYTNHUkIQbeqbPS586tVtUxJiqZmfua8G3lhEeee41V5P/4I9ytGIqWldkLHBynG3asN4mPM5gXhz6vJdvROB4b9FmGea6XRc3zd1ZWZe7aaL/zL0bdKFLxCprjaF5ijW11tl7fD1XuBtvgh9FyJpOQi8AfcMQfy1sBbr1TX+a0C7mshEjMfN3B3OKSo8eA2RqAcXq4GkVdhBFuMyCFzhMKV43B8s/MKEgkAAALLNpEfw7kZc2pHIqAk3T4tYd/cEFCrFPcsjxo+jBicZg7kZEA+9AFLfB8734o4jJi215wTPwCVkc5b6ssEP7yH3BGK5KsVHpHjObAgMBAAECggEAXx/UdvnhGeSPRVSmGXcSq0uWiR8tGHdNV6aGbvaRAc97IN6+/4gucu/4xbNqEzR9R3YnDIB5knvxmRRqt+rPlpLfmpGuzU1kZc9AEE2oykW2PuAxnBY/BgmM7YJJ/3w7AIPLHkufUyVb/Hjy7HRB2lQEoKJfHldWnVQWlfWrXijrgLf9FqwcNC+H5j0WCga/A0Tbf6pTGrB16MtaiuThZdy/U0S8pWL1ByMB6mjsYORxXBBa5QSHecyltqQCn3mBnbZdI7t0Q1O9wo07bHpz7QxqxlAume1IY2uPSSpI8QMHBMBNKNpa3525tBGhZVCNPyDrXXF6NRAwgC4Zkqz0eQKBgQDse+5GJhocm5TO9sZ3N+PRPL9PeMn2WPURClCFm7iS1zG+oDzBxYu8ZOPAjQi+gx0+xlfcOn+/TFidFBqRLleZBzg1+9Qys62Xe4IdNOZpseZz+sdg2N8PYqBXBoPEyIK0DQt1CP9kSqktG2soKdsU/52mug6MmtvEHX9zmDvVdwKBgQDMu9gRwsXsAenSApks7xzDXMXbA7/myitn3/NU9zD/s58+wD0otKRRPhNONDbON69uH0aB925OkEUZQ10TCYS70QS02K5/4uB7gBT+PW94eFCU/jf+jLpVjz7WzsZ/Lz8h44W74BzrAx3TW3IfKEGytfLCy8/kaJES1oK5oTjr/QKBgFfW5LeLuZE8vPZvNWLdELMMpGcJj8MAYe71bNlj8Rgh9KlA7bBwBypwMyS3fjL9kqRZmhMEa6UL37Jg4Eli9Ei0JM3wf25hzS4CQ19D4f4KhXY5BUvU4m3djX8lvVYfwGTOn53WPL7s+I/3qkLd4TGYjN98JqFVeCINbuTp+/ebAoGBAMeVFz25MliwRNCF1+0F7HRGrFqlfR3vWAEbQItDrnCXGlaB8R0NfGH2sbs7C3JctpgTxRhNrSrJWZMXKFS2or61NHFYCkSBV3UNl2mBWnmGUIfui4eKiNt/mTKuwLKbzF+s/WH5SDeSAjFYpBfblrAwz0c2iKORjFtg4m8zy9nBAoGBALiyvnOoHqnuh8vpSu/icuEROGHpmcp8PyGMlbkc0I5dmIehOaJw1bLfWoL6GLChufwDO6djpIao8UJAPCgHsxYMXwZjxkhZEQ3RL79tg/YiulRR5O25lXNk61vMALIcUmQeCow64IfBcY0PVDgtQJXb2QhCCd8s3MOURCkqKHa3", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9IEf/7M1moPkYTNHUkIQbeqbPS586tVtUxJiqZmfua8G3lhEeee41V5P/4I9ytGIqWldkLHBynG3asN4mPM5gXhz6vJdvROB4b9FmGea6XRc3zd1ZWZe7aaL/zL0bdKFLxCprjaF5ijW11tl7fD1XuBtvgh9FyJpOQi8AfcMQfy1sBbr1TX+a0C7mshEjMfN3B3OKSo8eA2RqAcXq4GkVdhBFuMyCFzhMKV43B8s/MKEgkAAALLNpEfw7kZc2pHIqAk3T4tYd/cEFCrFPcsjxo+jBicZg7kZEA+9AFLfB8734o4jJi215wTPwCVkc5b6ssEP7yH3BGK5KsVHpHjObAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSe3T2985rtAoiy39uahpYsjEJd8GK7sFgXAMbnX4AQY2", + "privKey": "CAASpwkwggSjAgEAAoIBAQDt/lYSWdZdTVdNmEc15XXHZFPtPutZEdhJzzltTuN38Sl2jWymsn8CagHepR3Scs9FwzV/tn81ROZtRS3YcNZBa7w54tWSb5V2Jvt6kyGstqBQqoWnuyEmKqYUPasvQEY0Xg69IHsdtvL5XnheQAtOGiIQZCwyrwJBU36Oi0Vgp9+n42hK9tDwcrqKweYL8/Xr9V3LT2OufZ+UXd3NRsd2G2u2bLQbBzjkbo5MjEWGJwbLTDRwg+VI+lIz9vqnMk+Hq32ymwUqqmumzmkkJ0hQWTxQmt0vBbOtSdknB4be7B34LZaf6HMlm04J0gJHELqwtRK97mD18t8yZBL0eCeTAgMBAAECggEANGE94FwVagOTq2hQg/Q0r+XM8vJeKgRbbiNFqGEsf0F8trL5rtaqTYW3U6FTpvXN2LTWGX25EahQbsxDAtgSz+M+Uh8ykkAszQxXXOr1BmZLcnWVZQ0yhovscZgBDS1ARlZNOCLl9exGHcxFAblmw5HM3X6um5kZDfeqawUMB/F9+Oei5rx0DpI6z00zJjT096Xu/TbOTSDLJUhGqHUC2dI3bo+VjVlBzSLdot+cXfsxiP0kWz6Aico/ftWEZNoG6eXNJBpQifPvCEMGImMIwI0jpolW4cUdu8tSO2q5QbpCHhUHwAQC5jmQTrHoX3pl4s6aE37xxCmm6w9TMZDpwQKBgQD/axU/3KRs60wmdD9uLcGmP2BIRt0PeNiF/FO3p8GTJCHwN5/uKtxnh54oilWSKYuAPRO2MAZenf1Z9LsPt8vkBYeGN0gx4CW6AeH8hT24VqJUbjniPYEZFnLc8ooN9uFxe4/eukq0RVCPwz79U3HHupXYXoHSm4bpA3qDJ/iNLQKBgQDuiRgQmzNjZgPo034F71/5aDxeBCF6DMTmXwruVU3pzGsMcuP8X4FNWDAL7AGci3h2uI5MsS0YVwZ1vjjg9EFv1xsuQR5+BiTWD2BQIKqbaaL0B6Hp2ZfsNvsVpJIehksRJgUfUJtHtearYxL3AzCsTV0MDFgooupqhx3X6WP/vwKBgFmrXmptK8yRTsqxRROJPNMArOyy9CjaZCmlzD5NxsfBh6it3pfetEIkeoIBDsmhjDgZOTJc6d+N18QdBw8dl5cV2d5kyhO4fYYv4wakQGbXA2ZgzDGBJjGIkArBm3YLllog5wFqpY9kRkQyZ4rIIMnd131+sFUgBN0JO5mQDtKBAoGAZm28RbU/ddliqGHY5deKkOCvu3duoKhHDN2XJgy/bjv3Y9saB09DiODrkNMBRiWlzuUlRc13HdKQ1ZKffgmk58+ovk38OAWPX9QueXntiNrtvHhikLZ9RFO/seV/UVg9d9mprW7BnyN/L+1VQXi/N93orLnISXrbym7G4+Y2qKUCgYEA2Mw4KUSDpHP1CJmSqqQog09vPhPPT0mU/8fj+GdVxwP6nv6u8z0Re/49ly9+1RD0dyXerKQOAGd9rvAjkmmfqr+S18gNRAkepW7DPiveL1rvRH0O1fdhSUAKDXDiWou9mdPUH6U0290AjjbI+ZAh83Af2VmJOvPW+hs1sCvkF6Y=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDt/lYSWdZdTVdNmEc15XXHZFPtPutZEdhJzzltTuN38Sl2jWymsn8CagHepR3Scs9FwzV/tn81ROZtRS3YcNZBa7w54tWSb5V2Jvt6kyGstqBQqoWnuyEmKqYUPasvQEY0Xg69IHsdtvL5XnheQAtOGiIQZCwyrwJBU36Oi0Vgp9+n42hK9tDwcrqKweYL8/Xr9V3LT2OufZ+UXd3NRsd2G2u2bLQbBzjkbo5MjEWGJwbLTDRwg+VI+lIz9vqnMk+Hq32ymwUqqmumzmkkJ0hQWTxQmt0vBbOtSdknB4be7B34LZaf6HMlm04J0gJHELqwtRK97mD18t8yZBL0eCeTAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmZ2rBVRQBbSKaDDAY7WhzcoN9AjvcebTvUPhRFyAk6Lj8", + "privKey": "CAASqQkwggSlAgEAAoIBAQDQ4LLRPd47qKngVWvUziPeFPDPISVIi8HgUFJ1Vq/CbLKZDrB20JjLvXwA0RpYkFfZHC84Fjmh4+LwYuV5qJy+5X7IdtnXjUO2yXyykkJ55jDZb7ZEx/5jrYSK+FY7GRaYpQU5dP9R33FnRdVm7GfSETmSwKv/NRQe9KTLKM+K9NvkLPfemau1YaGA2lF4h1TgRbHZYaz/Pp05Y2wv/iRXPRX4wE3k7b7k9oH9TL1UkoNn7L9G9/ZXA7zO8F51YNk0kGfYSmZSIcT6CyfU6SgZdojOYyQQ1KrUKy5lbByaHRh5PW5H8f6f1p8V6Ja/iUMwUg2YQobkKKsY4G3sB86jAgMBAAECggEBAMQsdOU91O11D+7oazjXTipywmPWfnyu/axd48PeYX4Ztnc3q5Y7fXXEhaUCvlq1XjxDUzm67e/U5rvcNidXq7dCNRuzPA9M1m7it2HDKfnwrqpYV/grWQlm2xfl+p7Qhj9gpRJ8hprvX0Od+7oJh8xsbwUcPa2XvUkBfZBsyNd4RAcDR3i7hRo77be1KSVfsGmNFnI1eGkSCS/QPG4aiQk7Od62V5ie0/lHM0hDlUnrl2SRqJGQRdwCp4DPH0TmxhPe4WMl277Pmfd8SRgcRW2WNiLdNXY+PK0cecvkEyr9kpK8eJ0g9loAOkFdcWTHwYplq8NSyVtnMKwvcji3FtECgYEA8h4Pxj9NH8teqfWqIQlDDGeDKxAE3EyPgREGCaFngV/OJ06fB05zt5uyoX8tLXotzSQjjgRk25d1577OkahDJGtcgq/zBDLE1XiaE8eICXn0/MksaMT2ZY0Pp/UEWql9cnnLY3ts/+q8qFloe6Gi+thdUYtWl+1hPhZonKtxn3sCgYEA3Nq5u+fdILAh+DCcWCtAtyZhsXENNvxmJAgVdsK/nbsrl01EiBYXFouxxIl9peHNJaEs4OAMky8EZjYbTZbcFltjh2KdPJiJ2vel30iQBjjPS46uQHh1s5f7SsdXJ2xI3YiheuK0ySiS35vl6AZbrXCAn3Kwi9aOR1wDm+XkEPkCgYEA3Ch7vZBICBY8YR2y8tFiN4BUpK6vTMcNYpZhQBaVcO32HoX+U32B+b5JY1KqeQT1aulmrzfNomQKYY1+drJjQ1WgzHFD8Fhd5aMBr+SrDbrpC4e+qxIW32ayis5ghDREjviy+iX8ioUfwZFzUaA7/A8MZB7owcOnvfZQb83xxssCgYALEfefYJbn7Yw2WZFspfZfd9ALyePkrrAb/D+/LTHXoSslMV1PCPRtT+FAPbgLmY7j5PlP6EsZEZFB4lJqCDbN9BTAE4RYJjk6vZEV6Rg3B5/0ZJl9Z8xWjTauX+GRe08Hs7KMa1KuhpceGD1k7PSpc+suktwglkeZchZIOTS+WQKBgQDvzWu1RFnaWiSpdkVguMP+W8RqAhH+4QW9NJC9S7RrXZ/OvEOdBp8BX8Gm0FbBKEpUl6hreaf/sPm7fudw+fNTDmRZL8yNOTbrCc9CpkZcgl/lm6Q5t7z8Ot2thlZNmTgdIkdXX9jIh+1BmuKpynzP31unvXWczzCnyiy81l+HAQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQ4LLRPd47qKngVWvUziPeFPDPISVIi8HgUFJ1Vq/CbLKZDrB20JjLvXwA0RpYkFfZHC84Fjmh4+LwYuV5qJy+5X7IdtnXjUO2yXyykkJ55jDZb7ZEx/5jrYSK+FY7GRaYpQU5dP9R33FnRdVm7GfSETmSwKv/NRQe9KTLKM+K9NvkLPfemau1YaGA2lF4h1TgRbHZYaz/Pp05Y2wv/iRXPRX4wE3k7b7k9oH9TL1UkoNn7L9G9/ZXA7zO8F51YNk0kGfYSmZSIcT6CyfU6SgZdojOYyQQ1KrUKy5lbByaHRh5PW5H8f6f1p8V6Ja/iUMwUg2YQobkKKsY4G3sB86jAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmdbyUiDo6RdJKSP4yiM7FkycMWx1DycYf5prttoCi7nkH", + "privKey": "CAASqQkwggSlAgEAAoIBAQDU1+WqcQTmVY8dZbZAMaprvG8QzsVGX+ssQT1jDQs8G+GQdGK6yg4OwCW6ZGebGg8Wcnhm9izafQGc94rk7su4+jKkDttQv+GEpZf8yv//jdTzV1bhpDIdE7+yMZgN5ViR3YrFi10vs7Sl+E9KvBQJPD1vsDngjsa3rGLG9CoKtY7EpXi2Rhe7Un8+tp0J7uIJRtyZ0Tgu0K3cLir7Fl3YVBv1PzsY2qaUA3ZfQNy6Yux0ANltU0oO+P2DTknfkuCIC7+QpzECV9z8eIc8vQzRSFLXKRDKqN+1Ucmf698VBdGVUt7Nmyo3q/jeHJWyKce0hArUGhwij5/uoYg9TZx9AgMBAAECggEBAK8KUuVmBxqKWKVbhZOrhLUPheOzuMeUkKqXiK2SB6BKaanMHXnyO7djzGNKuW3z816Ji31ZjS+uSIpXhhGaVU5t7QHA+hqhgwz8xk7uf7QiZ3QsatYsm84P9MHOSXd8Gufy43Jsl5loV/N6j3Mt0+h4cyoMKr0Djmd1TNLD8GNWxhahfGdhFsBEp20EcAe0BTMwHVUgKKOpu7kElAiJUYRVeqvozNC+kkzTLC5m8dcNW9Y5mRNHv6IpBDmUBCxnUubDakbCh8rI759+XNBE3SrDDBiZE9CO2DSZV/QM1lCIMnjcoEmENVZj3XcJYoAiGrMAVqGlxQYZmjQTBI0TzCECgYEA+gnxXm70lJCxPjRMqzI+4RPUeKc+TwIq1RLPOP8OP70VpG1TvBGny9YkuBxP5xsDB3W2S8jRYao3nwmKq3AJurfUt9GRJY1OreN3iX7aEBMMoPe5HTEZOrTm72RCt8eaeezxJuOLYxJLD3PYT/JHuuUD9d5VDHawE7OLlYbyEGkCgYEA2erwlOoRZ1hh/2eddfeRZEkeKhur625wt+29Ga2T3HmvLzVorHsq/krEE+qqZTDNk9I64dylbCYS6qJ6cJzEBlhyfimyQOooYiuUlcP/FvuXEAoOc1BwhmRNl1DkszX2XUMhNyWDNVCWJym47M1ksHlTExMOHV2cz8d9IToHqPUCgYEA1+KH1XpFkJSRhFzRqaq7YcimVfpIsRz08H3KD7MgkWXn7s06VBKGZ1eg4poHX0oSRnmbCTn9lq7KUXWCll0o+V9JueCmyt6EBV1103CERQa9i6n32b2PxAF3t1BAzr73oLg0ytgCfGrKBjCGnxhYWITt83agxh8gDhKivVsDW6kCgYAwfJvnJmWU7w9u+qkIdHs/Kx2xFNMd4UbnRdiLfBmoNtMJ2AJgTk90oUIbhF1BgqhbOa2sT6Hm/Fm9J0XDBL6BAvEGrVRiKTevEC9RW3jIrlYgVXx9n+pJnMu+3VrlnR4iBiu/z3LwS+v87sWcut6qfXREjDrZwdiASszGtdi6eQKBgQCWc2lKE2IapSzG8BF0ai6d6T8PmgwOcLnwSD6YU4Oe1lKaTBbtaS5KaemPnSAV7CJ0KR9Xf7qxDcdZBB7RnSBIIhi8sz0UW8s529nDKYhSrVi7iY1EQVK2YmXjDg+q76qTl2+/C+6EyfJHrU4tUBDbpjjOEZxcwwMYV6vydiR2sA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDU1+WqcQTmVY8dZbZAMaprvG8QzsVGX+ssQT1jDQs8G+GQdGK6yg4OwCW6ZGebGg8Wcnhm9izafQGc94rk7su4+jKkDttQv+GEpZf8yv//jdTzV1bhpDIdE7+yMZgN5ViR3YrFi10vs7Sl+E9KvBQJPD1vsDngjsa3rGLG9CoKtY7EpXi2Rhe7Un8+tp0J7uIJRtyZ0Tgu0K3cLir7Fl3YVBv1PzsY2qaUA3ZfQNy6Yux0ANltU0oO+P2DTknfkuCIC7+QpzECV9z8eIc8vQzRSFLXKRDKqN+1Ucmf698VBdGVUt7Nmyo3q/jeHJWyKce0hArUGhwij5/uoYg9TZx9AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmVoKJ8hSEjXCfeGUVdRxrQYGPCAR8GEmvS9TcgAQThG4L", + "privKey": "CAASqQkwggSlAgEAAoIBAQCubDylrliDnatd6ZVnl3T73E9gxl+KMV9Y4Gr9GVQcGYyYNlJMr6SezMxfk8hzkxyIlJjnzI4lXWPqAxloRdmps/7f4tCSnOTSUo+ZDsEjazVNYGntxjaOoEnSzkM+MbvOlq3McvW3XSmMDbRVOU79tfNP6PMDZHOxXnRMDaPRh7U23xVE08/gfjnOXQSEg05+EhnKzizkWeqJvRbfRKbY7ZnCL8fNl9Wt75PoxJnSdhdcpL6Qba4q6UkaEx6MJ0EidT2LClSCRg+/z+CtuFi4RgYTBJejdn4COK/Ho7h+MMZi5ZBx7uhZZ/6wefh5hWc+vUCozAQnfLsg66c6C34VAgMBAAECggEAZL+yXEUTbZrCJHHK0dZjRSOhWhXbk7gnCfA+/EkIE18Snc0qxo7h+LP1DPQQ4elEnwOuOp4mMSD7mG0H3PoT2vlULEAYF8e2SGJV/aPPHcVMOZCKP0SxuLqPScvIfYE+qPrSEvkIQ0z1taco1d1Pai8SBsNYs0nvpbEYXeG3EUxsrVcB7Dh68ydbHYlhUKMZXe0cNHyndrK9Jox9Z41kKxYcKpbzORi1pfnd+vIYC1+3geoWGaJTW0xnzpXpUl4EmG52NMD8uX6dpbJXpIpdMcKdCspUH2riSPOGTDwthvKW3Ews7fxGmEblDR7pYClrWPCn6UYiKTZxiZesNh6FlQKBgQDblX3MrWlbhG8ih18SFdJSlagy2OB5ecgf/zkJRsVNmyTO2+wv0dTsTLcwFafe7S0srqLxHc1ZEzryy+TxOHfplB5orxLYookAjZ8WaoZC50avQfkHMEIeJmo3OAem9yzbPJ6dVarR1TX8ZpID4g0d2ge4CWo+VwzY94VeEkDgLwKBgQDLWWn/s73pRJjl+Ll56ItwEdajSZf6VXLJFBIMeQn8GJ8o9pFn7YGUVbhkxBQPd1UjO0Eidn+YL/CywfH9ePcRIHPaOjI22Cl74hnCz5ManDrTH/S78Tu1CQeWKacbUaFTxLgNqo6z/NZww2CCgV051IJZJHvqBp2DQSYHRm9Q+wKBgQCQtaYgGzBRxadQBBKdYpAnKMWeLNtScvV2UMaP3HnuuQ263ah7ozdFOxGGuN7WxUt+JODxMgjAaTHyDHkml2Y/IwQfTTGIXyUWnj53kWBF+xDUMxAgsqcAI6TgGya/3ClNmleVrH1Up8RaQGZ99J1cTPHFUT8ZMlkfK5BS/IiQtQKBgQCpYGTGM7Tv489nXnE/dc8PHgymHdqVDS97BVizQu5qKSgJOreK1W2lXHEmnZwH9eHYYrayOfm1jdjzTFCATI2emmVlVCwXOp3zLjU+6x8gfxkQWgHDuf99n3PORAuI2cmCuMyFtZb/nI4RhuuQSKiaTsPz9Euydqgkd9NxI938mQKBgQDRcf0BavVuHEZcSegoI0wVLynCUapeCbnUFv32Cer9/V/YV8/ZcjTS1P/YlhZB5L16LguXDVfgXa03zeTeItjsW6feR3ZJo3WzwS9CEEuLg4OFu36hXsO/Tncv8MGO8weVYLGjeHhrbaPWmoWGhmsm7VP6430O1MAFSoZj6zyBzw==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCubDylrliDnatd6ZVnl3T73E9gxl+KMV9Y4Gr9GVQcGYyYNlJMr6SezMxfk8hzkxyIlJjnzI4lXWPqAxloRdmps/7f4tCSnOTSUo+ZDsEjazVNYGntxjaOoEnSzkM+MbvOlq3McvW3XSmMDbRVOU79tfNP6PMDZHOxXnRMDaPRh7U23xVE08/gfjnOXQSEg05+EhnKzizkWeqJvRbfRKbY7ZnCL8fNl9Wt75PoxJnSdhdcpL6Qba4q6UkaEx6MJ0EidT2LClSCRg+/z+CtuFi4RgYTBJejdn4COK/Ho7h+MMZi5ZBx7uhZZ/6wefh5hWc+vUCozAQnfLsg66c6C34VAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qmc5QckxBKLCgQVhMBisisvainagMKYDEeHQkXzPU5ppgx", + "privKey": "CAASqAkwggSkAgEAAoIBAQDBXIuC7gUixPiZ5TkXpTbZMzAt2fdfNV8gci9Rs7mhdtcAIWoMTTqcEEvuY0qA4VeoyiHOZrwWijcN1qhL/iWIwm+35ceqARa4WKzxqdFNUUqrcQ41tm5D3hk4Mc7+26KhRf5Rb6w4ZQxnadRHD26GcYOtGP+LLTKGFreWJOFcbwGCnsDkrW2f/jhsVeDwXAohfuQw2x9YkhhW8GBKeXnVrzdKneX98j2TmdQ7XxbqpmtYbSRscvvYjK3sliHJ4iFpqpXpHXIRuflgmcWOjNMQXBs1tNZpo5aWrjFngotGIqLWoMMCi3WgoMfhby246KpsgmtFDgQB0fdol1HmPeaFAgMBAAECggEAZQW03fL9O+0s9TqNWY032sKjqVD3rQZ1bL47erQrh/BO5AKRJVw0AtWA1kuJ4UvaQJValDuYiS4tFU3RH+LoOUtckve6GVf4RtgNgzT15S9Tk769bdKiSVMAWhuryft2PEwVUvbFQ7GHiYABKB8n35Xu9cDZwh0bCHNV91vNYjyygNg+VcUZK9TP6djcZB4YvdWv/WtpKgcAOOcPtgZbp3GzFHL/BsSNBHGg6Lynt9StYaZ6mqPYeYd6klTa2bVe/xkVrJ1cCPkWcFBk700JoPw/La2bARHjew46BSLf69wDWTQfl2QdUMNHVjwIZfIQN2dfldJFx2bYGAEhi7NIAQKBgQD8GKDmhw7ot1o5ha1Wl+Uvx7tfgtOmnouybrX1Ce0B8peDfD4MAUhy8nVwEjyoGVlzbY89odT3hSgp9KGD5h+38spAo9Rr2Hb5V2QxehlHZCewr+bESuL02bvxZnAxSFjJV0B6/A9anyBWKzw4hSviEYjvE+W/VYJLccZaP8V+yQKBgQDEWxPezoVJNVYIAKvX4ssX3nDfc+zdh+aAOcI/+CEmrWZ1E3kRD8bVFt1LFND2zIrlU/1FhuuhiL8KtsN4slonCdYhEi6kUnbsG5SkWfB8+TM391qvrX1eLBD0u/NzPfBBaeg7BQWFUSsXFWVzRfZG2VzXm3222AABJYVpcD5b3QKBgQCnkweBtc1nTFohWoa6xQWIGVCoUKK4YzOhTI6PcCWn4cZtlKz59fBe2GTQNo8zfoZDgFRzN5wFXPIx0Xd74gC7mhxvk3ekqKONY1YqvWsIVb88Z/ESEmWDNSkFcn6pg9nhHKq0FdFu/8/S97J0L7HX+Kf5pFRYN1MBK4QagcGaYQKBgQCdEV3rtLfZv9h5vk+3+asMBNu1Yz3uV2+C0rEYCpw6HCsBK/qEM2KRwiBylswxH51bpLvMigiixohLQbdLLSAAalXnTmwQ9gY7CDT24xsEXTMjabIZJWZLlmRZ4J71aG5vZRBnZbTs1+joJi1o8GX4dpdVwQPm5xHZ2PHHTgoT4QKBgHU4FGuQxOvbPXe2kEoxtonjTXZFd3ALLn7WHVCrlBEYkj58j0aIx7RsF/1dlVPM4j9SzAldk5Eze3cZdsu+Ae8wfLerxMwmQEWlwNGmttp45t6sfVq5Y0Sas5bOSRTfUQFXzrAxFo+5ZETYKN6OkDnEv3xbTQTnKaPV2pcqFx52", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBXIuC7gUixPiZ5TkXpTbZMzAt2fdfNV8gci9Rs7mhdtcAIWoMTTqcEEvuY0qA4VeoyiHOZrwWijcN1qhL/iWIwm+35ceqARa4WKzxqdFNUUqrcQ41tm5D3hk4Mc7+26KhRf5Rb6w4ZQxnadRHD26GcYOtGP+LLTKGFreWJOFcbwGCnsDkrW2f/jhsVeDwXAohfuQw2x9YkhhW8GBKeXnVrzdKneX98j2TmdQ7XxbqpmtYbSRscvvYjK3sliHJ4iFpqpXpHXIRuflgmcWOjNMQXBs1tNZpo5aWrjFngotGIqLWoMMCi3WgoMfhby246KpsgmtFDgQB0fdol1HmPeaFAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSBxDrxA5Cs9XCPHZkTQML8frDa7uFoCRHQDtGrkXCcC6", + "privKey": "CAASpwkwggSjAgEAAoIBAQDB1rGs8/efBrlhYevYWLmiREq1AmubenyJHL58MAWwgk/wFQZbTEHGQQQZT0AoR4vtcn1seODzUKxNCH4tpYOK+F7/ey0gtoJwL3YI0ZwL3kPIq2MJW2ZnqUZ/v/VkX5QtTUPfyfZfQnRYcZ54pWYHdFzqUbOwN5wD+VBWq+V6Fu2aIFuP7/RUPeRZ83CXHxsD54hTEDlBmc9lut3rVtFB0s6wvO+pRmt9uLUg93GtG/oA+qeEUXNj0l6XtoZq0CdJ2kj8bhKrz/oqx63g3kg7Pyv1L8Aa/MC7GjJ+o4R3bIG+sk7lDsm2bMI5HkfrEVgE+FlEvCS2FaDTk/jVHaDTAgMBAAECggEAOqCjELqhlJnGDCw/1ynOy8N4DRN0VIxRim8FNi6YKfDgGK9jQs3nvvz/LmCH+SbarbDJOru83hryYkJFV60OAkRpB0DMP260ORZBzx0G45gQTGt6AuSALq5GQnFe2UMHYERUWSWOvPUul2mWEsuD9pE9YSng/VV0fMc1g2FugORTm2SYenOA/tZfm6kPo/H9Y0aiVEKv5O9Js8GhGa35zCrF0Rhf/awthNLQWb0+vi92iBafrEilZfuSpD9mgbttRaCTaN00YwC4749jxlQyIwuUEodWwAy3NFQ1SuoiWNfUJbmHtuHf+2citsLBeUWcev7QWf4t+aFHQFUh7sIo0QKBgQDl3uRHHPV2DwfRbcyThpeGAg/SkgnsnE+CuSKCtTdK0l55Ck0EIeElsgB15FCinntJ3ZADU9l9gtf4toqM7OeqowwQ+8kEaqzMPILOicDs1SHUAKtxzUJjD3WuGnEgYKd2JjV7JDvuQRHwyht2Qhaken0Va+wJIal+5tLZ+z47hQKBgQDX30pkLCc2QJHrUyca42jaZVAvh8W/no8nXMN7LAJ/xPhGGi2tnTGfkUnIg/+8IZWLzS5198swPwm7nH1UN7QQq0atC4Ld2Lf8dn3cmyAJjcRll4lt9AB6VAJp5rkAAud9VJXCn2e0J5elXoM3YLgW2VlpFUy2JfUmEAh1kDr+dwKBgAZYVbLE0N22Yn/caQY1c99GFUu5rj5yvhscoyA6glE1Z1gt+ZxAlydkN3EJoVQrzblnPT9qRBmbz/xUhZSIQYjLQV0CpjTSAP0OOooa8VFYPLvOXO0iPk/fsF7i6fZ71IOFYHqKsIDOGQGtgn6MKnXVz7gUp4pE/Jm9I1rS/Y/FAoGAXxJhEfL8JgGUAj7x5v6mjCC4iuZR6g1r4JsTIKkGRL071qvq2B5131++TggMVg+4bASmZKAIJaxtnenSrIeHzxuPmeCK9ydeCFsrHUBYgLyl9VQi24DtwPJEyd0qNt4Qk3rwJfHMW2Rgfh08zuPSz4VTwlr2GPZonCXNg/FMegsCgYEAt3cw21h3X3VHmAxgWEU11XjNjDKyCrWUW4aYEUjGso0M5dksFLDSNezCls/k7Urp8agl1wRE9Okr1RILcle5bbhPVqQ1oXobANSjIEVhCwmCjnOuYMBJA/tQdKHqyOFe3Z/Sq42n7ydMdimSmBb+kf5uwLL8hWjPNDZJrxBl+YI=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDB1rGs8/efBrlhYevYWLmiREq1AmubenyJHL58MAWwgk/wFQZbTEHGQQQZT0AoR4vtcn1seODzUKxNCH4tpYOK+F7/ey0gtoJwL3YI0ZwL3kPIq2MJW2ZnqUZ/v/VkX5QtTUPfyfZfQnRYcZ54pWYHdFzqUbOwN5wD+VBWq+V6Fu2aIFuP7/RUPeRZ83CXHxsD54hTEDlBmc9lut3rVtFB0s6wvO+pRmt9uLUg93GtG/oA+qeEUXNj0l6XtoZq0CdJ2kj8bhKrz/oqx63g3kg7Pyv1L8Aa/MC7GjJ+o4R3bIG+sk7lDsm2bMI5HkfrEVgE+FlEvCS2FaDTk/jVHaDTAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmXmdPtQ6bT9pNyHKjfDUB7of3cmXQtJDBYKKeUGTEn27d", + "privKey": "CAASqAkwggSkAgEAAoIBAQD6xCvltFpdm2M8dlK6d6laqnIjuZRUtxFn+sdK2LqCsJVgg/a/eT6t8R8vKphjRN5piOzVJzo8NZC2X9UW4TeL6MBNRKrWzCFsTKwdEQM14Npjcu3wufi00p8ZoaG/JeEucXmmRzK10cXTYTG1hFcBWxWi4IHwsHM8+mNCNoK46S4Ly7ehQTi+1QLWG/lvd2FLN26FFNEhadikTd7+Psq7pvYC4XIAieU3LturRbfvGKzqEUwFTrayFsmxTo+KfiLDOyjCPjkwLL7+VsDmZUpHKkAetZpVx2NSBLD0p42qUyG4AjplfCQFi+TaJZqIEqrXAdumNWYgjBNR/hkAt7MlAgMBAAECggEBAJJ06D5sKyroifjSElcddCejzK3YwS0JDn1wFd083xFdGKEZ8Y66vUTRwqjFc+LmYg+5DLkhA/4OOsqJBecq+koYUdfO9wgkiJC75vnC6eEZxfK3OQiTVRImwQ0zPUhqUy3Q0H+wrYlLTwK5jVK6TCZakDRkcv+jzmoawsX1GDvtrCV0MzQkZL24tz1SDDSBDCijaEtyfqBqWOLLhDjocvYuEKsse+pu2PfSMH36/0dLaEwf2h5tib4OUyuTfA5knjbcEfsSFZHQvf84Y55baOuJbf3kHqEOKJ2WG+IYpAsVnpCN5Cwthj9k4TCpDaWCBsNFmXKBNZ8ZNJqXf+J30bECgYEA/aP8hDGYnbtMM9PZUzsS9RyzVx1k/IyJ9bOOD+RbHzomf7YTWeOv3bvbFzoyF1acmN+cY192F2w7t9Owckk2qSk1VuKHXjw/E3v6xLRnJTvhi1/+i7887A9jghm3MvfPtsyArRagcWxD2mnHum7QeQQbBG+Om64XVE/N2Z9JZlcCgYEA/RlXIPlprSo8gKKwmBa2+mPB6VgLXZCB3hcp+MC3hzzmbPtOup42Ap8g4YVpk5QNbizOfWEsYoT3O4jEFE6SKlzSvhvvWnw/G4ZGq7QnIp3ZKY2pn5vHenjri/RZzO9JATQ+nGjgqFHGvUXXUZ8bNq8oP0Fjc9hrdv2c7b5tLOMCgYEAkB85Ighodt/xWdW7vG5pxDttsEd0lYhp7+H6DA+us1zAeXsFHeOhj7XptRYNVnORgdA1tcWNfZuzhy3TKe1uEMrokxke4C4NjU26XUFBBsgyzZZbNh8RR/Uqjsd78IsdTPqA91lPC4QAPkAzDD1hWhI6I9gbyVwvx2mdR1YaR/sCgYB7N/UFJqfeGCvwbEQRJy3Z5Oso0SZnXMz89MYIRrqS6oE8GXUQwamFyTbW1H67zF5lfwbgX4ieRiGfKExdnormeN5Yk30Jzmdi3RJW0ZQj9DkfU8p62/pXk7sJHeMCNJSUM30v5JdLGtTonLHhGNbE3q13bjwe0AQxn/Lgg87fBQKBgFIJuMQ+RsrwK7XJ+Zm288rKo6kbRx8SVm0mjhCHaZCpcJbhlFB+8yvE++n+TKtgDp+pFrjkQf8yYO9p6+B/tCbQ6JHNCfdl4INMGAaCEAxqLnZPzB5ToxRYYHJ6RDVcBtX2inpZAKr1uKra/cLCWWg/cJLH3ozITCL5tHOMWevE", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD6xCvltFpdm2M8dlK6d6laqnIjuZRUtxFn+sdK2LqCsJVgg/a/eT6t8R8vKphjRN5piOzVJzo8NZC2X9UW4TeL6MBNRKrWzCFsTKwdEQM14Npjcu3wufi00p8ZoaG/JeEucXmmRzK10cXTYTG1hFcBWxWi4IHwsHM8+mNCNoK46S4Ly7ehQTi+1QLWG/lvd2FLN26FFNEhadikTd7+Psq7pvYC4XIAieU3LturRbfvGKzqEUwFTrayFsmxTo+KfiLDOyjCPjkwLL7+VsDmZUpHKkAetZpVx2NSBLD0p42qUyG4AjplfCQFi+TaJZqIEqrXAdumNWYgjBNR/hkAt7MlAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmcndsRHcVLGUgUMVjXczHf4qU84WtjFb8cKjgQHxPBkjA", + "privKey": "CAASqAkwggSkAgEAAoIBAQC4olOupPQAcn9YS66bRt+6p671m14N78z8Hv0pM+kF8QmA8G9DR9z+GJxFwZanQkIiKcwpw+o26lPYI8XGBh/ohTWTRgqIV3Ra/SGyIgMEIKjUJcoy0+/rfS6AgRsDuGWYWPTGs3i4OCc7CB22in+I61FX6zzHtxIiD4ADpjLoFxIdVEoOjp2Q3IErn9dyUx9rMqP80+WzxYLxtlaEX4Kt1vRATFk3yeg/6l6g5e6XctqD1gyIPaXfYyXDQAKQtDnGuc6Yf3SNvZjjtRImeEb4gfhBL9KTIvL0fq7cnNrQXuneupMQ5ho0naObLj0LBdJ/dVcIrET+WZvkdD8aTe9TAgMBAAECggEAfziq/L4Au4YppUeQ6sGtS8pbTjVeW7AOyPL5cjioqkVqTQRfRjbwWc3PcGlyS5HmS/ANFAJBEtHoMBiGIGr79ZZEUlSC0Wuha0jcvQeemGuAqZ3Yc6mBufwp3LYZTTj0GEPDdl8YIaffsFdpUeyg8FFlXXVkDiFhR0Ly7JDKpwyBG+p4aeqMmPYIYqx64yy8ddqooW6XBBCXkkMUDWwE4Dd7Xpokx//DKVmOmu85NOkCtqycptaidkdFKVobRw9zDF+7xprs+kSJOOF+nIAHaOStzuc4x8Am4WJqXNNTX2yGty2gEoMQKjrAu5FtDdNqGvrwbfQ/Yt1etHZFjh5yIQKBgQDzIVSw64Ca/6roWTrVBlRd/OTvWzjMb2vfkRpQIq6KpMpxP8qbQYV+nX83RoadpcHAk4kBoimC8L05NGTZjLuHMZ9fAs+/wVXxyhmdHZbCG7yUMF7f/j/IBc5yxeFRYZs2gWuVhdPrFqz8HAnTY0rHC+JTbBLxxIpA2X44RgZAqwKBgQDCaE/7hpAH6+TXtaXdeS7uxJ/efZQFccuB6giHCsM+dylEZKtPfs6sLpjeYQo/IaOLEhpvBwflOc8eOeS8uzYr42vo4FqvZ/nWB/vmm26QV697YQD6HabqBm8iL5NpIGWg9At/7doxfZfiRVcioIdDvgNx22hNr8QTqPBS1jUb+QKBgCX8HB4z/Pi6XvpEDpP/lCjG/QGEUABonALmyaShdoGEs3g0DjRpbTDV7G03YIq6veWXZz1RF4k0kWuhiuwON7Ish4ixiMGdtA69k3jfiZE0Aido0znNoCtg9NsrnUM4q6Y9XBCVQwGknkwZGVPkXGdyrN55sRACs9Lj5/tkvU9XAoGBAKMkUIJ+QN406lzO9fsul+ENJi/a6F3NSf+iuzdAI+qGqx3W8SAMBTne/LAZdTTXcNvi/EXR+6E0awgtgzOSU3pvJf5OUCvEsJcZKh4yr4z32K5MEDrUqV7YuWhRzn25DzALvJ7FpoZDpDLhB6dqWTjS+ycP/a674mqxKcQKOJVZAoGBAKqFFYjIOGNpv46dgXLcwN08GUTzUkOuqs96b5mmxLGE3CGAlSUeeoaKLRlh9QvjpMQF63BBiPcYetbB/NRWL+225lhAyQfxWSJKRNlKos7g/VuF0CNtTGT9FYhZkekBuWbHiIe03SYlzAEIF9FtR6W0AWBK/zv/gsQHwdIoZbbw", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC4olOupPQAcn9YS66bRt+6p671m14N78z8Hv0pM+kF8QmA8G9DR9z+GJxFwZanQkIiKcwpw+o26lPYI8XGBh/ohTWTRgqIV3Ra/SGyIgMEIKjUJcoy0+/rfS6AgRsDuGWYWPTGs3i4OCc7CB22in+I61FX6zzHtxIiD4ADpjLoFxIdVEoOjp2Q3IErn9dyUx9rMqP80+WzxYLxtlaEX4Kt1vRATFk3yeg/6l6g5e6XctqD1gyIPaXfYyXDQAKQtDnGuc6Yf3SNvZjjtRImeEb4gfhBL9KTIvL0fq7cnNrQXuneupMQ5ho0naObLj0LBdJ/dVcIrET+WZvkdD8aTe9TAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmTSPkZzHvNmHtcqwE9nGZjebbmFsrPAvRYPXxrbe64o3v", + "privKey": "CAASqAkwggSkAgEAAoIBAQDTvih1SAj4ioy/YtpD6Ewu0SvPlH2gF5GsUZ0eEJNdBwV7PWfXv+F36MdVxL+f4wFekW/BDp0kBFjDtnjoktrcusd6vpeSXndY4v4y/3DPLzGPpyldZIKEjuBRCm0PdUcl2mLXoH2hEFo49Xlk8h1eyXK3yscPJmRU9ANlHCmgIo/lIDdISosCn3BQwCx60FhVkfEiO6Rt/vzMH8j9QswLoqpAiz+XQ8iDqHNmsDpwliIOELmWgiwV61DVzOXPzvyHl+MhCLvvr8UokL2jxOmldAiIScXGl8dnMIKrhG714UIBcq+4757XF8fuL78nViSaTe1GB4AoSCSspQWvbq4dAgMBAAECggEAOcp5wmDRyfwOpCG3zrb1LAX8/h/aFbq5EJ4J0u3VOpuy/ErrL7B4OkD3Psp/PoU3l3b8WGXDr9Pb4jbIUznZsEruLOsd9V4BFuqFVKfxQyrvTPTjzlCjasiQIq5Ey+ZHb+Zl+dIc17vd1BPzeQC30WoL/GvE3rasxZ7/2jXQiprE7e73HABDtje4t3BKVtdc5+2Za5K0mVJU9AF9PWdp+SRNuvbhrr9wj1DPuzJVmOFkgGHWY8LBtUlfixTvH1cOBb+jXSOf7+yOjPNi7s9MpHVWdejM1Sk/TYKGfkv9/j3esLdwdCI8P7pupzzNtuFCjRMdZ+4Oul13YlfKULEsAQKBgQD4aEw4V88SRbM2WARFJhlWq/WqsHV6UBcSq6N4Uj+EmxUqOIMG6JIOcOjDazBQk5mjAZMMZM0i2jzBrSEE/Mtpeywj8c77xs7Kx415cgzdIKM9+oFcHbDYEBGxkekiFm6u5Gg+dsbh86gSTxcbUP+R0ORGg1bLq+YmzJPLLL6DAQKBgQDaNvjvSE9lAlDXW/H2qEI5PxfBNf2iuWhVNHkmDFb/0Gk4ietx5J7Q8oqTHWdts/QpQ/WsFWVTT9Fastj8qEaMubO0z7inl6IDMBv8KKRKsaQq14d7iT4eDvJzB4JdUGZ/Ch5OHTW2onMnOJnZnLuCn6ek+Io5igT3glXGIdTXHQKBgQDx1ri98d8Lbwg21CH0IE9y7h9SelElL2wHJUsVDR4Bv+ovHK2TwEDSBmLWPjjfeZON+y5qVojQcZ/M/vyymlp+6wfiRry4qqkRCo5Vug+ECQ5kfMoMIGvXLm3Lbr6GDUjcxEoo5gJiYJE0ogNg+M6X68MSUzPhPg3noCwTFhC0AQKBgQCMrxxWyHvHV3LfJXwd1eS8G50pB7H6Eybcp/PjP9lnG+p6dRDCYO6zL2t/5VklNPuZDyN4SmMFD1Sd8OhMHAFAAQmG7NTT18Kv43hnXZxuO5DnvgSu9JCDuIc++fxmRMuP4+od2l8i3CD5jFhEH/QUBvKCPWqAJieFmxXJo04hUQKBgFCkYPBQZhgaoGbRkvjRoh5Nz7pYZ8nfIzCt4B1NJyIJNUGyRBIuamC3Rm3mBF0fLg3bM2fYC4YdfInTeii1u/UXLlYgw1u5/O/xN5/CliLRX5ALDtm+noWFqxImlCGmkV4ZEOxHO+kuaxG0V1mzcMkYvCj2u2YbPKMrHWZ5PN8D", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDTvih1SAj4ioy/YtpD6Ewu0SvPlH2gF5GsUZ0eEJNdBwV7PWfXv+F36MdVxL+f4wFekW/BDp0kBFjDtnjoktrcusd6vpeSXndY4v4y/3DPLzGPpyldZIKEjuBRCm0PdUcl2mLXoH2hEFo49Xlk8h1eyXK3yscPJmRU9ANlHCmgIo/lIDdISosCn3BQwCx60FhVkfEiO6Rt/vzMH8j9QswLoqpAiz+XQ8iDqHNmsDpwliIOELmWgiwV61DVzOXPzvyHl+MhCLvvr8UokL2jxOmldAiIScXGl8dnMIKrhG714UIBcq+4757XF8fuL78nViSaTe1GB4AoSCSspQWvbq4dAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmX7K6pwskrZB8hvqwTgukFTR6o3DHiVui9PokxuJULnvr", + "privKey": "CAASqAkwggSkAgEAAoIBAQDPYkOtFBtPpJqDmAF4bp8dieu7d1/WlaMw2VynFmL9AhcydjDFp72N+YRztF8e0jBz46VkBGQ9PwZHkVgWNv/X7pUOELfEaUpg/KCx+X8uxLv7hjUb8ne2MVP1tO+Axl6cBtSbtQSqTxCTxK2I/4JRmnLNWcZ65nRdD/1CrBkGI2fwFnRYkSexGyFlDrhJtfpiZAB/lPk9GPcxeU6i2MKrx9S/vpj/DwV3QENlF/YSwdUMxbaaFkQHgeYVNHAIUP2HsErj9xDCNbzh51B4uLxIahOWs/exHvHBXab+xu8BPjIsCxaKKQ264jWssa8dDBRJ5O+eRDPwXj4TFdoMO9JXAgMBAAECggEBAI7qfRENxjSAjysY2gqQ0X6dyaKLhbRvsuK7KKrNNrJ9elcANGRCUNNCnRDPwK2Q1GtI+nWOwTWj9UPk2fuVM4Mvm/DxfHMSzHtCHcwI0Kj+Uz3nIzp7QhyAqgeuBU+NZS3JV0Nm4CwuCJKM+7ppuvlZorv5nlqb7p0jo7kKuMQM6znKsw3YzrOJLBvrCxWAo4ISpYuFHW132bpleO5ZY0Ipx7Auiz43C0jnq/v2ly7nrrPlp8xqbRJ37RM/RQyn+f/qTAWAJvR9LrHZQvP3+qln57+QQkAFqhPeYhXpXaJQQ4IPuEfAiLcAm0IWgrULRI2LHboQ6HW146GItKyTBYECgYEA/kCAKZnrryYGaKIYQJpzWqFLv+z6KQVtqXoHizkEsaNv9oHXl8zOauQLm3pKMs6Zgd3Pt633UOm8glfnqcOwft858t8h1hgd+p+xvz+LWx6sVJTcJ3PvyhuF1I2oGQ8Jl0oKlWP+2LYqkFK2Wp4BWTWhvopb9sX3QaXh75nOhbECgYEA0M9F3caJjrFagtEGWB7tDPogqoLPLrQdFLRAhYRu6ds33btclvgmv4g852F7X8qo5Nv/p/uMbcWRVczfzoV9BO1/6YMewT9Nc/OrpLFCVkt8k90XFVJiRTowfBoJb2Aojiw8zRs7XiwjWicdydTHnCBCIVYHd8hxIsrc3KeS8ocCgYBG1A8gB7oJa+1jHqzk6mHyQHbKu6ig3ttC2DTbywGMvvwEzv0RU8O5MVgucu3So41OCU3BXJxGFScnpHdr6pDzdxo8l35klwla9TveDES1GKFnWqTN9NU7F1m78c5/VJoWZFD4dwfatTy8Qd589gFoKbGqU/70iweraRu81LscsQKBgGLg5BrC+zyg61VrGe/8pRAyGenki6t4CxVUzgDr14HSF0BeitfKpr6oCv8egEe6NgQ50XSAf90zY0EYBRtMxwjgVmQDfTrReSHhT3RrpBgtIs76MQYdvv89MNxzj+g3xrycYiZWMOTFTfBQ+aArrGJYPDiA/oRQXJK3MaMjj0hdAoGBANyYagDRItp4Pv5j8b5nXmZq7l+9BxerzPwSzK147Wh24OBd6PRHxi9wJRrl9MeExJlf/CF764OnLodGhLb233v4iRG6LFb5j8XExFFNrVtnNbjdxOMKUFzG8FTd7UNcVO/8o2nk/qsuAAingYXMbkzhEl3soB591zs7GetvYDVc", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPYkOtFBtPpJqDmAF4bp8dieu7d1/WlaMw2VynFmL9AhcydjDFp72N+YRztF8e0jBz46VkBGQ9PwZHkVgWNv/X7pUOELfEaUpg/KCx+X8uxLv7hjUb8ne2MVP1tO+Axl6cBtSbtQSqTxCTxK2I/4JRmnLNWcZ65nRdD/1CrBkGI2fwFnRYkSexGyFlDrhJtfpiZAB/lPk9GPcxeU6i2MKrx9S/vpj/DwV3QENlF/YSwdUMxbaaFkQHgeYVNHAIUP2HsErj9xDCNbzh51B4uLxIahOWs/exHvHBXab+xu8BPjIsCxaKKQ264jWssa8dDBRJ5O+eRDPwXj4TFdoMO9JXAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmTcEGm5kj2vjQUbXTXo315ATwkUaggyJtHWsRVcUKN7PB", + "privKey": "CAASqQkwggSlAgEAAoIBAQD1Zl0OXDb1tHPDquEh/+xKF19vIbjim4xWDc9sK2h9OATAvGjuTcczW/YJ+swqrPA6zin+J1XrCThWDYBuQj9GNKR8illHZriqlwppVe2+7bLWca2dviLXmGh0lUlwJ6u7qQduPZuP4gZADS8YarIbJveUZGIksFF/php+/60OZk7nonapFlb3Sn3IR3ke9CS526pH9wA91A4UrvgKOtpS8K4NjScTOZHc62sttvg6/ssiWBsvXnwu9hhAbXCwfK1//A0wuLznpHdbg/WijnnEAijSBnapdgcpYIQnrLfxCYF+goYifIDlgAIz6pRvoZbtdUcZ5QgoyPo+w7Po8TSLAgMBAAECggEBAI5CUR/KBXJaseF0Zh63pdstwX1DJ1L2qVwZlW03nNM6bkbs8kdzf08euHsAkOsMZhcw/NcBJqWiKq54FUPV06h3TAOGkEr8GYGLHdYColhUo5/9NpCDcN9a0vMCuBf0Z3Hagxw9SrkWZlkrS2n0MFvdMxkrOFncfOJrAGEvBruZIO9h4ESHQku74zvnkaRTVPtvL5OKFKkWb8v5/5oJ/p5gAOCV5lo1OzFNvjPmHJTJWck2NwFMvQCrRNnh7/E7/1/GmBECK5/HpaZQRc0PnGER5U9/LEbfJU+4khHR3VzVr9d5Pn3lJhBmTmLaWitnWH4Bt4XDkbO52rjoD/TEuQECgYEA/wi/OsalFb/ThCsX0UJh+GukMjY646RMGCGvMVEPLkYZi0An0pL0Vbx6io7C/mcxBdz+8qSbv30UJMLbjC0IiGWVsWSamsQxr/O/z4R5F0ByTqyW5KrMVNJMxmjhKRoKTeWV1pTpY5uIbnd1xX/twxmQO6iFz2Nn7TTTeYHo2xECgYEA9lRGsWkaXbZ6zzD6TiK5I2taDnLqk9GSkwPp3cSWgm6iou7hNqLobRVUeOUAepbnYraa3lEOUyoJlrzBiIdBJUsXObs641MiGU1rjbBm712tdR3ppGPSUEromrCy+3gn0LLmZHe32gfZSkEdOyQWxdR5CJbeqMroT89S3tZe/dsCgYAmb5YKcKeuqHNjRu9W/U8wlmBvpNapOjixpln178Z+7depseiOhtFGHprFSRDAMKMlxBG0VfSXHm2rwKY/8QWJMO4nhwb57jmiz/SHfOqXA4J2svIm0krrOaqSeHn+rMsCxGgZp+WoumcMZvqb4lTeA3tGUnagM9YU3NJGTLrgUQKBgQD1pDEi9davISvytbrGdGX/ZixWQE6gvdrW9I4g8svMohtZM7Iu0+HH9f9Y17TUiuuPSt3BWT9Zu4/4W577UTWrxOgSUB13WA2nAceBcioUBWzWX9AAePLf0vOGXzL9BmNeASkzgxc6O516KNjHg0OaYDmaUSkVVdK409ymD0yHBQKBgQCeBJSjjHUnpCOtXTSuPw7L/f/R4jZebP3LCqnMYnMAWe6w5VIBU0y0Qty7SsnDkWkSHTBjCo3uO+FzHh4Vh94VcOrtZETowPsXK0+Hnrmptus+7zoLwZQd6CYSNpxE0BpfUjv7YoPJMQLuYCKU4DNs4bgSt53SUJ7+qLjGbbbPpA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD1Zl0OXDb1tHPDquEh/+xKF19vIbjim4xWDc9sK2h9OATAvGjuTcczW/YJ+swqrPA6zin+J1XrCThWDYBuQj9GNKR8illHZriqlwppVe2+7bLWca2dviLXmGh0lUlwJ6u7qQduPZuP4gZADS8YarIbJveUZGIksFF/php+/60OZk7nonapFlb3Sn3IR3ke9CS526pH9wA91A4UrvgKOtpS8K4NjScTOZHc62sttvg6/ssiWBsvXnwu9hhAbXCwfK1//A0wuLznpHdbg/WijnnEAijSBnapdgcpYIQnrLfxCYF+goYifIDlgAIz6pRvoZbtdUcZ5QgoyPo+w7Po8TSLAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmWfHjXRK9udKSkHtKhguehBAzW75LeHyPxRLP1ZykgdPG", + "privKey": "CAASqAkwggSkAgEAAoIBAQDaCLdVLSfGmXFz2qwciYslW7GQv8oMy3pkBotMPzdXIhSYXB4p8/HjRyAeX0DeCF9vC1SdaHXc9p70katM/K9AcwMod74QIUVI9dCS0oQKKW4oI+/Az5nYXEC/C1Lu70JnOVWxt4R9rTU087UJkPDHs3DsVN5bQ4R6wvQe9crotxRvRiXvOd3TnR+u/B6bzQgRBqglj8GUYSmLe+iE6e+WXnJhRcA4unyixljSXD3rmaZf3GI4GSGhLnauJbwWpmmyTfH56J23rnJLQnQJuygaMtreDQrfk2u9C8rSxY7pFNQCDahkMolicUsfgegN0hZfVTokHypbB7Teb49e1iaDAgMBAAECggEBAIQfuAkzneDpZyjPoHCCoQF4eTfAIQ5z16z5kjwYKs7wZg6V8+l0XGZf2YTOMB7ccAh4k0P340SNZnHKPEYg8Ypap9VECrb3kmbOHyB51W3bAVftvwHWS+IitVGP6SfFcTXgNp/FF9KYvZ9i95febyp1AL8WBtDDL2q87PY9+EHgYQTqv5yT1OGXhGN7dRMxyDGfe8OEZVjpsQ+hhA4/c3rPh+uZ3ugZZ4CnaistyNMywPZGYVoPqQg8/HRspSL97GctmuCKph7qQyKGVvFg0ExJgEQXVNSjVw0z7LXmDipYsz+3qR7dLGAQvpfXTc2szAhbOE0cqKUUlz0qt9M0MKECgYEA+flgc2Y93ls8/MtZbvzwbbi/VX3pfXKikqdizTAshwJzcbHMEohzHRnKb6hNk/P/V37c7NJXZWa/k3LPmz0Xk7wtSXSHpmk/+GEMpwjjQ7urRSg8HMHjN96U5amqmA6pZAYsv0tIouCoR2+XPi0YY2meIRpwtbeR4npxBbhnGQkCgYEA30o7oh1jy93VnCWHRg4g7CmV0H0ufgJfAcjQg07Wo+fquiu7QfmBHqyWGJCkAcT9pC4Ia8o7Xa17m5Syq9RyIPlTJMmr9KCrFQCyj9Tr1p59MK1FbkpLTCrRimaYmR/dQJBTfaaISSZipXEKyw5VhAz28tLBLTevwdn72YfT4isCgYBFvVk3WNLx8ip1rJXq7Q52zhAzXcmCgjTxDVn3PPVvRTPICH6SvRbAi616sU3TdUNLuc0RFS3k0GGqVWGuQcEOKnXIBIbD2qFKPmk1QLmG8Bi8VplOvJkTwTlxSYCao5yGl2JsjChbqKnKJEvhwNsJATJoseO4DtrYgKh/nA7HYQKBgQCd5diVo0LW/1/2s3MdTxBo8F9It70QzoxwrpkEwdN2xKFwVUxuMwnjrxfU9zODLNJQL101HCUu8Wbfdh+C8xBh0O3CrfozWwqgJ4Ydv+umMR1GNsFKZK8qhXz36eUvIyFKbsUbrY/iaoqHg5CmVtSSNLjMrcx9NUvMQWGfSjXDUQKBgHQUaT18/o+WEETXKLdyA6L4BUWSNzqTtt8qvDLffV+9/6YwO9fAjN/6NyRp4iBFtje5uuw5e7SfraWY34GA9tHv6ClGDYPQB2p8MwNq+8TyGkAxiPb6kqYIMGxxeXnwwac1ITK2FlAmFrazn2WmXUChB0MIiapyLGOjHLB+sH9l", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaCLdVLSfGmXFz2qwciYslW7GQv8oMy3pkBotMPzdXIhSYXB4p8/HjRyAeX0DeCF9vC1SdaHXc9p70katM/K9AcwMod74QIUVI9dCS0oQKKW4oI+/Az5nYXEC/C1Lu70JnOVWxt4R9rTU087UJkPDHs3DsVN5bQ4R6wvQe9crotxRvRiXvOd3TnR+u/B6bzQgRBqglj8GUYSmLe+iE6e+WXnJhRcA4unyixljSXD3rmaZf3GI4GSGhLnauJbwWpmmyTfH56J23rnJLQnQJuygaMtreDQrfk2u9C8rSxY7pFNQCDahkMolicUsfgegN0hZfVTokHypbB7Teb49e1iaDAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmYnNic1ZXYYFnE1GLFE6s5PJat7SkDRuYigxycHdvoeSb", + "privKey": "CAASpwkwggSjAgEAAoIBAQDqtF5hmd8vOpqbbwV21tg14xX++zqKXLH6GEsERFfmdzIvwEqXuaYwubrGbTONETICm5KDzaY/lQClV+R8Um6AmR1dL9j9lOyzeZE4f66l+LVu6n0jxE0T6Ik6nsHtIzOqO1aKpLNO+219KBswnBWc9lv7HD2e/OKlpOBDqX/YxpM1sz8J8A8TzNCrkufP6OSCdZ/s5XwPEh1o4tYXdJ9BSAfdKzUBgRtbs16Q7vWrVfxD01pmvvVnkIHVR+eL3d+3n19ZmMlGAm8HpP52fYTa7ABixDxdBelQN92/cdaIwePvAdGpqLv8fCEVCLwrQc4BQi2BePp5n5WYHTwEFW4hAgMBAAECggEAEeyWbKPArK2wEwDGjQ3ZUzw1eNSc4uYzXWMvj3Lct6gQuB7aU34FGCGHBxJd5n8Sr6pL5S72bFKnyvjMZUYyVDXdTTmTO8J81TQKiCMQJnK5AHB+ABZEwKl4mXZ4XvDaSDzh3hK38uc2tGE0umChMeyKl8HPXu33LSlLSz+NmPNj5wAallohy0JLSvM9hImvxE7kFTtSZCQUctz56WTnQdS7VAejmSPAqUheLlgq+eDbqzqJbMJOj+iXrT3DUxx54CIMlyd3vZg/LGI6PQxLNdrRBG5Tn+z0cn3T+407pClLdr6+ShJGBgzw1Su9NelWIJaXlsGquVXipj2fzAH58QKBgQD4yXq/k89BENdGI94h4ewICRXdc2ElgGK2xURUDKncb9HC7foNv/XR9ma87gwYq+uM/pgF6DCNi2VzVy9UHsollAOjdsn5y7C2y9HobWgArtv4YUe7oOdzI1UrP2htvFNNxjdDcYhGmeXlDOZcxW5AzQGJu/dclwIbH1vY0g3k7QKBgQDxgl4qHzB//VQJNpuimN2X/G9XDknKvm8guLjPXDr/2jWBthyPM6ow16qroAEGUtkXwBSt4y4GW/sz1vhf0sVrPIWMqkkPxMrnNQ1qQ3gECWHgQCBHVTqgJU0qOF2+c+WG3SGpB91YrIzHJqQRDjtHixEC1uJDdDRrYFfqqAqbhQKBgAzbhM9/2Rc4wpdqZSGFJoinx4yBWQTyJKfjfAuH+ANfeAzF9cVeJVsri9W5y8A+qlbIFZ1AibnW+XBDkjubt8DHbIS3L+sL/t8Dm56SgOyAHPgyNt3Yi/2kVtN8XG5HbFq5osOGi49yhrIWv5UN0wvgTHMM1tTfLQmvzjRfbr5lAoGAVvyC2B8Vw/PFse/WTNFMdzK4E54U3A6NTjbace2hXogE36xtSvLr6N21Hk3qMJHkmZZYnG0IJcg5iWlzWmg7LS3GWGz5FdHm1zIXm9+jOaj7dN8EAU1kaUwmJ//XXAK4eEPrnMs1YXv81LpJO89pcJJZVTF6m5seSlKQN/fAolUCgYEAw3j6b3Lgi1Z8jioss9xDmMPvf913W97N9lt877SXWSJwvcDik6cuRS6FCs2NBgUUcbQ2Sct/WqVbDNBCDU0PjpOFmlHjWUl9CZ0M4A5uiPyzoJbICE6Rz7AxAiQbGxRCjMe8l10rCkb5twQcxwnWFmWuCfp4C0IrXmD21Xlvwug=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDqtF5hmd8vOpqbbwV21tg14xX++zqKXLH6GEsERFfmdzIvwEqXuaYwubrGbTONETICm5KDzaY/lQClV+R8Um6AmR1dL9j9lOyzeZE4f66l+LVu6n0jxE0T6Ik6nsHtIzOqO1aKpLNO+219KBswnBWc9lv7HD2e/OKlpOBDqX/YxpM1sz8J8A8TzNCrkufP6OSCdZ/s5XwPEh1o4tYXdJ9BSAfdKzUBgRtbs16Q7vWrVfxD01pmvvVnkIHVR+eL3d+3n19ZmMlGAm8HpP52fYTa7ABixDxdBelQN92/cdaIwePvAdGpqLv8fCEVCLwrQc4BQi2BePp5n5WYHTwEFW4hAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmfQa5Q8TzoTugCs1GTfwB5ckb5MwEuqHdQu8LdBSmcqXk", + "privKey": "CAASqQkwggSlAgEAAoIBAQDx0kP+8QIqEa1V8vmxNxn/bx2r+I42wn8MZytziUKLzXPJIfIRejdcEO/U5jqDQNIr1ltIQkO/P+K8U4/ThlLfJ/pqkOYHNFtU1kGPVnMMDHkr2RvOG9MPUC61aCyhCYAUpUsHwSraBVxfQkDUTUOCMqwn0FUqpErM2v+naPGBYyn2owsN1SMLE/JxyZyB1VhoqyMpbfUZY0nYL+OqF7jveVM+30cfdfGHSkojgJCyb9Y8EXRCPRLCX2uQ8g5zgln8CyELd4p+wgSJ35YS2pUGlZ9Ev9UK+YZNCF97NIhtepFNLHmrYemVKrDokDP7fl2XEwmtjFdNq4SiorQdTHJBAgMBAAECggEAf/a8dJQkiQ6BoxHIf7ag00KBeRc2alPR10Zg/+qKhGBb/PsxlX4O/XEY+Jg8LmiGzxvHgh1OrE2qNe4iFdTm1Z/aK7oxf259Rg968dbVWnLfTAy/YfnnXhsYHHbb5vuYA1TUt23It0ZO8zmkBLQ+HQ+jeg4Mg1wdGPpqfrRR2B0SKbR/aG6c9EDhYXIDNnkX1Wfd4y+GqlHN0YrURbFVIzJUu93yrhP7DaM9CYBlmdjul/5NdfX+zU9XjqHJVw7/zxkJjWwfm8UgNVgjsFJlHhfcTKsacRUAiYuwljo84OOZUhshWV321LIby4BKMNFPEr6uqh14ZzTFPiczx8yoAQKBgQD6xYh4fpelVf21JMnjtWuiEkFLbTSKqFMPp6djCIfiBuJOFF3paJCHtnCGsK++/aEQ3mlxlJ6kYaPRcQUAle1RJtd8C+xhRqB3mjjwO0Cl1vTJgYMNMW1E0mTzhMVT1gRdt0+3Uii7k4Z/MWRacm/zFuE5GF9mxG51jabjULX/0QKBgQD23PYgucYaTEgZQrLMhN3TSQKmlGG8dE7S4QqdchmXkaqCMnU2LW2GYthirsZQa4hByUamG9j6T9tldpuPP0Fc8KfbwLohiwIatQHwIQUT2uhkG+HX/+/tZYZZ79vIf9Yl9fhAwBnSChRGhS5n90jhZ/CbyEk1PZxmDBe75r7XcQKBgQDzwQRZU3vmC0L0S9EuVM9Nl37+aSU0Tk+GnQlYexdR/i0FhkiOs8QhFpYkZiQ+etyPwBEwhSz7Tall0Pzyx8kJI787ZX+cQoGCIFeOM5owWVRRdmFDdrLmvbfA+WKxjgtqaN/EqsjLI6gNhJ4uSKRG3wuHawh4pSFVhJ4ewPpXsQKBgQDx0cVwjUqXnD3MMOABI+4/+HcWQqfy+WP1gujpDkovhUunulHDPoDZcZ5SHK67PHr/JnGEaicEHJHoNGVxzx7yMfPcelBaZ1cqXkGFvnLA3mFjH0T+WAHpZNhU5XdAUqmuCeKjWwpwC9uMsQ2iXkQQOccicvHzq2S3OgVN1V0AoQKBgQDBGXOTN/at01B5ooKS3/O/3zBoERfgnmAsPhnkYCl+yn6eSY6tU31do+oUXxXLVTt79goSSC9sQDzA9TSBBo1NTGzFElP1zSBEwhgU+l+KTdjKH0qHI9/8ks1G4SoSNFxAj+MrRVsy9glqdmJIgKmPqdwlnq/7hB9l/FUC65LsfQ==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDx0kP+8QIqEa1V8vmxNxn/bx2r+I42wn8MZytziUKLzXPJIfIRejdcEO/U5jqDQNIr1ltIQkO/P+K8U4/ThlLfJ/pqkOYHNFtU1kGPVnMMDHkr2RvOG9MPUC61aCyhCYAUpUsHwSraBVxfQkDUTUOCMqwn0FUqpErM2v+naPGBYyn2owsN1SMLE/JxyZyB1VhoqyMpbfUZY0nYL+OqF7jveVM+30cfdfGHSkojgJCyb9Y8EXRCPRLCX2uQ8g5zgln8CyELd4p+wgSJ35YS2pUGlZ9Ev9UK+YZNCF97NIhtepFNLHmrYemVKrDokDP7fl2XEwmtjFdNq4SiorQdTHJBAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmNcR5oXnGP4VSX5AjaRcPepFMz27ZGupEJXyq2BMpRp5g", + "privKey": "CAASpwkwggSjAgEAAoIBAQDQ+zxtRDJm934HN6L/8q8EFnXghF2cvpECCpBc+/+yR4l81QkKblB3/LWDeAcx4YSDipJZ8D7Wb18R4R3BfcJ2AoMnvoavX64tnTfFOYiUMri4txnDDCVfYzo2CC5QGTqwzwAdC4olqHpb7oVTIAzuQHOQSdH7nEsmy19SmXo2kQlZdU4b5G1x42qyFIRY2F5i+d9fx9WtwuYmCOL/QaPSZOF8j1uxuPzeHzc8zyVHXqJfvbhh7MOowCuawecp2N7OvYUsNJdtej5U0xgEdyICTivIPNOIvRKoozvMcmA0RZto6X+RFQX4c1Avc7cvA0CwKW2fLvsW+SB4FP5cur9dAgMBAAECggEABtl1LY+ip0VNWCc2rHTjz5p82pL8DnsgfZSjDqkjxFAb7X9+AF2FPamGuXxhn/zoPvd3vILnTFfyIb/jHchla0DB07em6nCUYOJaRZiRJWpUK5m0unPXdbzm14aFHhL1nX3rXwhVys4u1HyI2iSex+BM6VnCDCEfRXI8+ZQWMVuYaEyCTuhvl01jJ2LuPsDdQGffMXuiubwZSmvjwOlauUvXVCy6l5riwj/UyoEyIDp0bWY3LbaewblqHGvVGKBBX3pdNE4fadFtgeJBETMCr17EwKRWrNEo28w9Tm8A11s5GntOcGnpk6h/OIdBDPqXqBoQ3CnkJOsI+TmL5nTa8QKBgQDzbFZr1YKAEvKM41xJ6lqAKh7jXw+1SK2LgvatFMDnvsirsRJs/s2D/PQaTnQu+fG82LQbIj8a0wGLd/UKTle6jldssA0YU6KooW08/+1RaaaViSXik91pYel4gxyaN55ie3zlJ9lDiRTximQ+RTHr+w1qk38jcn93YOlYcZTNCwKBgQDbx1mvz9QK9Xf2gT3+KfMkJiEcQit38s9kWQnY3BGzqAq8Oo631gVpAy8KiYey6jKohj7wNPnhDBISVJ/eta6rMiDjujVa4IkBhakyzMCm1nSQHordv/oocnQHna2TplvYbSMUAjgvatS7AbnzZzz+k4iXCmfSEE/1z9aoTUNWNwKBgCcqymkFbL8QzWgv+RyHkdJHdLrfA9cGf64P/4Lv8O4Y+47sqetRwF25aMmG0Bjy7JuXPruS8hZt1zTKs2naGzGQT67UUPcWFfkOKFaFU3kjB8PN0oO3iQu4zmkup36E7n4oInt4wvOj7fPDcce3OIYg2hLI8s8QUEQ0Gre5ZtjrAoGAZhqsWRiVq221COmsUltM4VtxgH5hUX2VyknvYDeFZdDJA/+0dEXTB6F6Bkw0pfNWC6MqtE/4UwxXjPqRt1byyggk7YeB6DFulS1ymO41Bo2VY6s82p6o6oeZzjv7+x+LhfXWGSKa1bStFiBMMn+g/6itCXbFGvuHGm0vjcsvYGsCgYEAvDl+6IL0r1HNoyXZZgJGM8GVW1PpIJlHVE5X1X/LDtfiNNAhxXUt05+8uuryeAWpA5hr/Bt7/ds2k9wJFUHAU7VRJkhZ3J64vtl7MJro+cSNEZ8H5O1Y+53SBuAQk9Z5wOwZjjHf30l+wYoTwoKJ15DIPOIKGYyhE0Bx4HOBBdU=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQ+zxtRDJm934HN6L/8q8EFnXghF2cvpECCpBc+/+yR4l81QkKblB3/LWDeAcx4YSDipJZ8D7Wb18R4R3BfcJ2AoMnvoavX64tnTfFOYiUMri4txnDDCVfYzo2CC5QGTqwzwAdC4olqHpb7oVTIAzuQHOQSdH7nEsmy19SmXo2kQlZdU4b5G1x42qyFIRY2F5i+d9fx9WtwuYmCOL/QaPSZOF8j1uxuPzeHzc8zyVHXqJfvbhh7MOowCuawecp2N7OvYUsNJdtej5U0xgEdyICTivIPNOIvRKoozvMcmA0RZto6X+RFQX4c1Avc7cvA0CwKW2fLvsW+SB4FP5cur9dAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmPpTw7SQru7aWTmsZMhBPmprCWqnqXdqFbra14bnCYWYg", + "privKey": "CAASpgkwggSiAgEAAoIBAQDSzlp3EXYtalGQfbDDu8eE0y4Wn+YyVB8uOk7CVmDonlwp3brJ0/fNaP3mDG/Y24YdvmgpCuzNaxvEIYz19Ji5MKUE9wY9D3gUoJN8jRIAfuKIUnxOLxd+Rva3gp7Yn/5Y9aOurFjlWWNs1jimmqfDTnA5wmEKvIDuoWjMjq4fg150SIUjtG/SKg25lUCL2n6WYK21HIsObVWLbh88Hy3lQCbBU/4CcYakF6TEzrcgSPZ9hz1oirrznu5jpO2NoqT3vSN5NtiUrGcEdyk4L0efwqYKDIEjGjXS9SWiJYc+ri2vxsOy6rmoFafugGcX8cnnPLmqGhzqXngDLkQG1DqBAgMBAAECggEAPAp+Ba+5gxHnDUpfUEBpgVFMrTD5tZf0EYyV5hAIJfkEsv/uNZHj4GNo/V7JdHCB8HLM4/OyoodBL0mHBn6WCRjrx1A8PKPtRaK+nxjm6bE6AC3OLc6H2HWJy5aue3CGVvwPlK6N2zTsdpFFLV6bLatnl2vfi9lIt67NVIXG3j5dxo2OlPqXKLkLnMEwjo5hGj86Z+Q0O3Z0fxe3CApr373sVxkHDgChagVoraguFubOPsEOHBnjO5THZmNUhlEFDRydX5aCTYerzo8vs1G7vd6I9MjKkPAwRlGJ+XtmwmXbaX9pFjwiHjkiVFUAXxw5dmhuzYcfN0kZSsvWDv94AQKBgQD4UbSG18nyOFS6/njfebrtwJSkhQIyk54O/1KAguQUqOx4CjYhuhGeQlu5yTLQoWUO8E/7K5zdjOsCYCHcmI1W8TRolyOo0o78ATvSrcwy1gkaYgk2duac9WiBV6FVDtxlcsX1pou4vt4S8LXDHVb2ToMcretZpdx9WJAQkP1GYQKBgQDZU5qWmwG4uJQ6bloa6NQ4sgY7gXpf8fRHUk+Y6W6cyRkeiBVo+3BmoY0kE5kbJUQAfbpOJ2ynQzV1T19CFqnKJHbd4WQM5Q9+Lsa7QUSCmAvLoaAPe8AoLYlYoFodpRKEvjZk6myMhcSP85/XPkPsAA25GdXFZspUlPzuU48oIQKBgFzJ4yRT9BE/vWGWf0I6cYAv6xtC3Fxbzr8Z5xFAV8vkh2AfqLSXm8fAUhgtN4DAHkwjvi9Dz7z10Ec19tFAa+gl/4hpmZiW/XjrWRhTey8vzXz/TyP78BaMmT1jqlRnVjHOXmx5jFI/eCopqjG7f+hP1CxeTMhV8vsfoc2e8BVhAoGAWkAt4n1cqal9ZQaOxL4L47+Kdwu+FjoUh8nW5FmMZe/dTqCUw5QniXdtdZ3t5ygCpXGQ/QPCS3PNr3nWxUtEF34tHteLBQ/a7zvdq8Xe/ZzGyTnFjqiFlCnU78kno0f5+MZFMINpsLGcf2tc5bYl3svm5wejjuaw/48fuplYygECgYBbaRw9VV4XUBu+/nlcjSNdrj2N6gHxilYwUX4hTAT4ZDVxxJXZZHlxp20jHd3L135M6VAEHjA5b1+tUbe90GxOdM6xi9iKn36VHtjd7K/p0NWzGd86Ny8sqOZN0Q3surcqXvT2nFyuO6q7jDtAN2b0BSo9K9PnSiN50lEVcmBX0A==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDSzlp3EXYtalGQfbDDu8eE0y4Wn+YyVB8uOk7CVmDonlwp3brJ0/fNaP3mDG/Y24YdvmgpCuzNaxvEIYz19Ji5MKUE9wY9D3gUoJN8jRIAfuKIUnxOLxd+Rva3gp7Yn/5Y9aOurFjlWWNs1jimmqfDTnA5wmEKvIDuoWjMjq4fg150SIUjtG/SKg25lUCL2n6WYK21HIsObVWLbh88Hy3lQCbBU/4CcYakF6TEzrcgSPZ9hz1oirrznu5jpO2NoqT3vSN5NtiUrGcEdyk4L0efwqYKDIEjGjXS9SWiJYc+ri2vxsOy6rmoFafugGcX8cnnPLmqGhzqXngDLkQG1DqBAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSPUjpXC8ogoXp3AouY35AiLYTJWBbXR8uCmQY6QqS1rV", + "privKey": "CAASqAkwggSkAgEAAoIBAQDLlhiibulDWV/h9BweAmYkNDnyeU9Q+cn6xI5xCrrmEraPCvaQWcNBPbIoldERlE93d/ynP59y8Kixqhh9bXFHzP/EwXavvbO0OMxABtJZOx+lhWGl82HIjrvz44TFNEmXZBUhv/3BXEm0yLOPznW6ccdVNicOZLQoi46mHpH7BYe3zjQuX2cEp4wRG5pKB5X3QKKBmWn1SlskzthP5v3So7aQh2MfhGtetU9sJ8vNliFHST77QIKCyF4f6secNuyojekiHu7CUX55q7o1IVdZnrrEXZX2aMormAfqPhKQFPJYyO6aeWyHwMtxiiYnUQbokFpA1TQ1C6tOvc6ZXNsjAgMBAAECggEAcilS2xMyvs+JUt1ePv29ZSPcMroP3iqUNoiuD3mi4I0xzfip1rxfH2CHXPbV6/OstCOWi/rDYOLO1gG6BeuvEEJGUoDiGx5XfQI0ltq8bckXr+uhnDtkY+CWSOcWdrchZUF8EBbnJtyngDbjagquPcS7sG7Ta+DQncPUVBbkaUvqSpp4M5rqwECtEA9kUZQIMp/pJB9ZQ/2Ob2cyoI5SmUvk0by0XP8Hb7GBtrf6S4+BbUaOkj9jDfAH6Y0pN1ubJ3tkd38FAFtorWsJAdkvrQliFUjfjk+ANmWR6iIEGJMXsabUmrmXDIhzpv+XMMNpyI0L37l0DlkJ9hUEwql0wQKBgQDusySod6rD02pmSX4gTzf2RNaAOghTwiW6W4YyXOokRQPyrbvXUqhnlYJGBpB8Iy74h6+nJtCBPOTOhFSDjL0isTcG5KV4MWzoRT2l0PhOA03KccTBAgxHQSc2ACJIJr1yiuj62/ToEtmc7e4Eb5HeYzgUqig5Z9LHjxXu+UZeswKBgQDaV3RnUqb+3tlir2mB8Srr7ZjLMMjYw657YtvFCHpljuqUPbt+6k1K6uTsnJ/fTrfRg9Fn168YA8Kc5tqcW5ECjN4Q5/MdGWVBVuLByE1OAZ3Hm9g6++tIWLMpb+z2tgduKUA/hfdm64X6HqoBsxporYhj0Mpn0hrO8L7FlrXJ0QKBgQCDWHQNd3uxsb3UdxA9+xlSG+LkQAqg/C4Cc6ZORC5astdPTCYWf9dG2FAM9EPA6yNHgnI3SfZlhvpoYQyYLnNMibM7ycj7cEb7ME6R1YEsfEjr4tpfUh8rfkBzSHOUvCx2wNUeZLZIlUbFQW89ZZ8gffw38sGbhPPI94UcMHJ2XQKBgE06s9y8Gn96ObAzVYF12XW8A9iTN+ecR4IzNIMb/Zcglw66SzCYFaDTNwgOWmo1QMWl95LgcnlvEw5GhbralI8vXnjiYla/ndYfsnNSsy1NWw64rCIo608auLyGb23Qcw5fHu+ZJipMUoZnBEE3pbay8tRDjORuJ7dc5k2jgkeRAoGBAID3nD/tbyg617LB/tO1rnKlfkUGmLocoyzzX+reQHVRaabjAS5Ip5a/7g5gtLyFERlImbEzmCbZm03PomZgHLHMPE6Jlo1uTsggf8Ax/ldR3Q3ZficWwQ05gZGflezsUVayewoqDbrW+qxXI56v8l/dnoVs/5FjlY3aFZOFO2pV", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDLlhiibulDWV/h9BweAmYkNDnyeU9Q+cn6xI5xCrrmEraPCvaQWcNBPbIoldERlE93d/ynP59y8Kixqhh9bXFHzP/EwXavvbO0OMxABtJZOx+lhWGl82HIjrvz44TFNEmXZBUhv/3BXEm0yLOPznW6ccdVNicOZLQoi46mHpH7BYe3zjQuX2cEp4wRG5pKB5X3QKKBmWn1SlskzthP5v3So7aQh2MfhGtetU9sJ8vNliFHST77QIKCyF4f6secNuyojekiHu7CUX55q7o1IVdZnrrEXZX2aMormAfqPhKQFPJYyO6aeWyHwMtxiiYnUQbokFpA1TQ1C6tOvc6ZXNsjAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmeQD4Y7ahTYxRrDERmgTD4QTUxEgXoMKcoM5TJ9LXDKfB", + "privKey": "CAASqQkwggSlAgEAAoIBAQCrq+NH4sQ+lgXdZgQ8G/xD01fkuFuuHpaRX3a1QRsVP30KxhTNHNAuRq1+2RFSIfT42jGvEV29xFKAAZpY70P/6uPRurxn/uqCAroPJYV3FrCYS/b2N3lJOBrG6e/TzM2Gp0Aj5TbJwzA2k2vWHxjnyacVyzxSQtO5wPfiv+seP6RVSnBYQnJkeyjxDyhUG9D1n4q8TX8Bdjfgnubh73rg+jGwfmY7R6YQVCRNkwGnjesJHNvE0fgKt9HQYnDbgwQ4b1GeKPgYPpc+gOLOI5ctY/ScgXcHrI4N86o4uJsMBWo/kmTD1T5PJjGtdHRByzLrUElsJnKb+0rXiDS2WroXAgMBAAECggEBAKI4bjAauAjQKUCaSzwl0c6h4nduQqwZmXxLslf66sW8VcOdhECCjrJ79SxdoIF1NxEE1lgxV9yfrLnrSdfqWN53Lsqb47d96knqm7j+Ys0y8rMnbXoi14h57Mu0ef0xlbE9UF3bFle4C1I3InqWrikxo6Lzhs/Q+FOaZmOtqVbNjhdP88oIZANK/ceCYdba4mHENqxl8yupcuYplKdZJc7udOd97zGwebqlhsF9AJ0/OINUo5yeH4lBhjZmLyzvgUnNbWRqQbIrFHUJERb8LiYadNDuGURgKdSb9ARe9+/9L+mYTI1tNs7F0hACMnJxLRb/q3rxW2zPR3C2v2LB6+kCgYEA3NMofdiNfkeCav4OnpHpTV9G+uj3xEKtTvqdNVxrJEXbeRMYzZqVY9TP2v3UdSCDD1zjXays/+INljFFForSQFech9UIuuIDR4IVpmHiPwzmmYHf2A2tVZvjOFIe9sJMXS7nL193ojDuNvy6XCN5V4Vi0MYnM2XdaP+gKIa252sCgYEAxwRXiGjyEjRD8XMiwpe+o7IY+5DDG0he2f5jxI7ObEqVupQeAknQbvjDfXAv55bWlV8kQOWgcs5d4mpJoZ43adO1R9VFu15VkyhCJ3XYL1AlNj/543Rd9y6/Kxm1yYu42EHUrpluiWE2Rt46+INd+Ztj/yzYZoCM8F2GiBoW3wUCgYEAvZKxYkg0QEKXnc55MnxE811mDCVP/zbWncTcjWDHwh4OqkRQuMGKmmeqAXCDogHFQb0Wm+aPpiSkUVn+27lVglM0WA/1LKq28f6lI29I0aP7m7E5P7uOIL5xNHqbhm+LKzwG0E5+38ht2NriChOSKiaijGRwZtl+WJOLJP9xqf0CgYAGoQ9lXNGLZ7BHr6UdxD42Z61LW+QT2ZJHQqECIBuiIc3g/CQPwXOu7pxcZktCNJULPrMPclao3FTmQNIZDxMbdFDahrEe76J8F2A0vkkoMkw7BWCGgg7LOARoJCAZCY1rrq2t7zBuZQ2QyMBAHOgZc2KeUlkW+Ps42nSrveq7HQKBgQCwrPtKocpxsVTd+VuFtki3AtUvM2NfQBhtc5FT8WKVvO5PKBIPyG6hBmfGeOrxiK8lISO6MVDaU4FRZ7hc7bQUD7IpzGvNpZo8Vnsav11bgi3VO7ElKnHJN+MrqFYywasCDOnIVBGBBr0m+qnhr7pEgJeHuVnlcmynkZZJob5zWw==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrq+NH4sQ+lgXdZgQ8G/xD01fkuFuuHpaRX3a1QRsVP30KxhTNHNAuRq1+2RFSIfT42jGvEV29xFKAAZpY70P/6uPRurxn/uqCAroPJYV3FrCYS/b2N3lJOBrG6e/TzM2Gp0Aj5TbJwzA2k2vWHxjnyacVyzxSQtO5wPfiv+seP6RVSnBYQnJkeyjxDyhUG9D1n4q8TX8Bdjfgnubh73rg+jGwfmY7R6YQVCRNkwGnjesJHNvE0fgKt9HQYnDbgwQ4b1GeKPgYPpc+gOLOI5ctY/ScgXcHrI4N86o4uJsMBWo/kmTD1T5PJjGtdHRByzLrUElsJnKb+0rXiDS2WroXAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmRu9rXt1KoHES8dwvoN4Ca5PkHVEHsyFY3F7CwY1ZUTPA", + "privKey": "CAASqAkwggSkAgEAAoIBAQDfElzt5+t4UjWuHtDpwPvjIwQfrgn4+OvnKhBeK4yJuLlC3Crl5kS4cMkiwnbpsIGAF00BO0GQi7j0EY9g6bEsSnmKvpAovoekcVACQZzbsbe5zp1KYqbSawkzPrQO0OUR6UaIPEx4LZ6fpP8AJZLfOsJ1s+ETJ9qOQZa+IkrHgpHU629WdQoZt9tJ5jKLprWgp24CvBnErLnUPDXhkT60TrF5mSMukJJ/hsnbgzjs83J1AfhRp3wCE3X3606cUnT/0IpI+flLA7KvxBN8eVIA4zWFFr4hGZxtzNnxHImcwJ1l4Fj2vu20Ks8vozjBYOauVoUD02gVKBbsYdw82Ec7AgMBAAECggEAKBbiwJbHiK4tm4dKQFhAbIekfBUJEceajcbPfj0RWsbp9Iwg4YRKoWMTor2UJVdlTqHhYvFFTTbvHF3ziJU3FCCmSzsIKWpkcjczC9TC3fDIdgod1np4RKSb2KvSLD96i4eC94TusUJxmXtLoLkf9iJXRFP5hTnKW3qKHs2G5ufIQCp3QEgJaCJ+uGd2npZ+5x1pMZAF7HsShONyiDWT+63sF0TXrh4OJh1e5+SLCjlJY4luXDWYkelihWbWuWEe8lHAmBorBdRAPJG0ssl/rzSeEdQQHNY/WBYgXq1OhrrwffEKXBStrH1lIteYdAtPoTV6ilHB+S3Sj1LgWDaRgQKBgQD+q4X2PwGJ2PECog657PzWM1w8QQgbwnydl2N+iLrg+lOBdDE6QpJtOCmuTUAjlTbBONUhunsBSugHZtSUkSeJ2NBEuHf4qvqB9o78PGT+fILHMei8uJi7uJY6hNWbzfKR//RRdxZ/ZIJGK0eEZ5HO3K2s9tnS9jRg4OwWbo64mwKBgQDgPJhNmr+rMtMhRqMF5iYfpFIvvF+KGq8RJ0kk/PACf0wtxzjlryOnuy45Tkjuga3rr3xOJKwi6j+5MGxntH12cfkfZnR1Y1KnmTbNVs91R1ZGR08s0Omjfl1YauSdeQxmDyoOQXjV65vOb1L7bvwBa5DafUwVeFUikQ7tg7cF4QKBgQDFy8iHIhZ6zwEZj26qn1McttVbgxLeJKcO6yb+fwnOdP5onCsj2dLKe4V7+EnpmRnm5tI6mRCyR1CBdy+CmF7CJKBVz4R2oa1hRXN2mx3BvkkAl1XxRdpyaoJbvxH9Ke7N0KMcpsbVeOXpw/GO97X6mdFWdn9l54109RzIq2O0IwKBgCRvlCvf/k76JjZc/PZjbERt9fDNwhR1u4alBIyfEPzG5ID3wzYHHFsP3jXvk4g1yCXo0OD9sn7F427bAHJlcJGDeYBxrHC6n96d1brN5U3gNpOa2LGmjKBFUzOfwuAXoD0hL6s7VkAkVZ/YlPpIEWjFqrbl7yv57pN8UJmlcmLhAoGBAJXAhN56TY7mc/w6fKm8tD46zao2iynMREOUO3Wpa9wWtRWyAQwg44SW9mpuBuFVtuZ7KgumKX8BWcHsz5lu78KD+zZ7ko8UhtEDXbk22KVxsWYEgUNmaTkTA3ziDWq8Y2QJ0gW1HJ3G1PTu/0FH3b43LxxBnmSaR/wQmnKEvvoo", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDfElzt5+t4UjWuHtDpwPvjIwQfrgn4+OvnKhBeK4yJuLlC3Crl5kS4cMkiwnbpsIGAF00BO0GQi7j0EY9g6bEsSnmKvpAovoekcVACQZzbsbe5zp1KYqbSawkzPrQO0OUR6UaIPEx4LZ6fpP8AJZLfOsJ1s+ETJ9qOQZa+IkrHgpHU629WdQoZt9tJ5jKLprWgp24CvBnErLnUPDXhkT60TrF5mSMukJJ/hsnbgzjs83J1AfhRp3wCE3X3606cUnT/0IpI+flLA7KvxBN8eVIA4zWFFr4hGZxtzNnxHImcwJ1l4Fj2vu20Ks8vozjBYOauVoUD02gVKBbsYdw82Ec7AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmYqz4o7nrf6tNUo7ymPzLUPM5SpF7QvXK71kGNnLYw8Ra", + "privKey": "CAASpwkwggSjAgEAAoIBAQCgNnacFOUn73TenCv+AqNqSUFVf6rTHKOXq1JdxpiOvnCTVs/jGzFwZv7ytKMtfJf2o479TQL5anFnjOos6m2hxFcmF/W9XdcUEK7UiAD0n45RaGTOisE1ifZ4hUcdl5W1kmKHmbwvwcRRxXuoBvGYXq2ZJe0fWqaAxHHSzyVved4Sg80NzwX5mIwRK6Hg9GYCxj6vpRd5GAaEgxIk6aRnhV4zWOIYPnGu7ifUFz2mEyzB0a4ihZ2P/cLxr85Jr+GmJ4bwb5nxNtx5EOHVpAo/JFUenqc9bTowTvfWbOC5zsW/1FtmL8cFHUdVjVGDLfn8go8ZJ6tbMoTsbvDqNUNVAgMBAAECggEAO5Kk3frDDutySIhHr2bpvs7IdXNIYMGobvAsa2Q6O/HCSHciS+9Dnekeab8TYgmPNA2zUKq/LWEQFBIIzXTKGTm5shd8r9Jh9DsT10FPIabms4ye11Iu76qCNGRSgkVoTKDG9GcM27EwP7uv9FXIpgCmimjY2CzL9tuU+289G0rdzCDhYXpyTIPj8ZBu4sBp6pPBcLsjMuzzdyJ1OjczrSvIPh7hW3LQLS3i6Da4bq1yImqwyqN7tK94W4vRAxRBFjls6sdMDFZfOJST6l+qvHwcv6ZjwFQS+eJOPLcfqAxypBxOqw+Kmv90xJDJiJkq+jgsTnrJkYCW7KeMRaCgbQKBgQDO8ar/BlXMDoAzdGysm+cIFeZyNKQY4QLsJlH+VmpDXxdZnnkIJeQ6dfnbyatCaqHaqCKkx/2W06ZZOXiDjL6a2L1ZElfXszylYfhapvGDKIVqOIg1a1KJCRCE/MVzpGqmmj2td1O7PInGKTvA9zwTkLnWanNm41m+9q1gPFIeSwKBgQDGMOxUGkeSHAauoloKd5mPxbbm6rWm/a/Jh6gF/DuEU4lpNh3eZb07DpNq6g8xb0Fd3hcA+kJfoOZwrIA73SYCvAirO966ZgolSNRNakQV/QLEPgkL3FaOwocyDeG/LfN3uxvjFdIqCFzhWPhdRwjGNUrSeeownEGGsgZCVHqg3wKBgQCSE6sFi75CZTX/nD4d9Yq2fWcG1LvEyAhdE4urQeqOlfAQlbmPk9evoJl3mLpoDocjpq2VrYoGzm3M67FzAoWFHltCJZ2WJ/I2N5qsus0eLRtH6JHVS2WeT6S2iwsB31xdL+E7slCLiWcjVvXT93ETyoQzoz7EsNUn5E5r8QhyUwKBgHpYrzuH8ZC/3lwl+yGlDVYUvsE0OSk6SC9HoDD5saARla0ubCfjdHqll9mTXgetX5PbyyWeWCUChd8ejhbmgVWE0HEsh2VYIoE7wVt880UDqJaOmTUKMyDz81OyAB7t9fN+vUtlKBUsjnHKY5/pfwAk2+isvCZ//29wLK77yavPAoGAYR3tpLA7LB91/YWuS8D3xrda7cvLm3nVsik4tgWl0VgrewyGJjKWCvsV/SupVBIn62PlJzMSLDUzQDcWw/9mZ9isAKUBZPAI7lYzuuw3D6j3/05I9vKvHRUtAH9mNuYNu0lfqwyCuMoV1LD1wTfgaHSF1N8y4EoqQrcUBM1qrXI=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCgNnacFOUn73TenCv+AqNqSUFVf6rTHKOXq1JdxpiOvnCTVs/jGzFwZv7ytKMtfJf2o479TQL5anFnjOos6m2hxFcmF/W9XdcUEK7UiAD0n45RaGTOisE1ifZ4hUcdl5W1kmKHmbwvwcRRxXuoBvGYXq2ZJe0fWqaAxHHSzyVved4Sg80NzwX5mIwRK6Hg9GYCxj6vpRd5GAaEgxIk6aRnhV4zWOIYPnGu7ifUFz2mEyzB0a4ihZ2P/cLxr85Jr+GmJ4bwb5nxNtx5EOHVpAo/JFUenqc9bTowTvfWbOC5zsW/1FtmL8cFHUdVjVGDLfn8go8ZJ6tbMoTsbvDqNUNVAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "Qmf4BuSEF3q31HTpBuse7aPwpaYzJ2e7FHiGSHsmhA3uZz", + "privKey": "CAASpwkwggSjAgEAAoIBAQC40RyUzcdSIEiXOd5cb6Aw1rH2WhagwIX4p158NPDx57pDbjKVMgZXNJk6Mmnk4h0WFVxugFJtG9l730y5ErUa4kNFOMzG85urHM9pvWZAtqwggI44uITxST8mYGXwOT3jIJaPqnVmSQ/8TlAbQ+4tTEH2TfJaQwZ6uhn3h3RIQGyUm2iYrEa2eFV5x0aUXln4Q5xJb0Agns62QXJ+m73QaJhp3/x9Ul5umMpDRwWgfMZWhiHi0Uo/FwcZpmvNSeEZlnAyYHMulNkpXMH6UYj0vzHxH03BRkBAVpZl8aD1asKtOI2H7XHirqCcRoSLmPOTKgrGktDqsHzl6izy+KTfAgMBAAECggEAV+aNE3DztenI3LQXQBuPMutJ5QNf88DddzATTjvXxRYTjvKgeDk8rslDf1xu5P9uGgy604uQqHgwbiv8T6HIJSssF4Y2TwGaLj4boA0GzwySvTqnae7IvAG8WUJL+X8gIiBju5y1DZr+UV/l1bHvW/gC/2R/OdLbCA/vPb1c3ueF7k21ACoDN6CE2u+IxX+FfFmtvwlzo0zYobgNYMIvWaeM7qjMRHH/p4KTrutKcgGhZhq/0hXymRaX+Uc/aKyZkVVOvKPzHOQ1cucpv1Hzocl6dAnBgEOC0tm5/ZG98t27xRSef3zeElarzkmwh4vNDDNh7g7HLkPY6LWeF77ZAQKBgQDndF/9iwKyDw+7zPs9QH1PReW6joZaUY7UFFsHpatUYSVMt0TDOo2WrGcr+l3B82oYqQ88SOlH/JPURPQbsv3KB0r9OtfcF7RTxwFg83KGl3SyZzaTxchFIPF1hjp/KpcVQBdGJmFOybBg4ZomCkTr27ctOtP/uFoR+nx8m1SNwQKBgQDMapiG2Oj5UNQ8emHcYKPDuIiKF1y2VNUK/PXht1GN++D/VMykXWjXxytEnn/UrLHNbmuH2dJrXJIjNfH1TNcRpsM6LrgtsWLTex9WIeT7Afgvbs3sR19FkAHssbEXVx/W/nK0y0mADyXZ2NG7UZMzKdpELjF1+WV8tFj8RM8anwKBgFLpsH1OL/ADTzqSaqn9kSY1vt7+sYhnUQgOJrHtmhuHFWqO+HYLYq9IIUlyzeVtwmMFJO0OnWrpQze2X9AQZbPauvVOAAfbAgFE9+x4KV2noelK6hUzs9N3wqe8JvZpFmhJZkz98Lvdqm56QtM/uILZWZw9R7aCntlz5uZoanjBAoGAbcrTIZpfh4lidRlGdpdxXi4/J+xkX4ow4zX62sEbjKc8sedaAu4o4byYAMMg5Znb5froxo639fJCi6btzlL3MQPg199ADUq5Sd1Xd2u9ERR9uPxKnh23jiVK41aNR3wEHfWMpo6Ja763Fcre2z11UoWoNfaZmkPZvqEfKl/K3QECgYEAzNCm3YWypjjJ6ny/VHCWmjLZbgJN6kNbhfj/djr2As016K0DJqII0E66QWT1BjnMe4uBkabNvBCTybb4o1n5C2vRgvYtVJ/TJsmPKLxrEvARiYD0N1+v24P1G3BTpnVAqVIihMuTdHQIkBmqlGHOUmOfZ8CJb+lda4wMoAIxJSw=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC40RyUzcdSIEiXOd5cb6Aw1rH2WhagwIX4p158NPDx57pDbjKVMgZXNJk6Mmnk4h0WFVxugFJtG9l730y5ErUa4kNFOMzG85urHM9pvWZAtqwggI44uITxST8mYGXwOT3jIJaPqnVmSQ/8TlAbQ+4tTEH2TfJaQwZ6uhn3h3RIQGyUm2iYrEa2eFV5x0aUXln4Q5xJb0Agns62QXJ+m73QaJhp3/x9Ul5umMpDRwWgfMZWhiHi0Uo/FwcZpmvNSeEZlnAyYHMulNkpXMH6UYj0vzHxH03BRkBAVpZl8aD1asKtOI2H7XHirqCcRoSLmPOTKgrGktDqsHzl6izy+KTfAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmQnr4zPrD7UJRyLx8p3hkd4EXghTjwBHjnSVKwLtP3gFC", + "privKey": "CAASpgkwggSiAgEAAoIBAQDaDKzUGU5PCmN9cfxfi2K6LSf6Ro/LEJmBI4+aAZWRW5c8WJdqNIME7kQ0vLwr4ZjxVizntHjKr8so1CEVlet5YxQg2ezhsvnniTIYgoAo/tuLt8rZqEL6Kg0I9SYFN/zWHbfsJbGqFA20HoUSjPnO6MiSYrXHLzlJwXX/P0twRJGW1a0YjI+A01kI0XrTYfXNBgSPqd1gd/nWqDDMuulF+Y8dcXPRoUHEAQI4q7nMUyTSFX7Qhv9U7fKIQ1cGCEOKjWyB5jt8xK+cfKWJ9Mb1eLvPu/ZBnfjqW2g8LnE1TbZ1LvFmnbQZgPWZ12AfAsFprswMcIHNxoCnz3yxmUoHAgMBAAECggEABS4p6PwU7THM/Uz49vgjx1KNUZfdkLB7RSMoJTuGZyaq6CceqcpHlpVmj24wdkZs0McAWBzkhcQ5amXnx1CBgKfG8aTbyNzsrQCIbSakjtTHOIGMUzF5LeJT3vOcDKGw4xFfrj+TAfxp+u6CsNcilDTZlwi7UtkfXk43VHIXg7pCE/CxBstrlu48/Rsxvymzk7QHAkUneG0oVWJnkcPQNlnntC8XpQMqapxcDdIWjhXctouPn2hdVDC2KpyC2MrQKvbDb7bCVi6qntnryEe+DmX45TaR6TPfvnh1oc0ov02Tf64TJPieql+tjerlG23YoGWJH0wdezY+R/jIc5r1WQKBgQDzneebNpmQqduM0/4HI2LuI17J2OebKt7voQDm7q9ER7hsIPTUxXt9dx1RyxVZpXxNKFWJ3ITUtx/cLC4fxXb7CHxzWNx6nhAsnjwJeHbGiNw3x0c6fY0Tn6CV83WS2+XngItH4frT78nhnYFbnD4HByUXCfmlV6fR0UpTfkNUswKBgQDlIhKTh3IHKtmO0k8edbfhH0cXergbebp01Agjh6mnmMnsjI0XYn+iI1QK1ClN32mzlqHXMtGKtc2zKX6yhDMT7kPglVugKQWaQWkd7RHCQDaxN7tpwiDaYjVL6TqrTa24Dy5Lyrem8j/i5Bey5+TH08u31QuyUQGqCNJePnLnXQKBgB1cy9yGUS4BewfXSUfc+QCQ3MzhStEF8sbZFf2/iPpm1pCZzEiU4NR3dd405wbeDkRSdzTdklj9FWb5IDoOF9Ab7rwMWs6gnHx0OfI+RbqaJkjGyQwAs+9Ijxdjt6kSvfwQHzlzwEKpJSD/VecPxt4b+1lyh1dpYD3GxvmXP1BHAoGAWCd5uiS8LCHCPf6PzgpASm58LX5bYsa8g8Int3O0Q/S2izmv9rVAoaKx7NCfa4Ru6FclwOOeVp2HnEx0oD3YYOykVL1h2QavTx+nT4or8O4/nILyqce0WBC8rI34sntaQJwmlaZSbfp5tdNHgt9Q18iWcg2XSG1+FGr8dKHWF0kCgYAM6YV4r4GzAI+TgqI63fiRH3WhtE+RYhW9geUcGpI3PcGATee/R5xGZ9pYtNRHrm4DQ5EqTBiIZNKmBLmpanilhmoeju0+19fojk5tqlft/YrMOxfSNZkLNbm2Yww4vNHTCDvw8XpDlAjS4yyxRSDkucuCdsP6yJF9IyTqQsbrWA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDKzUGU5PCmN9cfxfi2K6LSf6Ro/LEJmBI4+aAZWRW5c8WJdqNIME7kQ0vLwr4ZjxVizntHjKr8so1CEVlet5YxQg2ezhsvnniTIYgoAo/tuLt8rZqEL6Kg0I9SYFN/zWHbfsJbGqFA20HoUSjPnO6MiSYrXHLzlJwXX/P0twRJGW1a0YjI+A01kI0XrTYfXNBgSPqd1gd/nWqDDMuulF+Y8dcXPRoUHEAQI4q7nMUyTSFX7Qhv9U7fKIQ1cGCEOKjWyB5jt8xK+cfKWJ9Mb1eLvPu/ZBnfjqW2g8LnE1TbZ1LvFmnbQZgPWZ12AfAsFprswMcIHNxoCnz3yxmUoHAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbF4cqzgjRthALpoDKwj6W1gDLVQVorkrmHVgGdgWkPzJ", + "privKey": "CAASqQkwggSlAgEAAoIBAQCyGullIgkT2WDF2RH2SCfhwqyRU1EN1OtIAUSo1AxlcYgGAPBVWDhO9Scce+nnGvlJY5OAUd7j1/QX/6/1/DPsRyKNjTqtUVrDZ+MUGYH8js/sSlDKeIcgjNXJ71EFPsqiGg0QS2PojpDkNf7jNDtCxEVTgGYC4wWb2r4cx/wcHVdO6uarCRGU9Pz29lNtNuqgLouLf+cLhi7G8kUisR42NWEP6qC/r4nb8GOttCcjrTS7tWgJUD/QBBlmYwJvmsVbJKQ4gtdYTrcn6yxoj0KrN05HMIw2cRfL5bgMaXO7Lm4IhnQDfYjrJVyfj/ZTJ9SICUG1SSgy0x9gwqK5HibNAgMBAAECggEAZ3RiZjBi/XijUclJObmoEOc3viKbTmGDWYwDCd5CZRqRXItnDuvzqUmVsmH3+Boe+5Yvs7XatpZWXypSV5xrvK+FTpvenZZIFoFd0esPKlj6RdLVIwbn1ux3spikg1t58LcZJ4HjQs6tMyJ6MBfC5IGFk39dwgeE1oc1LxqrQth/KzSYEYZgGU0bcgpNdAu3hHH1PBHsMkJ+3/mDhpOQbj3QWIm9wqRTbWWGehw3TnggwYVPC+xLQauFqbw5LkisVfZBlfN0D+fsbeivtBJzq+MZeZWi7BqTvAbPq4gJonxe13CApp6sXyUAup+Z7VOuDRs6wGt/OqUl+W/pmrqBMQKBgQDp1l5LmR+bj+F30FqnwWGB8znsPhf2CZgWy15IwavuzKwCCT8Z7uTISldE79kQWdYUF8gAuLbSNycUmM+b3XIYPo/8jXqWPooQeJ/M7umrJ3H8PINbNO7Q2XcxBjOFkZAj2P8drSqpL6Amqsay30+sd9ETaKf1WtN2JrWYFuQ81wKBgQDC/E2jt58nh7DZRTwMFtS2YutAAvtESU1xnwrGtuODmD7Xyazo8QDWKXb8XepAKxW6K4oWeW/SDXPtjbsxIdeVlYCQc+G/ekF8+oYp8MvDeq/mR13/JmCuW2b/aNNBj2Q7eRo7vWEVYl33M+qdZbYiFiDw3STmTQ/E/wxZPg2A+wKBgQCtrU50D9LuE7t+5f2vQ25Mun52/NeHIjEYHQx2NYKh5tqK2JtJg6nhKXYP+aTbBB6A5fjisE75a4VXQvhP5/XqE+2Vwu8d0G1zNmRaLcjYGoAKvFdD0tjdvedNPjHeLvND7NPvEsLwzjLBBW53RG1Ex+k95Sl6jm8o/i86OyZiGQKBgQCYlgTT96AOuTsF7A4/j6ZKTEK4xxyGpa57GfC+7ORCWOPkzigH6oGzFqPMfloQeSb5l5TqXYHKKUjtP5qbqlYg8uu3H1gsFaol+Y8ARzXN9batSHAgeZHzIAgMG6YmieXwPKbw1RSiPWY3S2NwZOYQ6qxAkW6M4wVSLh0lwU+j/QKBgQCIA0BuYWxcxPoeEiKc9JyFAPKt8ISCV0BVNYm5pYgw5vjEfNO9d1iZFZfB/ECdvRuuWxeiKgy8+l78XPjIqFyDZ7z1gI1XTz75HULbWUgjpv88BikhAY5/qjhri84Gzjfa4tZmEZKxu3K7ii07ZKp4o7k+6rosm4AZpOKi5WpBfA==", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCyGullIgkT2WDF2RH2SCfhwqyRU1EN1OtIAUSo1AxlcYgGAPBVWDhO9Scce+nnGvlJY5OAUd7j1/QX/6/1/DPsRyKNjTqtUVrDZ+MUGYH8js/sSlDKeIcgjNXJ71EFPsqiGg0QS2PojpDkNf7jNDtCxEVTgGYC4wWb2r4cx/wcHVdO6uarCRGU9Pz29lNtNuqgLouLf+cLhi7G8kUisR42NWEP6qC/r4nb8GOttCcjrTS7tWgJUD/QBBlmYwJvmsVbJKQ4gtdYTrcn6yxoj0KrN05HMIw2cRfL5bgMaXO7Lm4IhnQDfYjrJVyfj/ZTJ9SICUG1SSgy0x9gwqK5HibNAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmdycNxu2hJK68SQovw5Yju9FnuLB3NqY6mk15ATr4nkYa", + "privKey": "CAASpwkwggSjAgEAAoIBAQCp4KItjrRxtJU1AjHPhNvcH77MSh+XhLBMZaOOTfsmJ/9FtkUwMvWCVcfgUhi+CMyNqZRbTovcqr1U9hn1szLUjxhOPJ6DoFVZxZGARypXw3pTzZkLLYTJmOmNnQYG52Go74DmPS5E9x/iPxiD/xZTSsfAOKTgD+TmSRWxm4PXL4953NDtY8TUIdXSXnSgRpnJr99OugJDxwgW4HCSmcYYGo/j+xfjd8hwW2x3Zk663i5FlYpGDms+V39k0TDRFbCf3gcSZ1nOlR8CVMiQNeqZFgOGPfxOqKuOAfFg502ghaRXFQR9ZTO8HMOiN/b2m9alg0DGVZQ+yhktLuQ94JwPAgMBAAECggEAek1mlWQLV12KmppU4DGn1GfqhsvKyNxXzPjT8u0Dpune6AKc92GIzegSOdcBRzewhUEUtVPsb9dg7h0sfW8hZlULS7Bq8xrot/P8mB0kSAFNPa5kw95mnnl/lFv7bdcBwY2FAL4FZNOCWfHRJZ7uJNNO0n41fbcTthPiEXeESNQhWdVczNMycqod21CJLWuyBGv9LVTamWR4fFB2/ixjJNKVAVh0WTBk9LMURwgRaNRzwq+3NTZW4B+brZTLAAVav+xxIaJZWVv6irGwtXCvZTxpTL0vuTS41YH4oAhvWVvl/XG/CokEAh8T3CEzR23FN1A9Bgm31PwbSOeiWjbZuQKBgQDavlxkOb5/SioGpPpmMBdTTt5UO3oiCvVrV0yZuOpAX7+1fSBegksdfa7XOkixochmiIgbtuTRS5YEOmevE+YPEEHstzpQ//7lJOijzCaxLHTLVPYVrLxXktnGb9IWygna24BGkhAVvIt8dfwg8/3nsBoQ3omIVrDV5u5ycbQJIwKBgQDGz53Anqi4jEKPv60NBbj81LYR3RtAvPM4OlbaWLAeERaHR9xC4nWEgwvEDm0BWrQ77cGZATZ7QK6nstrKue8khkxbIKbibWJJWJ9F57yTZhvwq5sNayjJRbIsuKkubdvXaJp5ZDBz8L0XK693Rj4MGXp17ulZ8L9fwPcARt0uJQKBgGmKsb92EREPsqlUDrEhgQ+kHSfdLregO/vXulDtZLE8wZ4KyoRvL1kCXErih1KVscCvHaTpoQvPAYn2uDJEUptwB670VUHh0pWzMkBd70lLHutAih+5IYLLiyHwsBho0Up04DasoPAr8c1SjB1GPHr+gAUlqoxK77W1X9V+QRSrAoGBAIP47c8fgwB+mvCxXD54vgOXcAULsTuYMhvxHhZzKPXMghfrK9t6WGhOVVEgAlwTyfC+MvVOSMwoc8f+gh5wrr6gJ6+WTTGhSs1FdvUAj72I2qM4RwTxTXHOQihNrICVjInBdkl+qGtOMzdeWGvkxOtjPldq8Jwzo9X8UfptEAXBAoGAKaDO1B5bpFsiBlQKZmzeg/6vBa8D/F27YVP+bxoqeY9HlSBDtDxI540vyGwE1tJSql3gPvCZzKPxpXYPeXHweKp100YIYnRokLlXJpofA0dyJLKY3DPGAPTv4cOkgspw7Ckr6vsJL0/MK/kW0WfmSptAggdDwjgeM6mtcVlOsI0=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCp4KItjrRxtJU1AjHPhNvcH77MSh+XhLBMZaOOTfsmJ/9FtkUwMvWCVcfgUhi+CMyNqZRbTovcqr1U9hn1szLUjxhOPJ6DoFVZxZGARypXw3pTzZkLLYTJmOmNnQYG52Go74DmPS5E9x/iPxiD/xZTSsfAOKTgD+TmSRWxm4PXL4953NDtY8TUIdXSXnSgRpnJr99OugJDxwgW4HCSmcYYGo/j+xfjd8hwW2x3Zk663i5FlYpGDms+V39k0TDRFbCf3gcSZ1nOlR8CVMiQNeqZFgOGPfxOqKuOAfFg502ghaRXFQR9ZTO8HMOiN/b2m9alg0DGVZQ+yhktLuQ94JwPAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmSSEcBgyeaT8U6HykT9ErKHUKumaSYPBo7mdqTwcvq55U", + "privKey": "CAASpwkwggSjAgEAAoIBAQCv+kI/GSApNKExW7zcz7lmyTvX22eEiLhvwQv/LuGSknIqlmC8IqoQg+8l/MulZ3rKeD4uuS+VDDkNPcDDONHIjtlu1qKIYwec5SUiNhPTVpNiCeRkyG90XikwPEXak3OOyqPO17TtvK8n4/Pk63ehBix5c2GNoK0m4b7ThQzgUoOzwQ+AYRq4U41ma3pircE8JKYbywGmJFJdswvVjg9eGUgADfS9JhM941ZgQVvqCnX/yrxjZTMw5HVS+MBh0ZFHa6BK3rTF4yrQp7n2u5Tj2efs1Ci07DJ5hAuHZOn3JnX+UNLn0HMm/Bg/hvWOrc8zYzcZv9eVLfPCGVaUDUP1AgMBAAECggEAJrQ2Ccau6iEnKsHwgeg18MNlpA4fcGjZl8qvpspa1m/bKD62u+or2UILQSGecJyXxxw3IPOd4Xw0uBLS6J0AlsnETLpsOO7+56UGS8X1ClBKTg+66eeji8aB7Jf1DSPNEKTE7mNG6drL80wRglG/l+zRr0yPMiUasCiKXd8ve86Mu4iBLUdStBSHQAIMWBqTOP2oo10oW8Z54dGMQ9kSXcbtUFsD/5FJATQ1AlMPluHqyDf/fwqxAN2DSx2kZ8zIVFVcpK3250wWSY27Mplvq8VTdp4CjVpqWXxb710Oh969FPgYvNMHVHfuRfBuBiRsBlJKaVWtFWrNtWO9vngSAQKBgQDbE4OzCWppyqQ5DzUOWnI9COdjIHfqb1ynom2X2knr3Op7+YNpI0yUDygOr6OunKycU6uR3oWrJRvO6hdKWYYlFWu5BhSqHCSPCjJl/2OERRAkqmUxgu3dOM/WzJjcNLXB0aZ4LNxyS5x8ltSlpLR8PA1ZIliSFhaErHqTyqAywQKBgQDNoyp8po2Mmd5xNbF154BVJHuARdnu87ypV0otBW/ce6dxSDa1nKsht9I5C7nh1rwzN+srGrunhokHcSP3BOYmYG5bPn2/+bhmUo2KPIcXBzPFZEtaT2xYzn3DNZx1G/dY2ukgEZfS1KM6FcTj635P07zdcLTFWks0HbqNwA1CNQKBgHCU67ZDHXN2VsSX4w0YP+LLw5U2Z0mLpxLiru09mYVjRwEk7XpHUKA51b0OV9Bw5WeEvAO/VfPoowzHUea8cOp3wp8X1+C/i64ScGnoP60GjNA63Lv/69smyfA5vkhTsiADbEgPzc3Su31vSaJCLRo3BikLNHcGcNYHiQqQM5lBAoGBAJlNnS0Ulc5OH9FScBwwHDJdYlz8tj44I1wzoS7zMLO0093WMkMuqz4V5nl0zn0ZM3ETrRSTd3arC5kqtd9AHbxag6suaV0ndFuEC9UUzrlSOzxbSvnm4CVMu+E+JIgB82KgwM+Rjhg1QgLZm9E3DRHCDrkffwTqDcqqpxtqI/hJAoGAeS3nCY38KdaHbGTT7TmSe6HSt/kfb1NIygKTYEWNDc3kR9jubfk81/iwtAAvLfE4FY82TwC+78wyfpRa8Kt8m0GZLmyf0/8ACQd1RSig5P5ORKN9Er3nUXtvnr6tfkMELuPBWC9Rs0Vky8JIPJCfXEsQEOOGcuZDLsWF9Oe7Vwo=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCv+kI/GSApNKExW7zcz7lmyTvX22eEiLhvwQv/LuGSknIqlmC8IqoQg+8l/MulZ3rKeD4uuS+VDDkNPcDDONHIjtlu1qKIYwec5SUiNhPTVpNiCeRkyG90XikwPEXak3OOyqPO17TtvK8n4/Pk63ehBix5c2GNoK0m4b7ThQzgUoOzwQ+AYRq4U41ma3pircE8JKYbywGmJFJdswvVjg9eGUgADfS9JhM941ZgQVvqCnX/yrxjZTMw5HVS+MBh0ZFHa6BK3rTF4yrQp7n2u5Tj2efs1Ci07DJ5hAuHZOn3JnX+UNLn0HMm/Bg/hvWOrc8zYzcZv9eVLfPCGVaUDUP1AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmU8D5FgAjyxrSaobQT2FhMhx8Gxx117K8U8cPNYX3FRNX", + "privKey": "CAASqAkwggSkAgEAAoIBAQDIgr95M7CC0YOSJKhNn0g3V7GXwdBkd8HoGr+cFWKps4ghZeR+VYUjK5Fu93TuBEdeNac5KOAGfHLwN8uSdT4eN+F1zcb75/E+1RC2X2z47PaRMg8vXQ5AmTkXr6EX3E/IKxR/QaURuK1obTBiMAVzhJ4FVuYmk3VVpqKWO6U18I6pT2rfARtlEJYG6GHvqnSyyju/9TKL79VjD2wJrmNCS9l+yXSKAL46AsBHmyTzlLn1/cbRTFmG08Nm7PSokCpOV3ZTdVSPrJLpha39yMW/Ex5ICC6aSCB08lhCSUA4DoMOcYulOWO0q4rB33UokBzjAZAsZMlLhWSoBd99sSLvAgMBAAECggEAKrReH2w43cPNp+SSy+VutgrBUjb/MUaoT8zSnmWXm9kW1zYiUh3Yu0LeOKoPh1n18USwFuZzwC3lNPBNNSYvUrRIGpT3GlOt99ndM1pjlSiy4v2sakQBcxSvKjJHtxM/ErzKIshSZdHVbPZEZcUghBfsp+p4HiMtzE4vNpwBddkjQBxxAzLuua81W4fXdVcuqpH/1z1vCuzxgX8MpEjepGR0RIBPA1UsV8yb4I0w2xD3XO4nS++p0tZD0Z8SyBYcVRx0boUQAhghtLXhs4qv4VDkk1uvfU4A63NyFd4OQMwd3eGOnqxYQq+M9vRNIP+CenVfO7WiQEY1SOl5PtZCwQKBgQD4PCycyQ/5b82WnoAF6JOClgkAZ9wJXVx3Uz7QPQyoPoF33D1SowkMjEL44s8IsxSLDcU8Dnrqji9qjcbDgepK/6AN8vgzWwnitoX3+X56z5uGaY9EZphWk4VEnYQZwQZmQCrnLFaIxnqzLTxa+gW6VFvahvaKu8to4th6aVo0XwKBgQDOyGe1eqIyDMaXecXORNATt5M5x+FKMEzIy/sL6P7ZCKYqJ7DJP+qtlteqGcOccvDlxCKaM8eIrQDPHIRFyAexsKQ7UG577zHle2EE90LbYxKvOwPP4hRm2cDBc/suCtnrGjeYCHCTRcoj8TKsCkmdd97wNOmkPoFa+YtoFOYbcQKBgQDhNaa77+ZgRUDeP5qiwajitsAf8Bo/HMbBM3MvddO/6EWJuvSfvm59RduU9iEjIWWn6qxgmjqGBs2Z/FqyEXHA7T4GqcLoxNWpLDNLEL3hKe1N+wMR6YqYMWqdH9Mzkl398oV6Ck3P9VJosMerOl5r+BEFp6CRqWMYG4aPOHmwPQKBgGo9LoNf8UszoyiaCNXUJu+qZnrOReJ+9ERKAL56w8ywE+ceo0aSjzkGgeFEAWs05q212m1NYxvGft7p8M+FWOajMY3D4i/Mkd8sR4lsnC3pNeVPtcKtjfvVrqH1u7xJGPMgciWrWGNh/NwAhR883duIhcL1/IBFGOKryUL9UcgRAoGBAOG2J2RTW0NyhldTOciRpRuMTNTpr4LTGE9S//5S40i7YNv4ZFzUCabPXCyRRYyXUbhegeWmlNgfqRtNF+QyH98Y0ZezGJzQ1S0uQSnUeoqGcA1ohczWuOXESe1MgVS0Gsoo6Ytb4muYzlFZ97Y9gBM0KhaQ3GzMzkvNnX+3hqZv", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDIgr95M7CC0YOSJKhNn0g3V7GXwdBkd8HoGr+cFWKps4ghZeR+VYUjK5Fu93TuBEdeNac5KOAGfHLwN8uSdT4eN+F1zcb75/E+1RC2X2z47PaRMg8vXQ5AmTkXr6EX3E/IKxR/QaURuK1obTBiMAVzhJ4FVuYmk3VVpqKWO6U18I6pT2rfARtlEJYG6GHvqnSyyju/9TKL79VjD2wJrmNCS9l+yXSKAL46AsBHmyTzlLn1/cbRTFmG08Nm7PSokCpOV3ZTdVSPrJLpha39yMW/Ex5ICC6aSCB08lhCSUA4DoMOcYulOWO0q4rB33UokBzjAZAsZMlLhWSoBd99sSLvAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmbdrCRXAWsGxXTzaTkyL7o84PXkLQ8iyjWAJqXQrXoBBB", + "privKey": "CAASqAkwggSkAgEAAoIBAQCgS5u787XHG8wm+wPq1JFbNR+VBdQz2VTygxOZ5DMJn2ZWLbXEES94yzO4UaVA2/umXtTiiM97VPFBgYC3sV8rGg302qiNApY8z+OlGasXuoZBW6aWlFU9F9j/8jIEKEGtgqHIYNLDPjjFVa8308TCDC6otJmzCRuCJnDvYRkRaVlha1u3OSwxcKBVG4EGBpK1uOw4IpfP4zBkZAw4Ig5YzVA/QciJJ8TNRB2BwIv3f3NHWN1wV4v0MJIdj1JW5kLaU0WeQxxAgI6DJ9KG5h1Lxi3tqgudLAGF1mpU2VXBu6Mrnpqm/MPKHuoHrA259MSSIQZJ+75cDo9YpzTOvTQRAgMBAAECggEBAJSH2uObHQpFeLN6DxQvKg2AuSYGQ65TqQIacTQ9HwnAmTwrmOz4G6vrZp5ZkS37aUCtSMgsi0011WOkk1gjVBMFTn9fiaU4C2yIGeGnWkFfhf3T5hZLlnxIt7vaeXwerVUQ4cZh6YofAs3f6r9pTD2eujF7P5yFSOcdpbI6n9bf9plHJlVNwlOWvFrF0uO5lD4fPs1D6XWlKFuz2G6LOAvexZfbGmac3fpcrgY60rlXXOAueC35puyuha56RQtwKXHMC3/DcKExlRNXZhQByV9GrZ5WVWgSkouE1vbmFYNiLBaPWH4fFXgbkCvxlxiZKiVkx+vIRg70c8ZjAxFJDMECgYEA1TQr89ewSszz57am3oVaia+cB2vuy1QSDzxzyeGjbIpf+hbuxaZ7uHKngHV7QhJoC4OZ/+crfM8HvjSXObK6ZVWiNm+a59J81CGhV8XqzxO6WRNiGKSuNfxYjFv6BOqMi8lT/nIG5Mg+IjuZ6HVYcK5lLKS3vRlfR7uofE0hXVkCgYEAwHimE/oTXTLbWDCA/w207RJSyCvyroZ8+UXeSq7fKHkSFYAaPjq+NN520sR+E7g8uZqP4ZF6Pv/FAV3hVpuB5+wtk/2uPFO702rre7Rw3B2Hq0QM48njXfcTAiFfC94LRhKdcSnr7aOKnwAyl8EP6FSqXNLoMKnvV0iFDX/tHXkCgYBbwl6ATf4z003OFlBvSNmUlJ4Em7FklURIhm4XHyOk3VE9Y41UR7jLw5zPrsBjyWQ6QGORPb77smbUt/G2BXQvlNGBuDrlNzQ+YFL+YdITWZxEJhF8JbRMy9SYZCWQ5BmlN/sMcasB4CTNuvUclRSBOq2UrzfdDQRy7RMwnEmV0QKBgQC+CuLBOt0/2uVlkI7uR9RrePowF+TJmpVvdCNnTn+d8N2ASTqgU1RX04kz1zw9sF6VTR3gNcqkxdr53H6RC38bRsJCK+uMOYlt2VamkKYXUTkSTGEF0eQkdb9ZDSZSC27KQ7sdb606uY44LPPHj6NrXZ3RhZYp5sEiR8LIb5Xq0QKBgGU22UnE2iIgRKsWZ1BYQebnp2wmI7QZiU5ZmVWNfuM3kyjaA7IjLPK3zI/wi9NV8GnnpVWVOGoFeQIg4mAMfHSkCHEPG+8Ib0cAu2yHEv+i8yn1xwZqSuUx1aEjlczGCFIUCy4X30DIdwtpsVlUlAdE1p1br68firIz6W3OKyn+", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCgS5u787XHG8wm+wPq1JFbNR+VBdQz2VTygxOZ5DMJn2ZWLbXEES94yzO4UaVA2/umXtTiiM97VPFBgYC3sV8rGg302qiNApY8z+OlGasXuoZBW6aWlFU9F9j/8jIEKEGtgqHIYNLDPjjFVa8308TCDC6otJmzCRuCJnDvYRkRaVlha1u3OSwxcKBVG4EGBpK1uOw4IpfP4zBkZAw4Ig5YzVA/QciJJ8TNRB2BwIv3f3NHWN1wV4v0MJIdj1JW5kLaU0WeQxxAgI6DJ9KG5h1Lxi3tqgudLAGF1mpU2VXBu6Mrnpqm/MPKHuoHrA259MSSIQZJ+75cDo9YpzTOvTQRAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmWWYbfs1jFnZuKP6ky3Zf9A46W8R8tYA9eTqRdPobWFHh", + "privKey": "CAASpwkwggSjAgEAAoIBAQC7z4AoGK8K+kzoHhz5McSmP5IbsItENCi14CECnItsPXZlrUCywWMcXpIjh/FyMSq1P8d+EQryuYxnhdP3Kc5cYVshK7aaYsf+Pfy1sVzCfp59snGLKcKzetWLIDZsMYpnYp9yv2+ArxqGCYG7OikYgc2729ub4PkZpsBcQmsYy0lGyrCEId+dre0yGIHA4tYBzGuGfIGGfhLulyNbmDHdVkiAPyP6+VQvklvuzYim4KdDPIiklxbGIgQLM2WdrOHtS7PA9j5BzThzyjzUhe4JEsyS22oddbIzFai0rmYX06SDQcSY0PYWmpzOrCwmptNN/4XNK4OiR83Ttl6a7RtzAgMBAAECggEBALp71TL7H4P0+TxZ+kbtxeeVo8xexkoYyHufauee7Umy1ccr+twD7heTR+SD7ZiHfXKvO7TP02EkIGgCmHAJUOClwsjzEMPHZfHrNuxqikKNW25QKzIVa0CvrS4R9DgGEPmLEevsbhkGxX1mHyz7GSc+bDwmmK70+iMgUkzJnnHkZMsublJRd/Jc06VpogkI6SzR5pIHwc/t6B6U+WuZ+ohiJsEWiXrTEvD6RcNt/zHZAwmkatj/xkWcRRNhvS/Irb+ZkxgivXsk5XeNNK1BitK9Vnii+tVfoTTervKgMx18RN0hL9Fx4I01MwZNEnCpKxO+Xwg5oOwHY/TihgTesJECgYEA4y2YC8Eg0LIl+pnrNWUvja6RtJDSFIKGWOIAB1v+zBzszlDdFISLAeyZfZgwLzdOZZjTNuJp2V+pUsU/qTLqccIeI5u66cgRB2oI8O+g7XH472P7Ay/n0dFVj42fS6yZam8o+HRcK8av+f9F7YG0Fvs/ilrKg2Fcd4/IgenxXJ0CgYEA06NOqdNk2L3s3rgRkuBLoQ2gBmca0gKLcJOBfv2shiJ9y7dIBefSZxyMT6938U3NGvvzA8QB6/QZvz2BrgM9wS8bVIv25VtQ6tSatARXiTVfVVfAuEgErDEQWCdyqFerjDz4gu2yRUS6sg9rr7lJ1cXEGhsc2h5wzSQwGVMDc08CgYAIkorfPq1nUqGeQDqg7C2MMh8rah+TSI2bQwPvQyhtOVYyPtjo0kuQigYMuDZxQawCp26o7ohB/JseFXVehB5WppWOkGzQL4188yJdPR2ceCWFmwc4ypD72ONapGRzbZLockNghLuJp1iynVBdMvzBtT9jkCN+K6lalaFiTZqe/QKBgETOdFW8V64r2WXznCsPZyc+YceTH+IlV6ZLHq/l04BsmE9yECVzYDGL04ZYuvsl20gpn7GauTE4VGKboZysixhSs2UCeEvLK3ydkIp0Wu1N/+ekNxDywSombXTrplha4Hggnn8avnnMxZH8d3tTF1E8EeyW4gN8IBph6I1jMtz7AoGANXAUXM+PBA9xe7QUs4ZegR8reObEW7sUJ4rOmqSoTB5HIFHU6L37QJiAaHAF9S1Ncvgo7v+/GHRvA+O/FYy731kW/SJfHkkmPtfUl3u+gtdIdiyYswV1gxK/8PRB2dlbkrqITIBfHGqnSVVnIVqhy/wc7YIXu4H2mrpvrd389nM=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC7z4AoGK8K+kzoHhz5McSmP5IbsItENCi14CECnItsPXZlrUCywWMcXpIjh/FyMSq1P8d+EQryuYxnhdP3Kc5cYVshK7aaYsf+Pfy1sVzCfp59snGLKcKzetWLIDZsMYpnYp9yv2+ArxqGCYG7OikYgc2729ub4PkZpsBcQmsYy0lGyrCEId+dre0yGIHA4tYBzGuGfIGGfhLulyNbmDHdVkiAPyP6+VQvklvuzYim4KdDPIiklxbGIgQLM2WdrOHtS7PA9j5BzThzyjzUhe4JEsyS22oddbIzFai0rmYX06SDQcSY0PYWmpzOrCwmptNN/4XNK4OiR83Ttl6a7RtzAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmeQvuGyVN9VWyVmKZt1U6eiy578rF6kiU3W24nVXi7Z1d", + "privKey": "CAASqAkwggSkAgEAAoIBAQChA9xZ7KGxG0ti+VUNB1KH0Z8F37F6zlRqdwtrD/k5RRz91T+DEwifasCLgs8pdpl/I9CwlASXwPcbgVNj4GHlptxzdF6zeSuP3QDlhB/jyTpRa2lw2S2zYhBaTGsVeMlmGRV8LFpjhnCdW2kO0+oGEofF6Tcj3g9J+ul96aNi89FBHYYSERS+MCHRYvCuiHOHXtDI0yYfXR19rAcvzFOIHX0EoeNfKd1zwDv6p5kJnPR3n0DtGsNw8A0tW8w6l8fQd6Y97EmqPRzBQQ1Gag4zGfW/eBu59lNonghfjWJpBRH7TXlvy0w4WILbnEaUOFoeN1+fYQVMMfZTVA/+ePgbAgMBAAECggEAP8XMr50miYQa/q9sPUXKLVscFfJ8U/yGuMg/sH7aIhG6otqkViDiyGk6q8b6kByWPSINVPK7QvO9q5o0UhmcDJ5jMCNGIuV6GHfbFAyZqNmZjIfzcivCiwrrGSitPQrjEdobhVv3zPWBgwGiganzRcZvGjb9jOo1ugJ0GlfAS79PLIbzEflQj1P2sFULk47IXT+jwv+RqyUH8SN91wWblCamC7O+fIz/4jT5ff8iwtbkflGw2Gbf0iBY1CRqEHAx2zTFch8WeJb8KkVbkONy2jP0zCVPIpH16gw4FcKvQZZAMdZLI98DZ4MCH5J4JyJA0M7HyW5KXh5xNCaHjL8GIQKBgQDMTUam/4YhaUx17p3C8Q+zOO9TzmUzQQuoMvaG3Xs9Ekp5ygAbcHCNQUZ/thIHBS7kKDSRq62Tm1PXcnboAoQ98dSxpy1CSda4v3gAC4TF66+Tx94KFjLXZelgBIHXOzcqB7YuDXXHTmUz53V+8lVZ/rIhPVq5ZbZeWYWIUWEEkQKBgQDJwnTuY7yVQc9nZd/loTPLKibFqw2YgGGVG0GjIYhXWQiS31PL7wtnde+p9B69bBkEMnBiK20WBjsBgOP7asHJIiidb3BjuNUKQYqBatZBJt8OPmS/6SAZGY5DAlgntpoAhyX8HixNHeHQ5VUMHwmStVXWvHZvSGYy47oyUFTX6wKBgQC/IMArNTvHgBoe7ie7GwgkE+yaC6nTZFPCfELz8rn7bWQtQdQN14gELgAFNFDzLl8q5Y4ghWqyf4rVMOmardgHl3jy5kJKFIgDeGSMLjp9artsVnwcFZ5kspu8zxqlP2mhMWu287KuzWGSSEQ8iftdYRBGVn7MmSIebEOnPvKzcQKBgQCuOyolT6XkMv+7p+Mw9wO2N8Fhw/SqtHsQe4g0KtoFrFJWG1vO6bCseNEtsC33oGj+EdyxOhUrBthf1QGL9UZBvijaxAiHZW88Oxsz5aH+g2Xuc/0nKVfZtRMAVP7x1KOrPwqTbS8OrXZ7of/OxuLKeaQWG4wfT6NJ4RTDLFIIXwKBgFYydorZxccoBmtQzWhQA/I/Xgm/JO+k1DG7XzHLvOztwCwazRoBiVQ+ecIc1c/tsDQD3DuZZle+oFWYlfR3yrpBO9v2JaOeD8wMb5BBg067VAZ7CcYdbTccl3ncObaawWttJC4Njx5GElrUZa+aJwzL5LnGq2offNDw4BNGyUDo", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQChA9xZ7KGxG0ti+VUNB1KH0Z8F37F6zlRqdwtrD/k5RRz91T+DEwifasCLgs8pdpl/I9CwlASXwPcbgVNj4GHlptxzdF6zeSuP3QDlhB/jyTpRa2lw2S2zYhBaTGsVeMlmGRV8LFpjhnCdW2kO0+oGEofF6Tcj3g9J+ul96aNi89FBHYYSERS+MCHRYvCuiHOHXtDI0yYfXR19rAcvzFOIHX0EoeNfKd1zwDv6p5kJnPR3n0DtGsNw8A0tW8w6l8fQd6Y97EmqPRzBQQ1Gag4zGfW/eBu59lNonghfjWJpBRH7TXlvy0w4WILbnEaUOFoeN1+fYQVMMfZTVA/+ePgbAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmV7Hr7Yi74neZktqNghgrGYNV9X8zys1YTm31npSdVCrv", + "privKey": "CAASpwkwggSjAgEAAoIBAQDCF5axKAn+m/82xRDrewOR/LWE9THASE9CDihLm8FnCRAQw091KwzDOsMC3I/+lCHwxNNDLLFpgpSFJ1JEftdpMj4h7JnUn+Rx09PW9JUtii8PZmbpJD0w56eu1kachHrVMuZvYNA6ge+ukMMQpL3Za9udHk7a+CnCITG9N0F3WGk9p7GPpPlSazR/DgJiaqh4W11k+UAYejcs5Bj3QU1ndkGWhfd0bBxepK+otk9qXWSwaaOKxFCVrSBnv+hxTkaenWJy6oAE0GoQNQdsRxS2yHlgZEMLjmpD2hnUn4GfX6BLwn9/LY5fBaT56SIgu2JxThgro5mxkB4T79x//S+3AgMBAAECggEBAJgQhx3RMtNqQPAWQYVc4ZU1GrpKqGnvvTkRgnyKUWJ6dT3M56nyypMCrNrHF4HraRQMAUD1+SGjDt2rywajIf3nQUqu5m7xvrd3sNcO1PnS87/rCOHMZKy2MmgGtVfXa60xrdzBSyMrvi9Ud5/Ikn2PxYY5wqpIF99ixmdqrT3khjhzb4BRL6zW0xvKYOuuv7LULNC4261IlrBn6QUpaSKopCVGDiajZYpKYLJAgYyRXlvBEQnKACMRwt6uJ/kH6b6A8mlMV20OWrjHSce2F1MU02ZGSj8IblRK0FJvtVWhdOgOaM8WodtwIx7fgag45xTC4d6H3PnwRHJfG9GinnECgYEA8oT0TWcV6OdWmJOsqV4IdbcWatM1U2uQnZ2A5t+3MBsAZDS+725VgtSrWzAB8saVmDCOanMNq2Gtq5wdS9aVlR/SATQwRmVeGFG2ae7qtS2CpBwwIu2bD3bcR8AEVtR9uCJQyAeBQj+Hy75+wj/KR5mKquMTMXVkovAwn/27B70CgYEAzOGEHcU3+4SLnrVbXHoZfRrk9oiaZBWQELchk16D1LSQjf0fnJOjDGIO5L83qx7f9xzAdyGmYc9YbD9j1mTGnqgsSfhdRDxPcynExbhQOQAQNB7U7KCQlFzs4sbRWpHPrRpNAcxLZiDlyhSLEZLFnMOXUct2UGTeGYjmmmhHwoMCgYAIyeask2rI2PFbcCaWsLCvy2XFk0fgcQp5m8abF0plNOVLvFmbBa2Voy1ejZvUd3veWwweMXMyXcTUbkDlia48DD4pCwIg2vWQ/g0VQ7I/xJlyZw8bhO7UnaMX+o5tsx+nN58j0JnPk8vRB2NCmNs0wwyyaq48YZu3B+tLMP/BJQKBgALHeFxTBYxi4uX3PdMGUPwydjKl7bo31Kl1Yn42RQGIpYFXkqs0EX0kg2E0+tNWauFWQYIcMb6X6nIldfw9h7g1PcyPEuzPCKDeSy4Hbwcm6hFa7bZ8AxoQHKKC4eohmjiV57+Dfu5WuedA2hYV8JpMyOuyH9u9Uon0InSrv3VzAoGAT7iFhk5+t0Tcn4vmFjNKBTSBBdwGet3mHVbjVpit3IMT6dShxhpOxharIGypdWKLdptRwyIfNWoZ8P12DqujOsJ7mKn+uoAnD3Pcor6Ph5ZVbnVhaUU7nnxZ22gZZPbpZyWQQgbDHxq1DTGGpVW59q0CZ13+CE8QFKeRscOHW/E=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCF5axKAn+m/82xRDrewOR/LWE9THASE9CDihLm8FnCRAQw091KwzDOsMC3I/+lCHwxNNDLLFpgpSFJ1JEftdpMj4h7JnUn+Rx09PW9JUtii8PZmbpJD0w56eu1kachHrVMuZvYNA6ge+ukMMQpL3Za9udHk7a+CnCITG9N0F3WGk9p7GPpPlSazR/DgJiaqh4W11k+UAYejcs5Bj3QU1ndkGWhfd0bBxepK+otk9qXWSwaaOKxFCVrSBnv+hxTkaenWJy6oAE0GoQNQdsRxS2yHlgZEMLjmpD2hnUn4GfX6BLwn9/LY5fBaT56SIgu2JxThgro5mxkB4T79x//S+3AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmX3mkJEm2E5qnMS3zfSUGLLvJrTrWP3cB2x47CzV7x1H2", + "privKey": "CAASpwkwggSjAgEAAoIBAQDOd2RrB4TRtSdUarzog++Ma3tnWkq/kCiMGbZ175EnEkVImcCtKuVjoS+2qXDYoMR85yj1Q7tR/Me5iFINqK/ZZRBcmvokwWPLlNUCsE6Ig7YJCmUvuRaRGKYmJ6mJLVd98yhqeU7Pu7A0kXp07orpVmje+KbA7WCeZqsOQXHgTweqirqoBMZf6kV5p/Ya3mngpqmzCPhZTQSI7Fx1f/XkAh24CXeU2lnNlzpXLHVzGT68HQ9v0QCRh+bneB7tBEkwKLE5g2VjALjaDj65mElGkn+8ZyttztzNb8/ujrWkNBtKR7u0wWIgcgfs7fBf7c8i9HFs+9nZraZEdoLPuYGfAgMBAAECggEAMhwkER34DHWtH/3v73bmEuybPNBbR/cTAD3VXPZSAmuayS4X52970Rxz2h9xtgH+7lmkRTK1Kgbx6oO9dnc0hszSlcc/YuBU+jobINXtmZBuA++z80s2wOx8ltIVgaexjm4PpxfeGujwsTGFyQ+EQ3GnbkZnInf6dTdx2Lnli4zy1nom/7MrLxqXhGYf5iRdNMiPwx5dxSUsAWBhRvMMhJAyX+Mq0ft2FLxTk1eotHNXWtTwjPHEsHDjEEZT758uMsxqXYWKM/rrabrBhB1MM2nVww++G0Q6zdiE82kG5XaPR9unYqyjVMFO0srY6DgYXxyNVANS4rDEAjhPzI8qoQKBgQD5Tx0M0cJdtXYmGtqLaVKly9Gpe63lMVjwCOFTudLCi0QnfQ1bB+oEb+SKOegrGD3yRRF77a8iRtkqQc4ujoUTjyBjzJ7XH5+zSjqPrLFa/z5caLV2Agycj36RWCJV2L9XsMg9xk+HXxYiKEA4ft1NkrQqXMgXRSBl/KgdTyk+1wKBgQDUAe1AwBxQnb4VR3iX+rUjsl6JQBvwC60d4/vtSV4nFr4sDJuQo169uE3FI57OMyJwlBM3B+e1YEGPNafPojRv5EP+mGG+XIhmFiY6k4D7l+37p8/ymKAAJvhgrU9mKQniXZx5a29Hf/j8t63yzN2jRzs3gcE/uzdsddTdvyfieQKBgEkcZUWEIf6/H1XPXDWz/lO2sNaF+ZoT3aQOxp16Cg+ZLbRy3L7MVFlWwuuyTZ6NrmTk0lrIeiqQIlFdGOzYSLhSqcn6kL4/fOLkKsZFe4FXBt+sqUJhGXe0MQbIlNEeDgbWRfKvvFTTkrcTnLm0oouEMSeXK+p/ECA4dsiZlVvjAoGAMBIvxZrJ0M2zqAeIpI1IPUvYe655pzg+jKSBHxCftKVHgZ1qOKWSedosaCLng0G88WHh6Xx1YX7t3pb/8eiJk0Vi1XufzhYVJ3CmQmnnuSR95a3rTMqmnOI5N1KUyklL4HPxYualWMT/o+3SF1e0ea1RFAjr1JOSwZkGJzGMzaECgYEAhmHEv1HWQus7MFSiDPCEGekDbAbrqQOVHznLM7oU9PoVT8PPYm4qajoe9+kaGdR1wDgUcOIP2FstUAGrUCil/5EJbg+r3T1sH1TdIVEOalFNmoddYGYK00xdIyuHkZ5ADQP4oahM5XbpWm/2n3VNcTgY7qHoKqU7psVwLQklSqM=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDOd2RrB4TRtSdUarzog++Ma3tnWkq/kCiMGbZ175EnEkVImcCtKuVjoS+2qXDYoMR85yj1Q7tR/Me5iFINqK/ZZRBcmvokwWPLlNUCsE6Ig7YJCmUvuRaRGKYmJ6mJLVd98yhqeU7Pu7A0kXp07orpVmje+KbA7WCeZqsOQXHgTweqirqoBMZf6kV5p/Ya3mngpqmzCPhZTQSI7Fx1f/XkAh24CXeU2lnNlzpXLHVzGT68HQ9v0QCRh+bneB7tBEkwKLE5g2VjALjaDj65mElGkn+8ZyttztzNb8/ujrWkNBtKR7u0wWIgcgfs7fBf7c8i9HFs+9nZraZEdoLPuYGfAgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmRVSpRP7xqAD6DygdDs41Tou7kC4ZMcbXZusRsBmJPVVH", + "privKey": "CAASqAkwggSkAgEAAoIBAQC1pz29v/97ld9dVd/jUrCM0ZIGABwqG1UvpPXffF1zWlHBHyoheUXi1QD+QDNFV06ajEMP1j0jGeo5bYn2ggZf5duxeT5x5cRO1yWF/j54uprOlbg1/8+TRgRZrKFDmXY2p3ovxwg/dqBFZ+H8EDTWA3Wvq5VFPMzHlm0HCernyxnERxtC6vqC601wIsU2TTEGqHzEPi4yvIgfdu3Hse92j99nBUo6jftjMxv50IMLZM091DPfNlQCBRKwrxmArm2o591B/+Z7xsaNreQKIw5rDBnwT/QXzZuKf8hkcnXYek1PIiY4FngtHuWj0zjNDaNtClI/6kR4pCYgBFoIaoz1AgMBAAECggEBAIVQTMaSPsyTTE8yc9JgYEOoljMjJ4hbcOQ7e1rd6bN7qJ5D4eaZGwoC6uytbzNHhN91as4Xm9zD6xrkYijwef8tMVOJOKPcTXrS+K3izjRKNszAImY27D8YVp79S4jR+mjX9ptTxaDVzX/CYp5bwnsCJP+cvDsJCPy9UBynUad0MQVQnYCS6/gl8xSlxh7oaZ3oZzEMFZWzXmgc+w5agaNL+XEzWhLi5PD+DxZoCMnRUg6+0AiHJcOFnDTyRRi4bymerDJNVScOG7Jx6QLJQ9LwP8iNMa5zWoSPSR2E9m+Z1JioxXtAjIKfz4jxhbMIBibXy7euBOu+WP5k5nkwLu0CgYEA4a30MyabKClXN4jaflef7Q6csqSQFJt7oaxC6DzFT21bxvbJB5gyuwJXUX6MnIne7zl56j43usMDyij4Gsmm2Ukug7fdUnbNfzfXZHVIqCDRI12LKM0gdhpbnnchtKg5Is8A+vdz5a9NOtVFhY3KpZbFvLgf6V1jf9Klhtfl+B8CgYEAzg8LZLzcGcM3UTA+t/4ExW2jPNVi1dn+Wff6aL+X8sQMn+cD3xcQlPs394eBqvqh2/57ifdlHCKnrIGnuscTCM4VTbfhOwIGDd1PagxE3SRcG7yShsVO79GhcWkHFyUmditCVUue5UXJWj2Er4YQZ6EVwicC7SYKO6T8ZS6ZKGsCgYEAkcaI0CWm4Zlaoh+/aw702e6vX2GXRAhvIq6gBV2D4lt0hh/RGRvB4TSQ7K4+67rPC13oF1wbKYNgxkwSf1M0eHSiHCk/SE4/TWbnthdgWGHiVeLNygw+ZKt/9OtlFUn4pjhqnLIM5heHXnJ21t8RQEcU8WNKEbbmV6HclC6PeOcCgYATbYGyfsf1ud0mT3kqWc3TW3Hvk2LdLM95ZhL6+011OxzBmsNXrlIG6eSt9t235CeMmWLGcEfdLjtG3XaV+p0F0IBbsoGO0bMGbZ5GLl/zxbDVgKMEB+hYXhhtm+xqNzt4Gr4HUrjpfvnsAy7Wabp0OtDVXF4/Q73lP7n4RDt2fwKBgEHE+gsQoYBS8CY5UJHmHbft4oQ2YbGEe9DwKwXlB0y65154okg8Qk/fldwG4W/4PujOvO+rqHZ+zw8i25TV9uvYToDeobFj84y+MInWS65Gx7Ky1NQP6gGO4+2CxzWsvF0GSbdwqW4iqtwYgj8StFsxjGCY5Rkrx8pjbpXbImmC", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC1pz29v/97ld9dVd/jUrCM0ZIGABwqG1UvpPXffF1zWlHBHyoheUXi1QD+QDNFV06ajEMP1j0jGeo5bYn2ggZf5duxeT5x5cRO1yWF/j54uprOlbg1/8+TRgRZrKFDmXY2p3ovxwg/dqBFZ+H8EDTWA3Wvq5VFPMzHlm0HCernyxnERxtC6vqC601wIsU2TTEGqHzEPi4yvIgfdu3Hse92j99nBUo6jftjMxv50IMLZM091DPfNlQCBRKwrxmArm2o591B/+Z7xsaNreQKIw5rDBnwT/QXzZuKf8hkcnXYek1PIiY4FngtHuWj0zjNDaNtClI/6kR4pCYgBFoIaoz1AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + }, + { + "id": { + "id": "QmVG3c9ejpUUoAVg5T3TjcS1tXGWwmG6dmbgkSLxvp3jgt", + "privKey": "CAASpwkwggSjAgEAAoIBAQDN3x153zheqZd1EMVM/ty8j24QeAIdqvntIFMTrhVgqtGV6NiCLTytiXo/qOFa4eN0V0AXpK6xXS46NAFkOej4rDG3b1d9eUKADndja98ywtbMdKjddtuVWvIa/0M5TgBvtv0JSAi3qyOUM2GmBkRn9L4GsBvj440I82gASkNSsxKUa7LCxAz3mK9pCZ5QVWZGRIMjQzNpB3uR12vwXKouBf/Rnx9GIg7G2a7f6GTWWlNr+BLynURMaWnOu6mtVnCmPGAXysLZgodzw1aLdF6im57a/pd9zw0jcI5d/ffSHii51/337+ffdizSwTnAJnCGN4Y7Vpq5l4SJXFerT6V/AgMBAAECggEBAIeRtqJryX4k5fUULykt6ARP22YC8TnCPsTVdX/PMoqu0keKxxCqY3vPvW4wcv5bJGKXlkA7lUJ9HxT67DOpIu6mzjKCorWg5ZbYb+xLu/Z8ceC/rffw7lbjRe1bTVRuNkFa2jSDeCIjE9HjKBmhpOhkNcLHtAYU8eoEB+ew/7ZzwXiCTJUNFeTqb6dzuvhRpipD0ARCGGWUbbt18osWl1IPDNDkQfcCAcDSO1Mb2fC07uS2D3Hj9h0wUFN/lfzg64mIs1Lxh6+ctdYO3ln/n2hpYAT/QgoqrkpPCZy7PrWkTCSTW/Su9/NWqaTV3F9MzJnKkzexyF2442qhA15fpwkCgYEA7KWSUQg1hRoRPXrKpaSmF/iXW1d/+VOLRXWTR9Fpvi/PDQpgLyVMGLL5N+ENjSlcZCbk7hbffjSgoU6mSZqD92vKHN3kbFPxHf8Fk2g2V+GY2850pYlXX44IlOg1aeAX0Zx+SiWzWtCA9CFxwTh7gSpx/HOrFubiF2oO0OzXHuMCgYEA3rU8Ea67DKfBTPzlM9Wc/EpazVvdKC7/wPgjJfKbkTnqk6fjx0q+jLq3LzHTdobf7w7ydWs5U+8W4/c/oXmiGNVXwpEfTDAKYIkyKoMwlp/V2XaRlEVin4+SvlCvxMeo2x3N3kTnul6vGfT0O2tWFjDP8Uz4VnQVJz+Iqq1AJbUCgYAifqwKVcj/YuJadNivNoXjfqAJd4K3BD+L22yhjlv8lhl3TCjjFmu2Ofhr9ck052+JRcYfEoR3cBJuEPnaRsSvvy2R8aJHTCEcfzz/1LP/MWpHuBt2ucNbsWd81TBcA4dVTZt3EXHIbhYt/+YGBUazeE1vQCkTSIpyYUpRmARvgwKBgAO87wEs+Z7AwhHUvNQd5cCmTtfbjt65yzkl8REV/V52pmVMEBqsOn6KM8DrCS2YHfIZQiCOaCvse2ngIIVJUVsxWYO+g9P3inUMWHc2NH6SuDgqMU9Xysv60O+40vpuj3r+CRKN/YW3SSEaZ28H4i4FK7hVHmX1FNXPzy9uMQFxAoGAcRL/1MJiXG9XPdUUuRnlHgMgObeKyYjvy+1JyRgYhIMudpk1HWvo/+v7SIZwDm0NVA3fEgWhB1BNUxwbijrxw5TGH29fnXa+NFATFcmvyfwSVvbEB8Ml5E4X1S6r2EE5lHYIoa1fTV03LMJVuSrN12kqOyV4Bj6XTaJ0ZQ/+vi0=", + "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDN3x153zheqZd1EMVM/ty8j24QeAIdqvntIFMTrhVgqtGV6NiCLTytiXo/qOFa4eN0V0AXpK6xXS46NAFkOej4rDG3b1d9eUKADndja98ywtbMdKjddtuVWvIa/0M5TgBvtv0JSAi3qyOUM2GmBkRn9L4GsBvj440I82gASkNSsxKUa7LCxAz3mK9pCZ5QVWZGRIMjQzNpB3uR12vwXKouBf/Rnx9GIg7G2a7f6GTWWlNr+BLynURMaWnOu6mtVnCmPGAXysLZgodzw1aLdF6im57a/pd9zw0jcI5d/ffSHii51/337+ffdizSwTnAJnCGN4Y7Vpq5l4SJXFerT6V/AgMBAAE=" + }, + "multiaddrs": [], + "multiaddr": {} + } + ] +} \ No newline at end of file diff --git a/test/switch/transport-manager.spec.js b/test/switch/transport-manager.spec.js new file mode 100644 index 0000000000..cfc24b678f --- /dev/null +++ b/test/switch/transport-manager.spec.js @@ -0,0 +1,290 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) +const Multiaddr = require('multiaddr') +const PeerInfo = require('peer-info') +const sinon = require('sinon') + +const TransportManager = require('libp2p-switch/transport') + +describe('Transport Manager', () => { + afterEach(() => { + sinon.restore() + }) + + describe('dialables', () => { + let peerInfo + const dialAllTransport = { filter: addrs => addrs } + + beforeEach(done => { + PeerInfo.create((err, info) => { + if (err) return done(err) + peerInfo = info + done() + }) + }) + + it('should return all transport addresses when peer info has 0 addrs', () => { + const queryAddrs = [ + '/ip4/127.0.0.1/tcp/4002', + '/ip4/192.168.0.3/tcp/4002', + '/ip6/::1/tcp/4001' + ].map(a => Multiaddr(a)) + + const dialableAddrs = TransportManager.dialables(dialAllTransport, queryAddrs, peerInfo) + + expect(dialableAddrs).to.have.length(queryAddrs.length) + + queryAddrs.forEach(qa => { + expect(dialableAddrs.some(da => da.equals(qa))).to.be.true() + }) + }) + + it('should return all transport addresses when we pass no peer info', () => { + const queryAddrs = [ + '/ip4/127.0.0.1/tcp/4002', + '/ip4/192.168.0.3/tcp/4002', + '/ip6/::1/tcp/4001' + ].map(a => Multiaddr(a)) + + const dialableAddrs = TransportManager.dialables(dialAllTransport, queryAddrs) + + expect(dialableAddrs).to.have.length(queryAddrs.length) + + queryAddrs.forEach(qa => { + expect(dialableAddrs.some(da => da.equals(qa))).to.be.true() + }) + }) + + it('should filter our addresses', () => { + const queryAddrs = [ + '/ip4/127.0.0.1/tcp/4002', + '/ip4/192.168.0.3/tcp/4002', + '/ip6/::1/tcp/4001' + ].map(a => Multiaddr(a)) + + const ourAddrs = [ + '/ip4/127.0.0.1/tcp/4002', + '/ip4/192.168.0.3/tcp/4002' + ] + + ourAddrs.forEach(a => peerInfo.multiaddrs.add(a)) + + const dialableAddrs = TransportManager.dialables(dialAllTransport, queryAddrs, peerInfo) + + expect(dialableAddrs).to.have.length(1) + expect(dialableAddrs[0].toString()).to.equal('/ip6/::1/tcp/4001') + }) + + it('should filter our addresses with peer ID suffix', () => { + const queryAddrs = [ + '/ip4/127.0.0.1/tcp/4002/ipfs/QmebzNV1kSzLfaYpSZdShuiABNUxoKT1vJmCdxM2iWsM2j', + '/ip4/192.168.0.3/tcp/4002', + '/ip6/::1/tcp/4001' + ].map(a => Multiaddr(a)) + + const ourAddrs = [ + `/ip4/127.0.0.1/tcp/4002`, + `/ip4/192.168.0.3/tcp/4002/ipfs/${peerInfo.id.toB58String()}` + ] + + ourAddrs.forEach(a => peerInfo.multiaddrs.add(a)) + + const dialableAddrs = TransportManager.dialables(dialAllTransport, queryAddrs, peerInfo) + + expect(dialableAddrs).to.have.length(1) + expect(dialableAddrs[0].toString()).to.equal('/ip6/::1/tcp/4001') + }) + + it('should filter out our addrs that start with /ipfs/', () => { + const queryAddrs = [ + '/ip4/127.0.0.1/tcp/4002/ipfs/QmebzNV1kSzLfaYpSZdShuiABNUxoKT1vJmCdxM2iWsM2j' + ].map(a => Multiaddr(a)) + + const ourAddrs = [ + '/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z' + ] + + ourAddrs.forEach(a => peerInfo.multiaddrs.add(a)) + + const dialableAddrs = TransportManager.dialables(dialAllTransport, queryAddrs, peerInfo) + + expect(dialableAddrs).to.have.length(1) + expect(dialableAddrs[0]).to.eql(queryAddrs[0]) + }) + + it('should filter our addresses over relay/rendezvous', () => { + const peerId = peerInfo.id.toB58String() + const queryAddrs = [ + `/p2p-circuit/ipfs/${peerId}`, + `/p2p-circuit/ip4/127.0.0.1/tcp/4002`, + `/p2p-circuit/ip4/192.168.0.3/tcp/4002`, + `/p2p-circuit/ip4/127.0.0.1/tcp/4002/ipfs/${peerId}`, + `/p2p-circuit/ip4/192.168.0.3/tcp/4002/ipfs/${peerId}`, + `/p2p-circuit/ip4/127.0.0.1/tcp/4002/ipfs/QmebzNV1kSzLfaYpSZdShuiABNUxoKT1vJmCdxM2iWsM2j`, + `/p2p-circuit/ip4/192.168.0.3/tcp/4002/ipfs/QmebzNV1kSzLfaYpSZdShuiABNUxoKT1vJmCdxM2iWsM2j`, + `/p2p-webrtc-star/ipfs/${peerId}`, + `/p2p-websocket-star/ipfs/${peerId}`, + `/p2p-stardust/ipfs/${peerId}`, + '/ip6/::1/tcp/4001' + ].map(a => Multiaddr(a)) + + const ourAddrs = [ + `/ip4/127.0.0.1/tcp/4002`, + `/ip4/192.168.0.3/tcp/4002/ipfs/${peerInfo.id.toB58String()}` + ] + + ourAddrs.forEach(a => peerInfo.multiaddrs.add(a)) + + const dialableAddrs = TransportManager.dialables(dialAllTransport, queryAddrs, peerInfo) + + expect(dialableAddrs).to.have.length(1) + expect(dialableAddrs[0].toString()).to.equal('/ip6/::1/tcp/4001') + }) + }) + + describe('listen', () => { + const listener = { + once: function () {}, + listen: function () {}, + removeListener: function () {}, + getAddrs: function () {} + } + + it('should allow for multiple addresses with port 0', (done) => { + const mockListener = sinon.stub(listener) + mockListener.listen.callsArg(1) + mockListener.getAddrs.callsArgWith(0, null, []) + const mockSwitch = { + _peerInfo: { + multiaddrs: { + toArray: () => [ + Multiaddr('/ip4/127.0.0.1/tcp/0'), + Multiaddr('/ip4/0.0.0.0/tcp/0') + ], + replace: () => {} + } + }, + _options: {}, + _connectionHandler: () => {}, + transports: { + TCP: { + filter: (addrs) => addrs, + createListener: () => { + return mockListener + } + } + } + } + const transportManager = new TransportManager(mockSwitch) + transportManager.listen('TCP', null, null, (err) => { + expect(err).to.not.exist() + expect(mockListener.listen.callCount).to.eql(2) + done() + }) + }) + + it('should filter out equal addresses', (done) => { + const mockListener = sinon.stub(listener) + mockListener.listen.callsArg(1) + mockListener.getAddrs.callsArgWith(0, null, []) + const mockSwitch = { + _peerInfo: { + multiaddrs: { + toArray: () => [ + Multiaddr('/ip4/127.0.0.1/tcp/0'), + Multiaddr('/ip4/127.0.0.1/tcp/0') + ], + replace: () => {} + } + }, + _options: {}, + _connectionHandler: () => {}, + transports: { + TCP: { + filter: (addrs) => addrs, + createListener: () => { + return mockListener + } + } + } + } + const transportManager = new TransportManager(mockSwitch) + transportManager.listen('TCP', null, null, (err) => { + expect(err).to.not.exist() + expect(mockListener.listen.callCount).to.eql(1) + done() + }) + }) + + it('should account for addresses with no port', (done) => { + const mockListener = sinon.stub(listener) + mockListener.listen.callsArg(1) + mockListener.getAddrs.callsArgWith(0, null, []) + const mockSwitch = { + _peerInfo: { + multiaddrs: { + toArray: () => [ + Multiaddr('/p2p-circuit'), + Multiaddr('/p2p-websocket-star') + ], + replace: () => {} + } + }, + _options: {}, + _connectionHandler: () => {}, + transports: { + TCP: { + filter: (addrs) => addrs, + createListener: () => { + return mockListener + } + } + } + } + const transportManager = new TransportManager(mockSwitch) + transportManager.listen('TCP', null, null, (err) => { + expect(err).to.not.exist() + expect(mockListener.listen.callCount).to.eql(2) + done() + }) + }) + + it('should filter out addresses with the same, non 0, port', (done) => { + const mockListener = sinon.stub(listener) + mockListener.listen.callsArg(1) + mockListener.getAddrs.callsArgWith(0, null, []) + const mockSwitch = { + _peerInfo: { + multiaddrs: { + toArray: () => [ + Multiaddr('/ip4/127.0.0.1/tcp/8000'), + Multiaddr('/dnsaddr/libp2p.io/tcp/8000') + ], + replace: () => {} + } + }, + _options: {}, + _connectionHandler: () => {}, + transports: { + TCP: { + filter: (addrs) => addrs, + createListener: () => { + return mockListener + } + } + } + } + const transportManager = new TransportManager(mockSwitch) + transportManager.listen('TCP', null, null, (err) => { + expect(err).to.not.exist() + expect(mockListener.listen.callCount).to.eql(1) + done() + }) + }) + }) +}) diff --git a/test/switch/transports.browser.js b/test/switch/transports.browser.js new file mode 100644 index 0000000000..fc3e4104ec --- /dev/null +++ b/test/switch/transports.browser.js @@ -0,0 +1,52 @@ +/* eslint-env mocha */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const PeerId = require('peer-id') +const PeerInfo = require('peer-info') +const PeerBook = require('peer-book') +const WebSockets = require('libp2p-websockets') + +const tryEcho = require('./utils').tryEcho +const Switch = require('libp2p-switch') + +describe('Transports', () => { + describe('WebSockets', () => { + let sw + let peer + + before((done) => { + const b58IdSrc = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb' + // use a pre generated Id to save time + const idSrc = PeerId.createFromB58String(b58IdSrc) + const peerSrc = new PeerInfo(idSrc) + sw = new Switch(peerSrc, new PeerBook()) + + PeerInfo.create((err, p) => { + expect(err).to.not.exist() + peer = p + done() + }) + }) + + it('.transport.add', () => { + sw.transport.add('ws', new WebSockets()) + expect(Object.keys(sw.transports).length).to.equal(1) + }) + + it('.transport.dial', (done) => { + peer.multiaddrs.clear() + peer.multiaddrs.add('/ip4/127.0.0.1/tcp/15337/ws') + + const conn = sw.transport.dial('ws', peer, (err, conn) => { + expect(err).to.not.exist() + }) + + tryEcho(conn, done) + }) + }) +}) diff --git a/test/switch/transports.node.js b/test/switch/transports.node.js new file mode 100644 index 0000000000..9989a163e1 --- /dev/null +++ b/test/switch/transports.node.js @@ -0,0 +1,237 @@ +/* eslint-env mocha */ +/* eslint no-warning-comments: off */ +'use strict' + +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) +const parallel = require('async/parallel') +const TCP = require('libp2p-tcp') +const WS = require('libp2p-websockets') +const pull = require('pull-stream') +const PeerBook = require('peer-book') + +const utils = require('./utils') +const createInfos = utils.createInfos +const tryEcho = utils.tryEcho +const Switch = require('libp2p-switch') + +describe('transports', () => { + [ + { n: 'TCP', C: TCP, maGen: (port) => { return `/ip4/127.0.0.1/tcp/${port}` } }, + { n: 'WS', C: WS, maGen: (port) => { return `/ip4/127.0.0.1/tcp/${port}/ws` } } + // { n: 'UTP', C: UTP, maGen: (port) => { return `/ip4/127.0.0.1/udp/${port}/utp` } } + ].forEach((t) => describe(t.n, () => { + let switchA + let switchB + let morePeerInfo + + before(function (done) { + this.timeout(10 * 1000) + + createInfos(9, (err, peerInfos) => { + expect(err).to.not.exist() + + const peerA = peerInfos[0] + const peerB = peerInfos[1] + morePeerInfo = peerInfos.slice(2) + + peerA.multiaddrs.add(t.maGen(9888)) + peerB.multiaddrs.add(t.maGen(9999)) + switchA = new Switch(peerA, new PeerBook()) + switchB = new Switch(peerB, new PeerBook()) + done() + }) + }) + + after(function (done) { + parallel([ + (next) => switchA.stop(next), + (next) => switchB.stop(next) + ], done) + }) + + it('.transport.remove', () => { + switchA.transport.add('test', new t.C()) + expect(switchA.transports).to.have.any.keys(['test']) + switchA.transport.remove('test') + expect(switchA.transports).to.not.have.any.keys(['test']) + // verify remove fails silently + switchA.transport.remove('test') + }) + + it('.transport.removeAll', (done) => { + switchA.transport.add('test', new t.C()) + switchA.transport.add('test2', new t.C()) + expect(switchA.transports).to.have.any.keys(['test', 'test2']) + switchA.transport.removeAll(() => { + expect(switchA.transports).to.not.have.any.keys(['test', 'test2']) + done() + }) + }) + + it('.transport.add', () => { + switchA.transport.add(t.n, new t.C()) + expect(Object.keys(switchA.transports).length).to.equal(1) + + switchB.transport.add(t.n, new t.C()) + expect(Object.keys(switchB.transports).length).to.equal(1) + }) + + it('.transport.listen', (done) => { + let count = 0 + + switchA.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + switchB.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + + function ready () { + if (++count === 2) { + expect(switchA._peerInfo.multiaddrs.size).to.equal(1) + expect(switchB._peerInfo.multiaddrs.size).to.equal(1) + done() + } + } + }) + + it('.transport.dial to a multiaddr', (done) => { + const peer = morePeerInfo[0] + peer.multiaddrs.add(t.maGen(9999)) + + switchA.transport.dial(t.n, peer, (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, done) + }) + }) + + it('.transport.dial to set of multiaddr, only one is available', (done) => { + const peer = morePeerInfo[1] + peer.multiaddrs.add(t.maGen(9359)) + peer.multiaddrs.add(t.maGen(9329)) + peer.multiaddrs.add(t.maGen(9910)) + peer.multiaddrs.add(switchB._peerInfo.multiaddrs.toArray()[0]) // the valid address + peer.multiaddrs.add(t.maGen(9309)) + // addr not supported added on purpose + peer.multiaddrs.add('/ip4/1.2.3.4/tcp/3456/ws/p2p-webrtc-star') + + switchA.transport.dial(t.n, peer, (err, conn) => { + expect(err).to.not.exist() + tryEcho(conn, done) + }) + }) + + it('.transport.dial to set of multiaddr, none is available', (done) => { + const peer = morePeerInfo[2] + peer.multiaddrs.add(t.maGen(9359)) + peer.multiaddrs.add(t.maGen(9329)) + // addr not supported added on purpose + peer.multiaddrs.add('/ip4/1.2.3.4/tcp/3456/ws/p2p-webrtc-star') + + switchA.transport.dial(t.n, peer, (err, conn) => { + expect(err).to.exist() + expect(conn).to.not.exist() + done() + }) + }) + + it('.close', function (done) { + this.timeout(2500) + + parallel([ + (cb) => switchA.transport.close(t.n, cb), + (cb) => switchB.transport.close(t.n, cb) + ], done) + }) + + it('support port 0', (done) => { + const ma = t.maGen(0) + const peer = morePeerInfo[3] + peer.multiaddrs.add(ma) + + const sw = new Switch(peer, new PeerBook()) + sw.transport.add(t.n, new t.C()) + sw.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + + function ready () { + expect(peer.multiaddrs.size).to.equal(1) + // should not have /tcp/0 anymore + expect(peer.multiaddrs.has(ma)).to.equal(false) + sw.stop(done) + } + }) + + it('support addr 0.0.0.0', (done) => { + const ma = t.maGen(9050).replace('127.0.0.1', '0.0.0.0') + const peer = morePeerInfo[4] + peer.multiaddrs.add(ma) + + const sw = new Switch(peer, new PeerBook()) + sw.transport.add(t.n, new t.C()) + sw.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + + function ready () { + expect(peer.multiaddrs.size >= 1).to.equal(true) + expect(peer.multiaddrs.has(ma)).to.equal(false) + sw.stop(done) + } + }) + + it('support addr 0.0.0.0:0', (done) => { + const ma = t.maGen(9050).replace('127.0.0.1', '0.0.0.0') + const peer = morePeerInfo[5] + peer.multiaddrs.add(ma) + + const sw = new Switch(peer, new PeerBook()) + sw.transport.add(t.n, new t.C()) + sw.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + + function ready () { + expect(peer.multiaddrs.size >= 1).to.equal(true) + expect(peer.multiaddrs.has(ma)).to.equal(false) + sw.stop(done) + } + }) + + it('listen in several addrs', function (done) { + this.timeout(12000) + const peer = morePeerInfo[6] + + peer.multiaddrs.add(t.maGen(9001)) + peer.multiaddrs.add(t.maGen(9002)) + peer.multiaddrs.add(t.maGen(9003)) + + const sw = new Switch(peer, new PeerBook()) + sw.transport.add(t.n, new t.C()) + sw.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + + function ready () { + expect(peer.multiaddrs.size).to.equal(3) + sw.stop(done) + } + }) + + it('handles EADDRINUSE error when trying to listen', (done) => { + // TODO: fix libp2p-websockets to not throw Uncaught Error in this test + if (t.n === 'WS') { return done() } + + const switch1 = new Switch(switchA._peerInfo, new PeerBook()) + let switch2 + + switch1.transport.add(t.n, new t.C()) + switch1.transport.listen(t.n, {}, (conn) => pull(conn, conn), () => { + // Add in-use (peerA) address to peerB + switchB._peerInfo.multiaddrs.add(t.maGen(9888)) + + switch2 = new Switch(switchB._peerInfo, new PeerBook()) + switch2.transport.add(t.n, new t.C()) + switch2.transport.listen(t.n, {}, (conn) => pull(conn, conn), ready) + }) + + function ready (err) { + expect(err).to.exist() + expect(err.code).to.equal('EADDRINUSE') + switch1.stop(() => switch2.stop(done)) + } + }) + })) +}) diff --git a/test/switch/utils.js b/test/switch/utils.js new file mode 100644 index 0000000000..a518d73ea4 --- /dev/null +++ b/test/switch/utils.js @@ -0,0 +1,76 @@ +'use strict' + +const PeerInfo = require('peer-info') +const PeerId = require('peer-id') +const parallel = require('async/parallel') +const pull = require('pull-stream') +const chai = require('chai') +const dirtyChai = require('dirty-chai') +const expect = chai.expect +chai.use(dirtyChai) + +const fixtures = require('./test-data/ids.json').infos + +exports.createInfos = (num, callback) => { + const tasks = [] + + for (let i = 0; i < num; i++) { + tasks.push((cb) => { + if (fixtures[i]) { + PeerId.createFromJSON(fixtures[i].id, (err, id) => { + if (err) { + return cb(err) + } + + cb(null, new PeerInfo(id)) + }) + return + } + + PeerInfo.create(cb) + }) + } + + parallel(tasks, callback) +} + +exports.tryEcho = (conn, callback) => { + const values = [Buffer.from('echo')] + + pull( + pull.values(values), + conn, + pull.collect((err, _values) => { + expect(err).to.not.exist() + expect(_values).to.eql(values) + callback() + }) + ) +} + +/** + * A utility method for calling done multiple times to help with async + * testing + * + * @param {Number} n The number of times done will be called + * @param {Function} willFinish An optional callback for cleanup before done is called + * @param {Function} done + * @returns {void} + */ +exports.doneAfter = (n, willFinish, done) => { + if (!done) { + done = willFinish + willFinish = undefined + } + + let count = 0 + let errors = [] + return (err) => { + count++ + if (err) errors.push(err) + if (count >= n) { + if (willFinish) willFinish() + done(errors.length > 0 ? errors : null) + } + } +}