fluencelabs/js-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/js-libp2p synced 2025-03-14 22:50:50 +00:00
Code Issues Projects Releases Wiki Activity

feat!: update libp2p interfaces (#1252)

Browse Source 
BREAKING CHANGE: uses new single-issue libp2p interface modules
This commit is contained in:
Alex Potsides 2022-06-15 18:30:39 +01:00 committed by GitHub
parent 13d95b413c
commit d4dd664071
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
81 changed files with 370 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/CONFIGURATION.md
View File

@ -323,7 +323,7 @@ import { TCP } from '@libp2p/tcp'
import { Mplex } from '@libp2p/mplex'
import { Noise } from '@chainsafe/libp2p-noise'
import { GossipSub } from 'libp2p-gossipsub'
import { SignaturePolicy } from '@libp2p/interfaces/pubsub'
import { SignaturePolicy } from '@libp2p/interface-pubsub'
const node = await createLibp2p({
transports: [

2
doc/migrations/v0.36-v.037.md
View File

@ -240,7 +240,7 @@ libp2p.pubsub.off('my-topic', handler)
**After**
```js
import type { Message } from '@libp2p/interfaces/pubsub'
import type { Message } from '@libp2p/interface-pubsub'
const handler = (event: CustomEvent<Message>) => {
const message = event.detail

12
examples/delegated-routing/package.json
View File

@ -6,12 +6,12 @@
"@chainsafe/libp2p-noise": "^6.2.0",
"ipfs-core": "^0.14.1",
"libp2p": "../../",
"@libp2p/delegated-content-routing": "^1.0.1",
"@libp2p/delegated-peer-routing": "^1.0.1",
"@libp2p/kad-dht": "^1.0.9",
"@libp2p/mplex": "^1.0.4",
"@libp2p/webrtc-star": "^1.0.8",
"@libp2p/websockets": "^1.0.7",
"@libp2p/delegated-content-routing": "^2.0.1",
"@libp2p/delegated-peer-routing": "^2.0.1",
"@libp2p/kad-dht": "^2.0.0",
"@libp2p/mplex": "^2.0.0",
"@libp2p/webrtc-star": "^2.0.0",
"@libp2p/websockets": "^2.0.0",
"react": "^17.0.2",
"react-dom": "^17.0.2",
"react-scripts": "5.0.0"

8
examples/libp2p-in-the-browser/package.json
View File

@ -10,10 +10,10 @@
"license": "ISC",
"dependencies": {
"@chainsafe/libp2p-noise": "^6.2.0",
"@libp2p/bootstrap": "^1.0.4",
"@libp2p/mplex": "^1.0.4",
"@libp2p/webrtc-star": "^1.0.8",
"@libp2p/websockets": "^1.0.7",
"@libp2p/bootstrap": "^2.0.0",
"@libp2p/mplex": "^2.0.0",
"@libp2p/webrtc-star": "^2.0.0",
"@libp2p/websockets": "^2.0.0",
"libp2p": "../../"
},
"devDependencies": {

4
examples/package.json
View File

@ -9,8 +9,8 @@
},
"license": "MIT",
"dependencies": {
"@libp2p/pubsub-peer-discovery": "^5.0.2",
"@libp2p/floodsub": "^1.0.6",
"@libp2p/pubsub-peer-discovery": "^6.0.0",
"@libp2p/floodsub": "^2.0.0",
"@nodeutils/defaults-deep": "^1.1.0",
"execa": "^2.1.0",
"fs-extra": "^8.1.0",

6
examples/webrtc-direct/package.json
View File

@ -9,10 +9,10 @@
},
"license": "ISC",
"dependencies": {
"@libp2p/webrtc-direct": "^1.0.1",
"@libp2p/webrtc-direct": "^2.0.0",
"@chainsafe/libp2p-noise": "^6.2.0",
"@libp2p/bootstrap": "^1.0.4",
"@libp2p/mplex": "^1.0.4",
"@libp2p/bootstrap": "^2.0.0",
"@libp2p/mplex": "^2.0.0",
"libp2p": "../../",
"wrtc": "^0.4.7"
},

74
package.json
View File

@ -49,15 +49,19 @@
],
"exports": {
".": {
"types": "./src/index.d.ts",
"import": "./dist/src/index.js"
},
"./insecure": {
"types": "./dist/src/insecure/index.d.ts",
"import": "./dist/src/insecure/index.js"
},
"./pnet": {
"types": "./dist/src/pnet/index.d.ts",
"import": "./dist/src/pnet/index.js"
},
"./transport-manager": {
"types": "./dist/src/transport-manager.d.ts",
"import": "./dist/src/transport-manager.js"
}
},
@ -93,18 +97,34 @@
},
"dependencies": {
"@achingbrain/nat-port-mapper": "^1.0.3",
"@libp2p/connection": "^2.0.2",
"@libp2p/crypto": "^0.22.11",
"@libp2p/interfaces": "^2.0.2",
"@libp2p/logger": "^1.1.4",
"@libp2p/multistream-select": "^1.0.4",
"@libp2p/components": "^1.0.0",
"@libp2p/connection": "^3.0.0",
"@libp2p/crypto": "^1.0.0",
"@libp2p/interface-address-manager": "^1.0.1",
"@libp2p/interface-connection": "^1.0.1",
"@libp2p/interface-connection-encrypter": "^1.0.2",
"@libp2p/interface-content-routing": "^1.0.1",
"@libp2p/interface-dht": "^1.0.0",
"@libp2p/interface-metrics": "^1.0.2",
"@libp2p/interface-peer-discovery": "^1.0.0",
"@libp2p/interface-peer-id": "^1.0.2",
"@libp2p/interface-peer-info": "^1.0.1",
"@libp2p/interface-peer-routing": "^1.0.0",
"@libp2p/interface-peer-store": "^1.0.0",
"@libp2p/interface-pubsub": "^1.0.1",
"@libp2p/interface-registrar": "^1.0.0",
"@libp2p/interface-stream-muxer": "^1.0.1",
"@libp2p/interface-transport": "^1.0.0",
"@libp2p/interfaces": "^3.0.2",
"@libp2p/logger": "^2.0.0",
"@libp2p/multistream-select": "^2.0.0",
"@libp2p/peer-collections": "^1.0.2",
"@libp2p/peer-id": "^1.1.10",
"@libp2p/peer-id-factory": "^1.0.9",
"@libp2p/peer-record": "^1.0.8",
"@libp2p/peer-store": "^1.0.10",
"@libp2p/peer-record": "^2.0.0",
"@libp2p/peer-store": "^2.0.0",
"@libp2p/tracked-map": "^1.0.5",
"@libp2p/utils": "^1.0.10",
"@libp2p/utils": "^2.0.0",
"@multiformats/mafmt": "^11.0.2",
"@multiformats/multiaddr": "^10.1.8",
"abortable-iterator": "^4.0.2",
@ -119,7 +139,7 @@
"it-filter": "^1.0.3",
"it-first": "^1.0.6",
"it-foreach": "^0.1.1",
"it-handshake": "^3.0.1",
"it-handshake": "^4.0.0",
"it-length-prefixed": "^7.0.1",
"it-map": "^1.0.6",
"it-merge": "^1.0.3",
@ -146,22 +166,24 @@
},
"devDependencies": {
"@chainsafe/libp2p-noise": "^6.2.0",
"@libp2p/bootstrap": "^1.0.4",
"@libp2p/daemon-client": "^1.0.2",
"@libp2p/daemon-server": "^1.0.2",
"@libp2p/delegated-content-routing": "^1.0.5",
"@libp2p/delegated-peer-routing": "^1.0.5",
"@libp2p/floodsub": "^1.0.6",
"@libp2p/interface-compliance-tests": "^2.0.3",
"@libp2p/interop": "^1.0.3",
"@libp2p/kad-dht": "^1.0.9",
"@libp2p/mdns": "^1.0.5",
"@libp2p/mplex": "^1.1.0",
"@libp2p/pubsub": "^1.2.18",
"@libp2p/tcp": "^1.0.9",
"@libp2p/topology": "^1.1.7",
"@libp2p/webrtc-star": "^1.0.8",
"@libp2p/websockets": "^1.0.7",
"@libp2p/bootstrap": "^2.0.0",
"@libp2p/daemon-client": "^2.0.0",
"@libp2p/daemon-server": "^2.0.0",
"@libp2p/delegated-content-routing": "^2.0.0",
"@libp2p/delegated-peer-routing": "^2.0.0",
"@libp2p/floodsub": "^2.0.0",
"@libp2p/interface-compliance-tests": "^3.0.1",
"@libp2p/interface-connection-encrypter-compliance-tests": "^1.0.0",
"@libp2p/interface-mocks": "^1.0.1",
"@libp2p/interop": "^2.0.0",
"@libp2p/kad-dht": "^2.0.0",
"@libp2p/mdns": "^2.0.0",
"@libp2p/mplex": "^2.0.0",
"@libp2p/pubsub": "^2.0.0",
"@libp2p/tcp": "^2.0.0",
"@libp2p/topology": "^2.0.0",
"@libp2p/webrtc-star": "^2.0.0",
"@libp2p/websockets": "^2.0.0",
"@types/node-forge": "^1.0.0",
"@types/p-fifo": "^1.0.0",
"@types/varint": "^6.0.0",
@ -173,7 +195,7 @@
"go-libp2p": "^0.0.6",
"into-stream": "^7.0.0",
"ipfs-http-client": "^57.0.1",
"it-pushable": "^2.0.1",
"it-pushable": "^3.0.0",
"it-to-buffer": "^2.0.2",
"nock": "^13.0.3",
"npm-run-all": "^4.1.5",

4
src/address-manager/index.ts
View File

@ -1,8 +1,8 @@
import type { AddressManagerEvents } from '@libp2p/interfaces/address-manager'
import type { AddressManagerEvents } from '@libp2p/interface-address-manager'
import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
import { Multiaddr } from '@multiformats/multiaddr'
import { peerIdFromString } from '@libp2p/peer-id'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
export interface AddressManagerInit {
announceFilter?: AddressFilter

8
src/circuit/auto-relay.ts
View File

@ -10,10 +10,10 @@ import {
HOP_METADATA_VALUE,
RELAY_RENDEZVOUS_NS
} from './constants.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Components } from '@libp2p/interfaces/components'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
import type { Connection } from '@libp2p/interface-connection'
import type { Components } from '@libp2p/components'
import sort from 'it-sort'
import all from 'it-all'
import { pipe } from 'it-pipe'

4
src/circuit/circuit/hop.ts
View File

@ -7,11 +7,11 @@ import { pipe } from 'it-pipe'
import { codes as Errors } from '../../errors.js'
import { stop } from './stop.js'
import { RELAY_CODEC } from '../multicodec.js'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import { peerIdFromBytes } from '@libp2p/peer-id'
import type { Duplex } from 'it-stream-types'
import type { Circuit } from '../transport.js'
import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
import type { ConnectionManager } from '@libp2p/interface-connection-manager'
const log = logger('libp2p:circuit:hop')

2
src/circuit/circuit/stop.ts
View File

@ -3,7 +3,7 @@ import { CircuitRelay as CircuitPB } from '../pb/index.js'
import { RELAY_CODEC } from '../multicodec.js'
import { StreamHandler } from './stream-handler.js'
import { validateAddrs } from './utils.js'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import type { Duplex } from 'it-stream-types'
const log = logger('libp2p:circuit:stop')

2
src/circuit/circuit/stream-handler.ts
View File

@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
import * as lp from 'it-length-prefixed'
import { Handshake, handshake } from 'it-handshake'
import { CircuitRelay } from '../pb/index.js'
import type { Stream } from '@libp2p/interfaces/connection'
import type { Stream } from '@libp2p/interface-connection'
import type { Source } from 'it-stream-types'
const log = logger('libp2p:circuit:stream-handler')

4
src/circuit/index.ts
View File

@ -10,9 +10,9 @@ import { namespaceToCid } from './utils.js'
import {
RELAY_RENDEZVOUS_NS
} from './constants.js'
import type { AddressSorter } from '@libp2p/interfaces/peer-store'
import type { AddressSorter } from '@libp2p/interface-peer-store'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
const log = logger('libp2p:relay')

6
src/circuit/listener.ts
View File

@ -1,7 +1,7 @@
import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
import type { PeerStore } from '@libp2p/interfaces/peer-store'
import type { Listener } from '@libp2p/interfaces/transport'
import type { ConnectionManager } from '@libp2p/interface-connection-manager'
import type { PeerStore } from '@libp2p/interface-peer-store'
import type { Listener } from '@libp2p/interface-transport'
import { peerIdFromString } from '@libp2p/peer-id'
import { Multiaddr } from '@multiformats/multiaddr'

10
src/circuit/transport.ts
View File

@ -10,13 +10,13 @@ import { createListener } from './listener.js'
import { handleCanHop, handleHop, hop } from './circuit/hop.js'
import { handleStop } from './circuit/stop.js'
import { StreamHandler } from './circuit/stream-handler.js'
import { symbol } from '@libp2p/interfaces/transport'
import { symbol } from '@libp2p/interface-transport'
import { peerIdFromString } from '@libp2p/peer-id'
import { Components, Initializable } from '@libp2p/interfaces/components'
import { Components, Initializable } from '@libp2p/components'
import type { AbortOptions } from '@libp2p/interfaces'
import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interfaces/transport'
import type { Connection } from '@libp2p/interfaces/connection'
import type { IncomingStreamData } from '@libp2p/interface-registrar'
import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
import type { Connection } from '@libp2p/interface-connection'
const log = logger('libp2p:circuit')

2
src/connection-manager/auto-dialler.ts
View File

@ -7,7 +7,7 @@ import { pipe } from 'it-pipe'
import filter from 'it-filter'
import sort from 'it-sort'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
const log = logger('libp2p:connection-manager:auto-dialler')

4
src/connection-manager/dialer/auto-dialer.ts
View File

@ -1,6 +1,6 @@
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import { logger } from '@libp2p/logger'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
import { TimeoutController } from 'timeout-abort-controller'
const log = logger('libp2p:dialer:auto-dialer')

2
src/connection-manager/dialer/dial-request.ts
View File

@ -5,7 +5,7 @@ import { setMaxListeners } from 'events'
import { codes } from '../../errors.js'
import { logger } from '@libp2p/logger'
import type { Multiaddr } from '@multiformats/multiaddr'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import type { AbortOptions } from '@libp2p/interfaces'
import type { Dialer } from './index.js'

10
src/connection-manager/dialer/index.ts
View File

@ -18,16 +18,16 @@ import {
MAX_PER_PEER_DIALS,
MAX_ADDRS_TO_DIAL
} from '../../constants.js'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import type { AbortOptions } from '@libp2p/interfaces'
import type { Startable } from '@libp2p/interfaces/startable'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { getPeer } from '../../get-peer.js'
import sort from 'it-sort'
import { Components, Initializable } from '@libp2p/interfaces/components'
import { Components, Initializable } from '@libp2p/components'
import map from 'it-map'
import type { AddressSorter } from '@libp2p/interfaces/peer-store'
import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics'
import type { AddressSorter } from '@libp2p/interface-peer-store'
import type { ComponentMetricsTracker } from '@libp2p/interface-metrics'
const log = logger('libp2p:dialer')

12
src/connection-manager/index.ts
View File

@ -9,14 +9,14 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
import type { Startable } from '@libp2p/interfaces/startable'
import { trackedMap } from '@libp2p/tracked-map'
import { codes } from '../errors.js'
import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id'
import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
import { setMaxListeners } from 'events'
import type { Connection } from '@libp2p/interfaces/connection'
import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
import { Components, Initializable } from '@libp2p/interfaces/components'
import * as STATUS from '@libp2p/interfaces/connection/status'
import type { Connection } from '@libp2p/interface-connection'
import type { ConnectionManager } from '@libp2p/interface-connection-manager'
import { Components, Initializable } from '@libp2p/components'
import * as STATUS from '@libp2p/interface-connection/status'
import { Dialer } from './dialer/index.js'
import type { AddressSorter } from '@libp2p/interfaces/peer-store'
import type { AddressSorter } from '@libp2p/interface-peer-store'
import type { Resolver } from '@multiformats/multiaddr'
const log = logger('libp2p:connection-manager')

4
src/content-routing/index.ts
View File

@ -8,11 +8,11 @@ import {
import drain from 'it-drain'
import merge from 'it-merge'
import { pipe } from 'it-pipe'
import type { ContentRouting } from '@libp2p/interfaces/content-routing'
import type { ContentRouting } from '@libp2p/interface-content-routing'
import type { AbortOptions } from '@libp2p/interfaces'
import type { Startable } from '@libp2p/interfaces/startable'
import type { CID } from 'multiformats/cid'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
export interface CompoundContentRoutingInit {
routers: ContentRouting[]

4
src/content-routing/utils.ts
View File

@ -2,8 +2,8 @@ import errCode from 'err-code'
import filter from 'it-filter'
import map from 'it-map'
import type { Source } from 'it-stream-types'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { PeerStore } from '@libp2p/interfaces/peer-store'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import type { PeerStore } from '@libp2p/interface-peer-store'
/**
* Store the multiaddrs from every peer in the passed peer store

4
src/dht/dht-content-routing.ts
View File

@ -1,7 +1,7 @@
import drain from 'it-drain'
import errCode from 'err-code'
import type { DHT } from '@libp2p/interfaces/dht'
import type { ContentRouting } from '@libp2p/interfaces/content-routing'
import type { DHT } from '@libp2p/interface-dht'
import type { ContentRouting } from '@libp2p/interface-content-routing'
import type { CID } from 'multiformats/cid'
import type { AbortOptions } from '@libp2p/interfaces'

6
src/dht/dht-peer-routing.ts
View File

@ -1,8 +1,8 @@
import errCode from 'err-code'
import { messages, codes } from '../errors.js'
import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
import type { DHT } from '@libp2p/interfaces/dht'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerRouting } from '@libp2p/interface-peer-routing'
import type { DHT } from '@libp2p/interface-dht'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { AbortOptions } from '@libp2p/interfaces'
/**

6
src/dht/dummy-dht.ts
View File

@ -1,9 +1,9 @@
import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interfaces/dht'
import type { PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interface-dht'
import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
import errCode from 'err-code'
import { messages, codes } from '../errors.js'
import { EventEmitter } from '@libp2p/interfaces/events'
import { symbol } from '@libp2p/interfaces/peer-discovery'
import { symbol } from '@libp2p/interface-peer-discovery'
export class DummyDHT extends EventEmitter<PeerDiscoveryEvents> implements DualDHT {
get [symbol] (): true {

8
src/fetch/index.ts
View File

@ -5,11 +5,11 @@ import * as lp from 'it-length-prefixed'
import { FetchRequest, FetchResponse } from './pb/proto.js'
import { handshake } from 'it-handshake'
import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Stream } from '@libp2p/interfaces/connection'
import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
import type { Components } from '@libp2p/interfaces/components'
import type { Stream } from '@libp2p/interface-connection'
import type { IncomingStreamData } from '@libp2p/interface-registrar'
import type { Components } from '@libp2p/components'
import type { AbortOptions } from '@libp2p/interfaces'
import type { Duplex } from 'it-stream-types'
import { abortableDuplex } from 'abortable-iterator'

6
src/get-peer.ts
View File

@ -2,9 +2,9 @@ import { peerIdFromString } from '@libp2p/peer-id'
import { Multiaddr } from '@multiformats/multiaddr'
import errCode from 'err-code'
import { codes } from './errors.js'
import { isPeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import { isPeerId } from '@libp2p/interface-peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { PeerInfo } from '@libp2p/interface-peer-info'
function peerIdFromMultiaddr (ma: Multiaddr) {
const idStr = ma.getPeerId()

36
src/identify/index.ts
View File

@ -18,11 +18,11 @@ import {
MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
} from './consts.js'
import { codes } from '../errors.js'
import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
import type { Connection, Stream } from '@libp2p/interfaces/connection'
import type { IncomingStreamData } from '@libp2p/interface-registrar'
import type { Connection, Stream } from '@libp2p/interface-connection'
import type { Startable } from '@libp2p/interfaces/startable'
import { peerIdFromKeys } from '@libp2p/peer-id'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
import { TimeoutController } from 'timeout-abort-controller'
import type { AbortOptions } from '@libp2p/interfaces'
import { abortableDuplex } from 'abortable-iterator'
@ -79,8 +79,6 @@ export class IdentifyService implements Startable {
this.started = false
this.init = init
this.handleMessage = this.handleMessage.bind(this)
this.identifyProtocolStr = `/${init.protocolPrefix}/${MULTICODEC_IDENTIFY_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PROTOCOL_VERSION}`
this.identifyPushProtocolStr = `/${init.protocolPrefix}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION}`
@ -127,11 +125,13 @@ export class IdentifyService implements Startable {
await this.components.getPeerStore().metadataBook.setValue(this.components.getPeerId(), 'AgentVersion', uint8ArrayFromString(this.host.agentVersion))
await this.components.getPeerStore().metadataBook.setValue(this.components.getPeerId(), 'ProtocolVersion', uint8ArrayFromString(this.host.protocolVersion))
await this.components.getRegistrar().handle([
this.identifyProtocolStr,
this.identifyPushProtocolStr
], (data) => {
void this.handleMessage(data)?.catch(err => {
await this.components.getRegistrar().handle(this.identifyProtocolStr, (data) => {
void this._handleIdentify(data).catch(err => {
log.error(err)
})
})
await this.components.getRegistrar().handle(this.identifyPushProtocolStr, (data) => {
void this._handlePush(data).catch(err => {
log.error(err)
})
})
@ -353,22 +353,6 @@ export class IdentifyService implements Startable {
// this.components.getAddressManager().addObservedAddr(observedAddr)
}
/**
* A handler to register with Libp2p to process identify messages
*/
handleMessage (data: IncomingStreamData) {
const { protocol } = data
switch (protocol) {
case this.identifyProtocolStr:
return this._handleIdentify(data)
case this.identifyPushProtocolStr:
return this._handlePush(data)
default:
log.error('cannot handle unknown protocol %s', protocol)
}
}
/**
* Sends the `Identify` response with the Signed Peer Record
* to the requesting peer over the given `connection`

30
src/index.ts
View File

@ -5,23 +5,23 @@ import type { Startable } from '@libp2p/interfaces/startable'
import type { Multiaddr } from '@multiformats/multiaddr'
import type { FaultTolerance } from './transport-manager.js'
import type { IdentifyServiceInit } from './identify/index.js'
import type { DualDHT } from '@libp2p/interfaces/dht'
import type { DualDHT } from '@libp2p/interface-dht'
import type { Datastore } from 'interface-datastore'
import type { PeerStore, PeerStoreInit } from '@libp2p/interfaces/peer-store'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerStore, PeerStoreInit } from '@libp2p/interface-peer-store'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { AutoRelayConfig, RelayAdvertiseConfig } from './circuit/index.js'
import type { PeerDiscovery } from '@libp2p/interfaces/peer-discovery'
import type { Connection, ConnectionGater, ConnectionProtector, ProtocolStream } from '@libp2p/interfaces/connection'
import type { Transport } from '@libp2p/interfaces/transport'
import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
import type { ContentRouting } from '@libp2p/interfaces/content-routing'
import type { PubSub } from '@libp2p/interfaces/pubsub'
import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
import type { Metrics, MetricsInit } from '@libp2p/interfaces/metrics'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
import type { Connection, ConnectionGater, ConnectionProtector, ProtocolStream } from '@libp2p/interface-connection'
import type { Transport } from '@libp2p/interface-transport'
import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
import type { PeerRouting } from '@libp2p/interface-peer-routing'
import type { ContentRouting } from '@libp2p/interface-content-routing'
import type { PubSub } from '@libp2p/interface-pubsub'
import type { Registrar, StreamHandler } from '@libp2p/interface-registrar'
import type { ConnectionManager } from '@libp2p/interface-connection-manager'
import type { Metrics, MetricsInit } from '@libp2p/interface-metrics'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import type { KeyChain } from './keychain/index.js'
import type { ConnectionManagerInit } from './connection-manager/index.js'
import type { PingServiceInit } from './ping/index.js'

6
src/insecure/index.ts
View File

@ -1,11 +1,11 @@
import { logger } from '@libp2p/logger'
import { handshake } from 'it-handshake'
import * as lp from 'it-length-prefixed'
import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interfaces/connection-encrypter/errors'
import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface-connection-encrypter/errors'
import { Exchange, KeyType } from './pb/proto.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
import type { Duplex } from 'it-stream-types'
const log = logger('libp2p:plaintext')

4
src/keychain/index.ts
View File

@ -10,8 +10,8 @@ import { codes } from '../errors.js'
import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import { generateKeyPair, importKey, unmarshalPrivateKey } from '@libp2p/crypto/keys'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { Components } from '@libp2p/interfaces/components'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Components } from '@libp2p/components'
import { pbkdf2, randomBytes } from '@libp2p/crypto'
const log = logger('libp2p:keychain')

44
src/libp2p.ts
View File

@ -27,25 +27,25 @@ import { DHTPeerRouting } from './dht/dht-peer-routing.js'
import { PersistentPeerStore } from '@libp2p/peer-store'
import { DHTContentRouting } from './dht/dht-content-routing.js'
import { AutoDialer } from './connection-manager/dialer/auto-dialer.js'
import { Initializable, Components, isInitializable } from '@libp2p/interfaces/components'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { Connection } from '@libp2p/interfaces/connection'
import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
import type { ContentRouting } from '@libp2p/interfaces/content-routing'
import type { PubSub } from '@libp2p/interfaces/pubsub'
import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import { Initializable, Components, isInitializable } from '@libp2p/components'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Connection } from '@libp2p/interface-connection'
import type { PeerRouting } from '@libp2p/interface-peer-routing'
import type { ContentRouting } from '@libp2p/interface-content-routing'
import type { PubSub } from '@libp2p/interface-pubsub'
import type { Registrar, StreamHandler } from '@libp2p/interface-registrar'
import type { ConnectionManager } from '@libp2p/interface-connection-manager'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import type { Libp2p, Libp2pEvents, Libp2pInit, Libp2pOptions } from './index.js'
import { validateConfig } from './config.js'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import type { PeerStore } from '@libp2p/interfaces/peer-store'
import type { DualDHT } from '@libp2p/interfaces/dht'
import type { PeerStore } from '@libp2p/interface-peer-store'
import type { DualDHT } from '@libp2p/interface-dht'
import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import errCode from 'err-code'
import { unmarshalPublicKey } from '@libp2p/crypto/keys'
import type { Metrics } from '@libp2p/interfaces/metrics'
import type { Metrics } from '@libp2p/interface-metrics'
import { DummyDHT } from './dht/dummy-dht.js'
import { DummyPubSub } from './pubsub/dummy-pubsub.js'
import { PeerSet } from '@libp2p/peer-collections'
@ -491,11 +491,27 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
}
async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
return await this.components.getRegistrar().handle(protocols, handler)
if (!Array.isArray(protocols)) {
protocols = [protocols]
}
await Promise.all(
protocols.map(async protocol => {
await this.components.getRegistrar().handle(protocol, handler)
})
)
}
async unhandle (protocols: string[] | string): Promise<void> {
return await this.components.getRegistrar().unhandle(protocols)
if (!Array.isArray(protocols)) {
protocols = [protocols]
}
await Promise.all(
protocols.map(async protocol => {
await this.components.getRegistrar().unhandle(protocol)
})
)
}
/**

4
src/metrics/index.ts
View File

@ -3,8 +3,8 @@ import each from 'it-foreach'
import LRU from 'hashlru'
import { METRICS as defaultOptions } from '../constants.js'
import { DefaultStats, StatsInit } from './stats.js'
import type { ComponentMetricsUpdate, Metrics, Stats, TrackStreamOptions } from '@libp2p/interfaces/metrics'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { ComponentMetricsUpdate, Metrics, Stats, TrackStreamOptions } from '@libp2p/interface-metrics'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Duplex } from 'it-stream-types'

2
src/metrics/moving-average.ts
View File

@ -1,4 +1,4 @@
import type { MovingAverage } from '@libp2p/interfaces/metrics'
import type { MovingAverage } from '@libp2p/interface-metrics'
export class DefaultMovingAverage {
public movingAverage: number

2
src/metrics/stats.ts
View File

@ -2,7 +2,7 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
import { createMovingAverage } from './moving-average.js'
// @ts-expect-error no types
import retimer from 'retimer'
import type { MovingAverages, Stats, TransferStats } from '@libp2p/interfaces/metrics'
import type { MovingAverages, Stats, TransferStats } from '@libp2p/interface-metrics'
export interface StatsEvents {
'update': CustomEvent<TransferStats>

2
src/nat-manager.ts
View File

@ -8,7 +8,7 @@ import errCode from 'err-code'
import { codes } from './errors.js'
import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
const log = logger('libp2p:nat')
const DEFAULT_TTL = 7200

2
src/peer-record-updater.ts
View File

@ -1,5 +1,5 @@
import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
import type { Startable } from '@libp2p/interfaces/startable'
import { logger } from '@libp2p/logger'
import { protocols } from '@multiformats/multiaddr'

8
src/peer-routing.ts
View File

@ -18,12 +18,12 @@ import {
// @ts-expect-error module with no types
} from 'set-delayed-interval'
import { setMaxListeners } from 'events'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { PeerRouting } from '@libp2p/interface-peer-routing'
import type { AbortOptions } from '@libp2p/interfaces'
import type { Startable } from '@libp2p/interfaces/startable'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { Components } from '@libp2p/interfaces/components'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import type { Components } from '@libp2p/components'
const log = logger('libp2p:peer-routing')

6
src/ping/index.ts
View File

@ -6,10 +6,10 @@ import { pipe } from 'it-pipe'
import first from 'it-first'
import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
import { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } from './constants.js'
import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { IncomingStreamData } from '@libp2p/interface-registrar'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
import type { AbortOptions } from '@libp2p/interfaces'
import type { Duplex } from 'it-stream-types'
import { abortableDuplex } from 'abortable-iterator'

3
src/pnet/index.ts
View File

@ -12,8 +12,7 @@ import {
} from './crypto.js'
import { handshake } from 'it-handshake'
import { NONCE_LENGTH } from './key-generator.js'
import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
import type { ConnectionProtector } from '@libp2p/interfaces/connection'
import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface-connection'
const log = logger('libp2p:pnet')

4
src/pubsub/dummy-pubsub.ts
View File

@ -1,6 +1,6 @@
import { EventEmitter } from '@libp2p/interfaces/events'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interfaces/pubsub'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interface-pubsub'
import errCode from 'err-code'
import { messages, codes } from '../errors.js'

127
src/registrar.ts
View File

@ -1,30 +1,20 @@
import { logger } from '@libp2p/logger'
import errCode from 'err-code'
import { codes } from './errors.js'
import { isTopology, Topology } from '@libp2p/interfaces/topology'
import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Components } from '@libp2p/interfaces/components'
import { isTopology, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-registrar'
import type { Registrar, StreamHandler, Topology } from '@libp2p/interface-registrar'
import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
import type { Connection } from '@libp2p/interface-connection'
import type { Components } from '@libp2p/components'
const log = logger('libp2p:registrar')
function supportsProtocol (peerProtocols: string[], topologyProtocols: string[]) {
for (const peerProtocol of peerProtocols) {
if (topologyProtocols.includes(peerProtocol)) {
return true
}
}
return false
}
/**
* Responsible for notifying registered protocols of events in the network.
*/
export class DefaultRegistrar implements Registrar {
private readonly topologies: Map<string, { topology: Topology, protocols: string[] }>
private readonly handlers: Map<string, StreamHandler>
private readonly topologies: Map<string, Map<string, Topology>>
private readonly handlers: Map<string, StreamHandlerRecord>
private readonly components: Components
constructor (components: Components) {
@ -42,17 +32,10 @@ export class DefaultRegistrar implements Registrar {
}
getProtocols () {
const protocols = new Set<string>()
for (const topology of this.topologies.values()) {
topology.protocols.forEach(protocol => protocols.add(protocol))
}
for (const protocol of this.handlers.keys()) {
protocols.add(protocol)
}
return Array.from(protocols).sort()
return Array.from(new Set<string>([
...this.topologies.keys(),
...this.handlers.keys()
])).sort()
}
getHandler (protocol: string) {
@ -66,33 +49,32 @@ export class DefaultRegistrar implements Registrar {
}
getTopologies (protocol: string) {
const output: Topology[] = []
const topologies = this.topologies.get(protocol)
for (const { topology, protocols } of this.topologies.values()) {
if (protocols.includes(protocol)) {
output.push(topology)
}
if (topologies == null) {
return []
}
return output
return [
...topologies.values()
]
}
/**
* Registers the `handler` for each protocol
*/
async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
const protocolList = Array.isArray(protocols) ? protocols : [protocols]
for (const protocol of protocolList) {
if (this.handlers.has(protocol)) {
throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
}
this.handlers.set(protocol, handler)
async handle (protocol: string, handler: StreamHandler, options: StreamHandlerOptions = { maxConcurrentStreams: 1 }): Promise<void> {
if (this.handlers.has(protocol)) {
throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
}
this.handlers.set(protocol, {
handler,
options
})
// Add new protocols to self protocols in the Protobook
await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), protocolList)
await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), [protocol])
}
/**
@ -113,7 +95,7 @@ export class DefaultRegistrar implements Registrar {
/**
* Register handlers for a set of multicodecs given
*/
async register (protocols: string | string[], topology: Topology): Promise<string> {
async register (protocol: string, topology: Topology): Promise<string> {
if (!isTopology(topology)) {
log.error('topology must be an instance of interfaces/topology')
throw errCode(new Error('topology must be an instance of interfaces/topology'), codes.ERR_INVALID_PARAMETERS)
@ -122,10 +104,14 @@ export class DefaultRegistrar implements Registrar {
// Create topology
const id = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
this.topologies.set(id, {
topology,
protocols: Array.isArray(protocols) ? protocols : [protocols]
})
let topologies = this.topologies.get(protocol)
if (topologies == null) {
topologies = new Map<string, Topology>()
this.topologies.set(protocol, topologies)
}
topologies.set(id, topology)
// Set registrar
await topology.setRegistrar(this)
@ -137,7 +123,15 @@ export class DefaultRegistrar implements Registrar {
* Unregister topology
*/
unregister (id: string) {
this.topologies.delete(id)
for (const [protocol, topologies] of this.topologies.entries()) {
if (topologies.has(id)) {
topologies.delete(id)
if (topologies.size === 0) {
this.topologies.delete(protocol)
}
}
}
}
/**
@ -148,8 +142,15 @@ export class DefaultRegistrar implements Registrar {
void this.components.getPeerStore().protoBook.get(connection.remotePeer)
.then(peerProtocols => {
for (const { topology, protocols } of this.topologies.values()) {
if (supportsProtocol(peerProtocols, protocols)) {
for (const protocol of peerProtocols) {
const topologies = this.topologies.get(protocol)
if (topologies == null) {
// no topologies are interested in this protocol
continue
}
for (const topology of topologies.values()) {
topology.onDisconnect(connection.remotePeer)
}
}
@ -168,14 +169,28 @@ export class DefaultRegistrar implements Registrar {
const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
for (const { topology, protocols } of this.topologies.values()) {
if (supportsProtocol(removed, protocols)) {
for (const protocol of removed) {
const topologies = this.topologies.get(protocol)
if (topologies == null) {
// no topologies are interested in this protocol
continue
}
for (const topology of topologies.values()) {
topology.onDisconnect(peerId)
}
}
for (const { topology, protocols } of this.topologies.values()) {
if (supportsProtocol(added, protocols)) {
for (const protocol of added) {
const topologies = this.topologies.get(protocol)
if (topologies == null) {
// no topologies are interested in this protocol
continue
}
for (const topology of topologies.values()) {
const connection = this.components.getConnectionManager().getConnections(peerId)[0]
if (connection == null) {

6
src/transport-manager.ts
View File

@ -2,13 +2,13 @@ import { logger } from '@libp2p/logger'
import pSettle from 'p-settle'
import { codes } from './errors.js'
import errCode from 'err-code'
import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interfaces/transport'
import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interface-transport'
import type { Multiaddr } from '@multiformats/multiaddr'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import type { AbortOptions } from '@libp2p/interfaces'
import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
import type { Startable } from '@libp2p/interfaces/startable'
import type { Components } from '@libp2p/interfaces/components'
import type { Components } from '@libp2p/components'
import { trackedMap } from '@libp2p/tracked-map'
const log = logger('libp2p:transports')

20
src/upgrader.ts
View File

@ -8,13 +8,13 @@ import { codes } from './errors.js'
import { createConnection } from '@libp2p/connection'
import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
import { peerIdFromString } from '@libp2p/peer-id'
import type { Connection, ProtocolStream, Stream } from '@libp2p/interfaces/connection'
import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { MultiaddrConnection, Upgrader, UpgraderEvents } from '@libp2p/interfaces/transport'
import type { MultiaddrConnection, Connection, ProtocolStream, Stream } from '@libp2p/interface-connection'
import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Upgrader, UpgraderEvents } from '@libp2p/interface-transport'
import type { Duplex } from 'it-stream-types'
import type { Components } from '@libp2p/interfaces/components'
import { Components, isInitializable } from '@libp2p/components'
import type { AbortOptions } from '@libp2p/interfaces'
const log = logger('libp2p:upgrader')
@ -272,7 +272,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
if (muxerFactory != null) {
// Create the muxer
muxer = muxerFactory.createStreamMuxer(this.components, {
muxer = muxerFactory.createStreamMuxer({
// Run anytime a remote stream is created
onIncomingStream: muxedStream => {
if (connection == null) {
@ -313,6 +313,10 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
}
})
if (isInitializable(muxer)) {
muxer.init(this.components)
}
newStream = async (protocols: string[], options: AbortOptions = {}): Promise<ProtocolStream> => {
if (muxer == null) {
throw errCode(new Error('Stream is not multiplexed'), codes.ERR_MUXER_UNAVAILABLE)
@ -417,7 +421,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
*/
_onStream (opts: OnStreamOptions): void {
const { connection, stream, protocol } = opts
const handler = this.components.getRegistrar().getHandler(protocol)
const { handler } = this.components.getRegistrar().getHandler(protocol)
handler({ connection, stream, protocol })
}

6
test/addresses/address-manager.spec.ts
View File

@ -7,10 +7,10 @@ import { createNode } from '../utils/creators/peer.js'
import { createFromJSON } from '@libp2p/peer-id-factory'
import Peers from '../fixtures/peers.js'
import { stubInterface } from 'ts-sinon'
import type { TransportManager } from '@libp2p/interfaces/transport'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { TransportManager } from '@libp2p/interface-transport'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Libp2p } from '../../src/index.js'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
const listenAddresses = ['/ip4/127.0.0.1/tcp/15006/ws', '/ip4/127.0.0.1/tcp/15008/ws']
const announceAddreses = ['/dns4/peer.io']

2
test/configuration/pubsub.spec.ts
View File

@ -9,7 +9,7 @@ import { baseOptions, pubsubSubsystemOptions } from './utils.js'
import { createPeerId } from '../utils/creators/peer.js'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import { FloodSub } from '@libp2p/floodsub'
import type { PubSub } from '@libp2p/interfaces/pubsub'
import type { PubSub } from '@libp2p/interface-pubsub'
describe('Pubsub subsystem is configurable', () => {
let libp2p: Libp2p

4
test/configuration/utils.ts
View File

@ -5,9 +5,9 @@ import { WebSockets } from '@libp2p/websockets'
import * as filters from '@libp2p/websockets/filters'
import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
import mergeOptions from 'merge-options'
import type { Message, PublishResult, PubSubInit, PubSubRPC, PubSubRPCMessage } from '@libp2p/interfaces/pubsub'
import type { Message, PublishResult, PubSubInit, PubSubRPC, PubSubRPCMessage } from '@libp2p/interface-pubsub'
import type { Libp2pInit, Libp2pOptions } from '../../src/index.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import * as cborg from 'cborg'
import { peerIdFromString } from '@libp2p/peer-id'

6
test/connection-manager/auto-dialler.spec.ts
View File

@ -5,10 +5,10 @@ import { AutoDialler } from '../../src/connection-manager/auto-dialler.js'
import pWaitFor from 'p-wait-for'
import delay from 'delay'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { stubInterface } from 'ts-sinon'
import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
import type { PeerStore, Peer } from '@libp2p/interfaces/peer-store'
import type { ConnectionManager } from '@libp2p/interface-connection-manager'
import type { PeerStore, Peer } from '@libp2p/interface-peer-store'
describe('Auto-dialler', () => {
it('should not dial self', async () => {

12
test/connection-manager/index.node.ts
View File

@ -2,19 +2,19 @@
import { expect } from 'aegir/chai'
import { createNode, createPeerId } from '../utils/creators/peer.js'
import { mockConnection, mockDuplex, mockMultiaddrConnection, mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnection, mockDuplex, mockMultiaddrConnection, mockUpgrader } from '@libp2p/interface-mocks'
import { createBaseOptions } from '../utils/base-options.browser.js'
import type { Libp2p } from '../../src/index.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { CustomEvent } from '@libp2p/interfaces/events'
import * as STATUS from '@libp2p/interfaces/connection/status'
import * as STATUS from '@libp2p/interface-connection/status'
import { stubInterface } from 'ts-sinon'
import type { KeyBook, PeerStore } from '@libp2p/interfaces/peer-store'
import type { KeyBook, PeerStore } from '@libp2p/interface-peer-store'
import sinon from 'sinon'
import pWaitFor from 'p-wait-for'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import delay from 'delay'
import type { Libp2pNode } from '../../src/libp2p.js'
import { codes } from '../../src/errors.js'

2
test/connection-manager/index.spec.ts
View File

@ -6,7 +6,7 @@ import { createNode } from '../utils/creators/peer.js'
import { createBaseOptions } from '../utils/base-options.browser.js'
import type { Libp2pNode } from '../../src/libp2p.js'
import type { DefaultConnectionManager } from '../../src/connection-manager/index.js'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import { CustomEvent } from '@libp2p/interfaces/events'

2
test/content-routing/content-routing.node.ts
View File

@ -14,7 +14,7 @@ import { createNode, createPeerId, populateAddressBooks } from '../utils/creator
import { createBaseOptions } from '../utils/base-options.js'
import { createRoutingOptions } from './utils.js'
import type { Libp2p } from '../../src/index.js'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import type { Libp2pNode } from '../../src/libp2p.js'
describe('content-routing', () => {

2
test/content-routing/dht/operation.node.ts
View File

@ -6,7 +6,7 @@ import pWaitFor from 'p-wait-for'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import { subsystemMulticodecs, createSubsystemOptions } from './utils.js'
import { createPeerId } from '../../utils/creators/peer.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createLibp2pNode, Libp2pNode } from '../../../src/libp2p.js'
import { start } from '@libp2p/interfaces/startable'

2
test/core/encryption.spec.ts
View File

@ -6,7 +6,7 @@ import { NOISE } from '@chainsafe/libp2p-noise'
import { createLibp2p, Libp2pOptions } from '../../src/index.js'
import { codes as ErrorCodes } from '../../src/errors.js'
import { createPeerId } from '../utils/creators/peer.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
describe('Connection encryption configuration', () => {
let peerId: PeerId

2
test/core/listening.node.ts
View File

@ -4,7 +4,7 @@ import { expect } from 'aegir/chai'
import { TCP } from '@libp2p/tcp'
import { NOISE } from '@chainsafe/libp2p-noise'
import { createPeerId } from '../utils/creators/peer.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
const listenAddr = '/ip4/0.0.0.0/tcp/0'

2
test/dialing/dial-request.spec.ts
View File

@ -6,7 +6,7 @@ import { AbortError } from '@libp2p/interfaces/errors'
import pDefer from 'p-defer'
import delay from 'delay'
import { DialAction, DialRequest } from '../../src/connection-manager/dialer/dial-request.js'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import { Multiaddr } from '@multiformats/multiaddr'
import { Dialer } from '../../src/connection-manager/dialer/index.js'

10
test/dialing/direct.node.ts
View File

@ -13,7 +13,7 @@ import pSettle, { PromiseResult } from 'p-settle'
import pWaitFor from 'p-wait-for'
import { pipe } from 'it-pipe'
import { pushable } from 'it-pushable'
import { Connection, isConnection } from '@libp2p/interfaces/connection'
import { Connection, isConnection } from '@libp2p/interface-connection'
import { AbortError } from '@libp2p/interfaces/errors'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import { MemoryDatastore } from 'datastore-core/memory'
@ -22,11 +22,11 @@ import { DefaultAddressManager } from '../../src/address-manager/index.js'
import { PersistentPeerStore } from '@libp2p/peer-store'
import { DefaultTransportManager } from '../../src/transport-manager.js'
import { codes as ErrorCodes } from '../../src/errors.js'
import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-mocks'
import Peers from '../fixtures/peers.js'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { createFromJSON } from '@libp2p/peer-id-factory'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
import { PreSharedKeyConnectionProtector } from '../../src/pnet/index.js'
import swarmKey from '../fixtures/swarm.key.js'
@ -382,7 +382,7 @@ describe('libp2p.dialer (direct, TCP)', () => {
await libp2p.dialProtocol(remoteLibp2p.peerId, '/stream-count/4')
// Partially write to the echo stream
const source = pushable<Uint8Array>()
const source = pushable()
void stream.sink(source)
source.push(uint8ArrayFromString('hello'))

10
test/dialing/direct.spec.ts
View File

@ -17,18 +17,18 @@ import { Dialer, DialTarget } from '../../src/connection-manager/dialer/index.js
import { publicAddressesFirst } from '@libp2p/utils/address-sort'
import { PersistentPeerStore } from '@libp2p/peer-store'
import { DefaultTransportManager } from '../../src/transport-manager.js'
import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-mocks'
import { createPeerId } from '../utils/creators/peer.js'
import type { TransportManager } from '@libp2p/interfaces/transport'
import { Components } from '@libp2p/interfaces/components'
import type { TransportManager } from '@libp2p/interface-transport'
import { Components } from '@libp2p/components'
import { peerIdFromString } from '@libp2p/peer-id'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
import { createFromJSON } from '@libp2p/peer-id-factory'
import Peers from '../fixtures/peers.js'
import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { pEvent } from 'p-event'
const unsupportedAddr = new Multiaddr('/ip4/127.0.0.1/tcp/9999')

4
test/dialing/resolver.spec.ts
View File

@ -7,11 +7,11 @@ import { codes as ErrorCodes } from '../../src/errors.js'
import { createNode } from '../utils/creators/peer.js'
import { createBaseOptions } from '../utils/base-options.browser.js'
import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Libp2pNode } from '../../src/libp2p.js'
import { Circuit } from '../../src/circuit/transport.js'
import pDefer from 'p-defer'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
import { peerIdFromString } from '@libp2p/peer-id'
import { WebSockets } from '@libp2p/websockets'

2
test/fetch/fetch.node.ts
View File

@ -7,7 +7,7 @@ import { Mplex } from '@libp2p/mplex'
import { NOISE } from '@chainsafe/libp2p-noise'
import { createPeerId } from '../utils/creators/peer.js'
import { codes } from '../../src/errors.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
async function createNode (peerId: PeerId) {
return await createLibp2pNode({

4
test/fetch/index.spec.ts
View File

@ -4,9 +4,9 @@ import { expect } from 'aegir/chai'
import sinon from 'sinon'
import { FetchService } from '../../src/fetch/index.js'
import Peers from '../fixtures/peers.js'
import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
import { start, stop } from '@libp2p/interfaces/startable'
import { CustomEvent } from '@libp2p/interfaces/events'

4
test/identify/index.spec.ts
View File

@ -14,9 +14,9 @@ import { MemoryDatastore } from 'datastore-core/memory'
import * as lp from 'it-length-prefixed'
import drain from 'it-drain'
import { pipe } from 'it-pipe'
import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { PeerRecordUpdater } from '../../src/peer-record-updater.js'
import {
MULTICODEC_IDENTIFY,

4
test/identify/push.spec.ts
View File

@ -10,9 +10,9 @@ import { DefaultAddressManager } from '../../src/address-manager/index.js'
import { MemoryDatastore } from 'datastore-core/memory'
import drain from 'it-drain'
import { pipe } from 'it-pipe'
import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnectionGater, mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { PeerRecordUpdater } from '../../src/peer-record-updater.js'
import {
MULTICODEC_IDENTIFY,

2
test/identify/service.spec.ts
View File

@ -11,7 +11,7 @@ import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
import { createFromJSON } from '@libp2p/peer-id-factory'
import pWaitFor from 'p-wait-for'
import { peerIdFromString } from '@libp2p/peer-id'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import type { Libp2pNode } from '../../src/libp2p.js'
import { pEvent } from 'p-event'

2
test/insecure/compliance.spec.ts
View File

@ -1,6 +1,6 @@
/* eslint-env mocha */
import suite from '@libp2p/interface-compliance-tests/connection-encrypter'
import suite from '@libp2p/interface-connection-encrypter-compliance-tests'
import { Plaintext } from '../../src/insecure/index.js'
describe('plaintext compliance', () => {

8
test/insecure/plaintext.spec.ts
View File

@ -7,11 +7,11 @@ import { Plaintext } from '../../src/insecure/index.js'
import {
InvalidCryptoExchangeError,
UnexpectedPeerError
} from '@libp2p/interfaces/connection-encrypter/errors'
import type { PeerId } from '@libp2p/interfaces/peer-id'
} from '@libp2p/interface-connection-encrypter/errors'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createFromJSON, createRSAPeerId } from '@libp2p/peer-id-factory'
import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
import { mockMultiaddrConnPair } from '@libp2p/interface-compliance-tests/mocks'
import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
import { mockMultiaddrConnPair } from '@libp2p/interface-mocks'
import { Multiaddr } from '@multiformats/multiaddr'
import { peerIdFromBytes } from '@libp2p/peer-id'

2
test/interop.ts
View File

@ -14,7 +14,7 @@ import { logger } from '@libp2p/logger'
import { Mplex } from '@libp2p/mplex'
import fs from 'fs'
import { unmarshalPrivateKey } from '@libp2p/crypto/keys'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { peerIdFromKeys } from '@libp2p/peer-id'
import { FloodSub } from '@libp2p/floodsub'

2
test/keychain/cms-interop.spec.ts
View File

@ -6,7 +6,7 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
import { MemoryDatastore } from 'datastore-core/memory'
import { KeyChain } from '../../src/keychain/index.js'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
describe('cms interop', () => {
const passPhrase = 'this is not a secure phrase'

4
test/keychain/keychain.spec.ts
View File

@ -9,9 +9,9 @@ import { Key } from 'interface-datastore/key'
import { MemoryDatastore } from 'datastore-core/memory'
import { KeyChain, KeyChainInit, KeyInfo } from '../../src/keychain/index.js'
import { pbkdf2 } from '@libp2p/crypto'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import type { Datastore } from 'interface-datastore'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createFromPrivKey } from '@libp2p/peer-id-factory'
import { unmarshalPrivateKey } from '@libp2p/crypto/keys'

2
test/keychain/peerid.spec.ts
View File

@ -4,7 +4,7 @@ import { expect } from 'aegir/chai'
import { base58btc } from 'multiformats/bases/base58'
import { supportedKeys, unmarshalPrivateKey, unmarshalPublicKey } from '@libp2p/crypto/keys'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createFromPrivKey } from '@libp2p/peer-id-factory'
const sample = {

4
test/metrics/index.spec.ts
View File

@ -14,7 +14,7 @@ import { createPeerId } from '../utils/creators/peer.js'
import toBuffer from 'it-to-buffer'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import { peerIdFromString } from '@libp2p/peer-id'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
describe('Metrics', () => {
let peerId: PeerId
@ -199,7 +199,7 @@ describe('Metrics', () => {
})
const bytes = randomBytes(1024)
const input = pushable<Uint8Array>()
const input = pushable()
const deferredPromise = pipe(input, local, drain)

4
test/nat-manager/nat-manager.node.ts
View File

@ -4,13 +4,13 @@ import { expect } from 'aegir/chai'
import { DefaultAddressManager } from '../../src/address-manager/index.js'
import { DefaultTransportManager, FaultTolerance } from '../../src/transport-manager.js'
import { TCP } from '@libp2p/tcp'
import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
import { mockUpgrader } from '@libp2p/interface-mocks'
import { NatManager } from '../../src/nat-manager.js'
import delay from 'delay'
import Peers from '../fixtures/peers.js'
import { codes } from '../../src/errors.js'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import type { NatAPI } from '@achingbrain/nat-port-mapper'
import { StubbedInstance, stubInterface } from 'ts-sinon'
import { start, stop } from '@libp2p/interfaces/startable'

4
test/peer-discovery/index.node.ts
View File

@ -11,10 +11,10 @@ import { Multiaddr } from '@multiformats/multiaddr'
import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
import { createBaseOptions } from '../utils/base-options.js'
import { createPeerId } from '../utils/creators/peer.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
import { CustomEvent } from '@libp2p/interfaces/events'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { PeerInfo } from '@libp2p/interface-peer-info'
const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')

4
test/peer-discovery/index.spec.ts
View File

@ -6,9 +6,9 @@ import defer from 'p-defer'
import { Multiaddr } from '@multiformats/multiaddr'
import { createBaseOptions } from '../utils/base-options.browser.js'
import { createPeerId } from '../utils/creators/peer.js'
import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id'
import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-mocks'
import type { Startable } from '@libp2p/interfaces/startable'
describe('peer discovery', () => {

6
test/peer-routing/peer-routing.node.ts
View File

@ -16,11 +16,11 @@ import { createNode, createPeerId, populateAddressBooks } from '../utils/creator
import type { Libp2pNode } from '../../src/libp2p.js'
import { createBaseOptions } from '../utils/base-options.js'
import { createRoutingOptions } from './utils.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import { EventTypes, MessageType } from '@libp2p/interfaces/dht'
import { EventTypes, MessageType } from '@libp2p/interface-dht'
import { peerIdFromString } from '@libp2p/peer-id'
import type { PeerInfo } from '@libp2p/interfaces/peer-info'
import type { PeerInfo } from '@libp2p/interface-peer-info'
import { KadDHT } from '@libp2p/kad-dht'
describe('peer-routing', () => {

4
test/ping/index.spec.ts
View File

@ -4,9 +4,9 @@ import { expect } from 'aegir/chai'
import sinon from 'sinon'
import { PingService } from '../../src/ping/index.js'
import Peers from '../fixtures/peers.js'
import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-compliance-tests/mocks'
import { mockRegistrar, mockUpgrader, connectionPair } from '@libp2p/interface-mocks'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
import { start, stop } from '@libp2p/interfaces/startable'
import { CustomEvent } from '@libp2p/interfaces/events'

2
test/pnet/index.spec.ts
View File

@ -5,7 +5,7 @@ import all from 'it-all'
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import { PreSharedKeyConnectionProtector, generateKey } from '../../src/pnet/index.js'
import { INVALID_PSK } from '../../src/pnet/errors.js'
import { mockMultiaddrConnPair } from '@libp2p/interface-compliance-tests/mocks'
import { mockMultiaddrConnPair } from '@libp2p/interface-mocks'
import { Multiaddr } from '@multiformats/multiaddr'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'

18
test/registrar/registrar.spec.ts
View File

@ -6,21 +6,21 @@ import { MemoryDatastore } from 'datastore-core/memory'
import { createTopology } from '@libp2p/topology'
import { PersistentPeerStore } from '@libp2p/peer-store'
import { DefaultRegistrar } from '../../src/registrar.js'
import { mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-compliance-tests/mocks'
import { mockDuplex, mockMultiaddrConnection, mockUpgrader, mockConnection } from '@libp2p/interface-mocks'
import { createPeerId, createNode } from '../utils/creators/peer.js'
import { createBaseOptions } from '../utils/base-options.browser.js'
import type { Registrar } from '@libp2p/interfaces/registrar'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import { Components } from '@libp2p/interfaces/components'
import type { Registrar } from '@libp2p/interface-registrar'
import type { PeerId } from '@libp2p/interface-peer-id'
import { Components } from '@libp2p/components'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
import { CustomEvent } from '@libp2p/interfaces/events'
import type { Connection } from '@libp2p/interfaces/connection'
import type { Connection } from '@libp2p/interface-connection'
import { DefaultConnectionManager } from '../../src/connection-manager/index.js'
import { Plaintext } from '../../src/insecure/index.js'
import { WebSockets } from '@libp2p/websockets'
import { Mplex } from '@libp2p/mplex'
import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
const protocol = '/test/1.0.0'
@ -238,12 +238,12 @@ describe('registrar', () => {
const echoHandler = () => {}
await libp2p.handle(['/echo/1.0.0', '/echo/1.0.1'], echoHandler)
expect(registrar.getHandler('/echo/1.0.0')).to.equal(echoHandler)
expect(registrar.getHandler('/echo/1.0.1')).to.equal(echoHandler)
expect(registrar.getHandler('/echo/1.0.0')).to.have.property('handler', echoHandler)
expect(registrar.getHandler('/echo/1.0.1')).to.have.property('handler', echoHandler)
await libp2p.unhandle(['/echo/1.0.0'])
expect(registrar.getProtocols()).to.not.have.any.keys(['/echo/1.0.0'])
expect(registrar.getHandler('/echo/1.0.1')).to.equal(echoHandler)
expect(registrar.getHandler('/echo/1.0.1')).to.have.property('handler', echoHandler)
})
})
})

6
test/transports/transport-manager.node.ts
View File

@ -8,13 +8,13 @@ import { PersistentPeerStore } from '@libp2p/peer-store'
import { PeerRecord } from '@libp2p/peer-record'
import { TCP } from '@libp2p/tcp'
import { Multiaddr } from '@multiformats/multiaddr'
import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
import { mockUpgrader } from '@libp2p/interface-mocks'
import sinon from 'sinon'
import Peers from '../fixtures/peers.js'
import pWaitFor from 'p-wait-for'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { PeerRecordUpdater } from '../../src/peer-record-updater.js'
const addrs = [

6
test/transports/transport-manager.spec.ts
View File

@ -8,13 +8,13 @@ import * as filters from '@libp2p/websockets/filters'
import { NOISE } from '@chainsafe/libp2p-noise'
import { DefaultAddressManager } from '../../src/address-manager/index.js'
import { DefaultTransportManager, FaultTolerance } from '../../src/transport-manager.js'
import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
import { mockUpgrader } from '@libp2p/interface-mocks'
import { MULTIADDRS_WEBSOCKETS } from '../fixtures/browser.js'
import { codes as ErrorCodes } from '../../src/errors.js'
import Peers from '../fixtures/peers.js'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { createEd25519PeerId, createFromJSON } from '@libp2p/peer-id-factory'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')

16
test/upgrading/upgrader.spec.ts
View File

@ -14,16 +14,16 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
import swarmKey from '../fixtures/swarm.key.js'
import { DefaultUpgrader } from '../../src/upgrader.js'
import { codes } from '../../src/errors.js'
import { mockConnectionGater, mockMultiaddrConnPair, mockRegistrar, mockStream } from '@libp2p/interface-compliance-tests/mocks'
import { mockConnectionGater, mockMultiaddrConnPair, mockRegistrar, mockStream } from '@libp2p/interface-mocks'
import Peers from '../fixtures/peers.js'
import type { Upgrader } from '@libp2p/interfaces/transport'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { Upgrader } from '@libp2p/interface-transport'
import type { PeerId } from '@libp2p/interface-peer-id'
import { createFromJSON } from '@libp2p/peer-id-factory'
import { Components } from '@libp2p/interfaces/components'
import { Components } from '@libp2p/components'
import { Plaintext } from '../../src/insecure/index.js'
import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
import type { Stream } from '@libp2p/interfaces/connection'
import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface-stream-muxer'
import type { Stream } from '@libp2p/interface-connection'
import pDefer from 'p-defer'
import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
import { pEvent } from 'p-event'
@ -248,7 +248,7 @@ describe('Upgrader', () => {
class OtherMuxerFactory implements StreamMuxerFactory {
protocol = '/muxer-local'
createStreamMuxer (components: Components, init?: StreamMuxerInit): StreamMuxer {
createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
return new OtherMuxer()
}
}

2
test/utils/creators/peer.ts
View File

@ -4,7 +4,7 @@ import { createBaseOptions } from '../base-options.browser.js'
import { createEd25519PeerId, createFromJSON, createRSAPeerId } from '@libp2p/peer-id-factory'
import { createLibp2pNode, Libp2pNode } from '../../../src/libp2p.js'
import type { AddressesConfig, Libp2pOptions } from '../../../src/index.js'
import type { PeerId } from '@libp2p/interfaces/peer-id'
import type { PeerId } from '@libp2p/interface-peer-id'
const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')