@helia/bitswap 0.0.0-329652a

package/dist/src/index.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @packageDocumentation
+ *
+ * This module implements the [Bitswap protocol](https://docs.ipfs.tech/concepts/bitswap/) in TypeScript.
+ *
+ * It supersedes the older [ipfs-bitswap](https://www.npmjs.com/package/ipfs-bitswap) module with the aim of being smaller, faster, better integrated with libp2p/helia, having fewer dependencies and using standard JavaScript instead of Node.js APIs.
+ */
+import type { BitswapNetworkNotifyProgressEvents, BitswapNetworkWantProgressEvents } from './network.js';
+import type { WantType } from './pb/message.js';
+import type { CreateSessionOptions } from '@helia/interface';
+import type { Routing } from '@helia/interface/routing';
+import type { Libp2p, AbortOptions, Startable, ComponentLogger, Metrics, PeerId } from '@libp2p/interface';
+import type { PeerSet } from '@libp2p/peer-collections';
+import type { Blockstore } from 'interface-blockstore';
+import type { CID } from 'multiformats/cid';
+import type { MultihashHasher } from 'multiformats/hashes/interface';
+import type { ProgressEvent, ProgressOptions } from 'progress-events';
+export type BitswapWantProgressEvents = BitswapWantBlockProgressEvents;
+export type BitswapNotifyProgressEvents = BitswapNetworkNotifyProgressEvents;
+export type BitswapWantBlockProgressEvents = ProgressEvent<'bitswap:want-block:unwant', CID> | ProgressEvent<'bitswap:want-block:block', CID> | BitswapNetworkWantProgressEvents;
+/**
+ * A bitswap session is a network overlay consisting of peers that all have the
+ * first block in a file. Subsequent requests will only go to these peers.
+ */
+export interface BitswapSession {
+    /**
+     * The peers in this session
+     */
+    peers: PeerSet;
+    /**
+     * Fetch an additional CID from this DAG
+     */
+    want(cid: CID, options?: AbortOptions & ProgressOptions<BitswapWantProgressEvents>): Promise<Uint8Array>;
+}
+export interface WantListEntry {
+    cid: CID;
+    priority: number;
+    wantType: WantType;
+}
+export interface CreateBitswapSessionOptions extends CreateSessionOptions<BitswapWantProgressEvents> {
+    /**
+     * If true, query connected peers before searching for providers via
+     * Helia routers
+     *
+     * @default true
+     */
+    queryConnectedPeers?: boolean;
+    /**
+     * If true, search for providers via Helia routers to query for the root CID
+     *
+     * @default true
+     */
+    queryRoutingPeers?: boolean;
+    /**
+     * The priority to use when querying availability of the root CID
+     *
+     * @default 1
+     */
+    priority?: number;
+}
+export interface Bitswap extends Startable {
+    /**
+     * Returns the current state of the wantlist
+     */
+    getWantlist(): WantListEntry[];
+    /**
+     * Returns the current state of the wantlist for a peer, if it is being
+     * tracked
+     */
+    getPeerWantlist(peerId: PeerId): WantListEntry[] | undefined;
+    /**
+     * Notify bitswap that a new block is available
+     */
+    notify(cid: CID, block: Uint8Array, options?: ProgressOptions<BitswapNotifyProgressEvents>): Promise<void>;
+    /**
+     * Start a session to retrieve a file from the network
+     */
+    want(cid: CID, options?: AbortOptions & ProgressOptions<BitswapWantProgressEvents>): Promise<Uint8Array>;
+    /**
+     * Start a session to retrieve a file from the network
+     */
+    createSession(root: CID, options?: AbortOptions & ProgressOptions<BitswapWantProgressEvents>): Promise<BitswapSession>;
+}
+export interface MultihashHasherLoader {
+    getHasher(codeOrName: number | string): Promise<MultihashHasher>;
+}
+export interface BitswapComponents {
+    routing: Routing;
+    blockstore: Blockstore;
+    logger: ComponentLogger;
+    libp2p: Libp2p;
+    metrics?: Metrics;
+}
+export interface BitswapOptions {
+    /**
+     * This is the maximum number of concurrent inbound bitswap streams that are
+     * allowed
+     *
+     * @default 32
+     */
+    maxInboundStreams?: number;
+    /**
+     * This is the maximum number of concurrent outbound bitswap streams that are
+     * allowed
+     *
+     * @default 128
+     */
+    maxOutboundStreams?: number;
+    /**
+     * An incoming stream must resolve within this number of seconds
+     *
+     * @default 30000
+     */
+    incomingStreamTimeout?: number;
+    /**
+     * Whether to run on transient (e.g. time/data limited) connections
+     *
+     * @default false
+     */
+    runOnTransientConnections?: boolean;
+    /**
+     * Enables loading esoteric hash functions
+     */
+    hashLoader?: MultihashHasherLoader;
+    /**
+     * The protocol that we speak
+     *
+     * @default '/ipfs/bitswap/1.2.0'
+     */
+    protocol?: string;
+    /**
+     * When a new peer connects, sending our WantList should complete within this
+     * many ms
+     *
+     * @default 5000
+     */
+    messageSendTimeout?: number;
+    /**
+     * When sending want list updates to peers, how many messages to send at once
+     *
+     * @default 50
+     */
+    messageSendConcurrency?: number;
+    /**
+     * When sending blocks to peers, how many messages to send at once
+     *
+     * @default 50
+     */
+    sendBlocksConcurrency?: number;
+    /**
+     * When sending blocks to peers, timeout after this many milliseconds.
+     * This is useful for preventing slow/large peer-connections from consuming
+     * your bandwidth/streams.
+     *
+     * @default 10000
+     */
+    sendBlocksTimeout?: number;
+    /**
+     * When a block is added to the blockstore and we are about to send that block
+     * to peers who have it in their wantlist, wait this many milliseconds before
+     * queueing the send job in case more blocks are added that they want
+     *
+     * @default 10
+     */
+    sendBlocksDebounce?: number;
+    /**
+     * If the client sends a want-have, and we have the corresponding block, we
+     * check the size of the block and if it's small enough we send the block
+     * itself, rather than sending a HAVE.
+     *
+     * This defines the maximum size up to which we replace a HAVE with a block.
+     *
+     * @default 1024
+     */
+    maxSizeReplaceHasWithBlock?: number;
+}
+export declare const createBitswap: (components: BitswapComponents, options?: BitswapOptions) => Bitswap;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/src/index.js

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ *
+ * This module implements the [Bitswap protocol](https://docs.ipfs.tech/concepts/bitswap/) in TypeScript.
+ *
+ * It supersedes the older [ipfs-bitswap](https://www.npmjs.com/package/ipfs-bitswap) module with the aim of being smaller, faster, better integrated with libp2p/helia, having fewer dependencies and using standard JavaScript instead of Node.js APIs.
+ */
+import { Bitswap as BitswapClass } from './bitswap.js';
+export const createBitswap = (components, options = {}) => {
+    return new BitswapClass(components, options);
+};
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,cAAc,CAAA;AA4MtD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,UAA6B,EAAE,UAA0B,EAAE,EAAW,EAAE;IACpG,OAAO,IAAI,YAAY,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;AAC9C,CAAC,CAAA"}

package/dist/src/network.d.ts

@@ -0,0 +1,84 @@
+import { TypedEventEmitter } from '@libp2p/interface';
+import { CID } from 'multiformats/cid';
+import { BitswapMessage } from './pb/message.js';
+import type { WantOptions } from './bitswap.js';
+import type { MultihashHasherLoader } from './index.js';
+import type { Block } from './pb/message.js';
+import type { Provider, Routing } from '@helia/interface/routing';
+import type { Libp2p, AbortOptions, Connection, PeerId, IncomingStreamData, ComponentLogger, Metrics } from '@libp2p/interface';
+import type { ProgressEvent, ProgressOptions } from 'progress-events';
+export type BitswapNetworkProgressEvents = ProgressEvent<'bitswap:network:dial', PeerId>;
+export type BitswapNetworkWantProgressEvents = ProgressEvent<'bitswap:network:send-wantlist', PeerId> | ProgressEvent<'bitswap:network:send-wantlist:error', {
+    peer: PeerId;
+    error: Error;
+}> | ProgressEvent<'bitswap:network:find-providers', CID> | BitswapNetworkProgressEvents;
+export type BitswapNetworkNotifyProgressEvents = BitswapNetworkProgressEvents | ProgressEvent<'bitswap:network:send-block', PeerId>;
+export interface NetworkInit {
+    hashLoader?: MultihashHasherLoader;
+    maxInboundStreams?: number;
+    maxOutboundStreams?: number;
+    messageReceiveTimeout?: number;
+    messageSendTimeout?: number;
+    messageSendConcurrency?: number;
+    protocols?: string[];
+    runOnTransientConnections?: boolean;
+}
+export interface NetworkComponents {
+    routing: Routing;
+    logger: ComponentLogger;
+    libp2p: Libp2p;
+    metrics?: Metrics;
+}
+export interface BitswapMessageEventDetail {
+    peer: PeerId;
+    message: BitswapMessage;
+}
+export interface NetworkEvents {
+    'bitswap:message': CustomEvent<{
+        peer: PeerId;
+        message: BitswapMessage;
+    }>;
+    'peer:connected': CustomEvent<PeerId>;
+    'peer:disconnected': CustomEvent<PeerId>;
+}
+export declare class Network extends TypedEventEmitter<NetworkEvents> {
+    private readonly log;
+    private readonly libp2p;
+    private readonly routing;
+    private readonly protocols;
+    private running;
+    private readonly maxInboundStreams;
+    private readonly maxOutboundStreams;
+    private readonly messageReceiveTimeout;
+    private registrarIds;
+    private readonly metrics?;
+    private readonly sendQueue;
+    private readonly messageSendTimeout;
+    private readonly runOnTransientConnections;
+    constructor(components: NetworkComponents, init?: NetworkInit);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Handles incoming bitswap messages
+     */
+    _onStream(info: IncomingStreamData): void;
+    /**
+     * Find bitswap providers for a given `cid`.
+     */
+    findProviders(cid: CID, options?: AbortOptions & ProgressOptions<BitswapNetworkWantProgressEvents>): AsyncIterable<Provider>;
+    /**
+     * Find the providers of a given `cid` and connect to them.
+     */
+    findAndConnect(cid: CID, options?: WantOptions): Promise<void>;
+    /**
+     * Connect to the given peer
+     * Send the given msg (instance of Message) to the given peer
+     */
+    sendMessage(peerId: PeerId, msg: Partial<BitswapMessage>, options?: AbortOptions & ProgressOptions<BitswapNetworkWantProgressEvents>): Promise<void>;
+    /**
+     * Connects to another peer
+     */
+    connectTo(peer: PeerId, options?: AbortOptions & ProgressOptions<BitswapNetworkProgressEvents>): Promise<Connection>;
+    _updateSentStats(peerId: PeerId, blocks?: Block[]): void;
+}
+//# sourceMappingURL=network.d.ts.map

package/dist/src/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/network.ts"],"names":[],"mappings":"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"}

package/dist/src/network.js

@@ -0,0 +1,370 @@
+import { CodeError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface';
+import { PeerQueue } from '@libp2p/utils/peer-queue';
+import { Circuit } from '@multiformats/multiaddr-matcher';
+import { anySignal } from 'any-signal';
+import debug from 'debug';
+import drain from 'it-drain';
+import * as lp from 'it-length-prefixed';
+import { lpStream } from 'it-length-prefixed-stream';
+import map from 'it-map';
+import { pipe } from 'it-pipe';
+import take from 'it-take';
+import { base64 } from 'multiformats/bases/base64';
+import { CID } from 'multiformats/cid';
+import { CustomProgressEvent } from 'progress-events';
+import { raceEvent } from 'race-event';
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string';
+import { BITSWAP_120, DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS, DEFAULT_MAX_PROVIDERS_PER_REQUEST, DEFAULT_MESSAGE_RECEIVE_TIMEOUT, DEFAULT_MESSAGE_SEND_TIMEOUT, DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS } from './constants.js';
+import { BitswapMessage } from './pb/message.js';
+// Add a formatter for a bitswap message
+debug.formatters.B = (b) => {
+    if (b == null) {
+        return 'undefined';
+    }
+    return JSON.stringify({
+        blocks: b.blocks?.map(b => ({
+            data: `${uint8ArrayToString(b.data, 'base64').substring(0, 10)}...`,
+            prefix: uint8ArrayToString(b.prefix, 'base64')
+        })),
+        blockPresences: b.blockPresences?.map(p => ({
+            ...p,
+            cid: CID.decode(p.cid).toString()
+        })),
+        wantlist: b.wantlist == null
+            ? undefined
+            : {
+                full: b.wantlist.full,
+                entries: b.wantlist.entries.map(e => ({
+                    ...e,
+                    cid: CID.decode(e.cid).toString()
+                }))
+            }
+    }, null, 2);
+};
+export class Network extends TypedEventEmitter {
+    log;
+    libp2p;
+    routing;
+    protocols;
+    running;
+    maxInboundStreams;
+    maxOutboundStreams;
+    messageReceiveTimeout;
+    registrarIds;
+    metrics;
+    sendQueue;
+    messageSendTimeout;
+    runOnTransientConnections;
+    constructor(components, init = {}) {
+        super();
+        this.log = components.logger.forComponent('helia:bitswap:network');
+        this.libp2p = components.libp2p;
+        this.routing = components.routing;
+        this.protocols = init.protocols ?? [BITSWAP_120];
+        this.registrarIds = [];
+        this.running = false;
+        // bind event listeners
+        this._onStream = this._onStream.bind(this);
+        this.maxInboundStreams = init.maxInboundStreams ?? DEFAULT_MAX_INBOUND_STREAMS;
+        this.maxOutboundStreams = init.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS;
+        this.messageReceiveTimeout = init.messageReceiveTimeout ?? DEFAULT_MESSAGE_RECEIVE_TIMEOUT;
+        this.messageSendTimeout = init.messageSendTimeout ?? DEFAULT_MESSAGE_SEND_TIMEOUT;
+        this.runOnTransientConnections = init.runOnTransientConnections ?? DEFAULT_RUN_ON_TRANSIENT_CONNECTIONS;
+        if (components.metrics != null) {
+            this.metrics = {
+                blocksSent: components.metrics?.registerMetricGroup('ipfs_bitswap_sent_blocks'),
+                dataSent: components.metrics?.registerMetricGroup('ipfs_bitswap_sent_data_bytes')
+            };
+        }
+        this.sendQueue = new PeerQueue({
+            concurrency: init.messageSendConcurrency,
+            metrics: components.metrics,
+            metricName: 'ipfs_bitswap_message_send_queue'
+        });
+        this.sendQueue.addEventListener('error', (evt) => {
+            this.log.error('error sending wantlist to peer', evt.detail);
+        });
+    }
+    async start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        await this.libp2p.handle(this.protocols, this._onStream, {
+            maxInboundStreams: this.maxInboundStreams,
+            maxOutboundStreams: this.maxOutboundStreams,
+            runOnTransientConnection: this.runOnTransientConnections
+        });
+        // register protocol with topology
+        const topology = {
+            onConnect: (peerId) => {
+                this.safeDispatchEvent('peer:connected', {
+                    detail: peerId
+                });
+            },
+            onDisconnect: (peerId) => {
+                this.safeDispatchEvent('peer:disconnected', {
+                    detail: peerId
+                });
+            }
+        };
+        this.registrarIds = [];
+        for (const protocol of this.protocols) {
+            this.registrarIds.push(await this.libp2p.register(protocol, topology));
+        }
+        // All existing connections are like new ones for us
+        this.libp2p.getConnections().forEach(conn => {
+            this.safeDispatchEvent('peer:connected', {
+                detail: conn.remotePeer
+            });
+        });
+    }
+    async stop() {
+        this.running = false;
+        // Unhandle both, libp2p doesn't care if it's not already handled
+        await this.libp2p.unhandle(this.protocols);
+        // unregister protocol and handlers
+        if (this.registrarIds != null) {
+            for (const id of this.registrarIds) {
+                this.libp2p.unregister(id);
+            }
+            this.registrarIds = [];
+        }
+    }
+    /**
+     * Handles incoming bitswap messages
+     */
+    _onStream(info) {
+        if (!this.running) {
+            return;
+        }
+        const { stream, connection } = info;
+        Promise.resolve().then(async () => {
+            this.log('incoming new bitswap %s stream from %p', stream.protocol, connection.remotePeer);
+            const abortListener = () => {
+                stream.abort(new CodeError('Incoming Bitswap stream timed out', 'ERR_TIMEOUT'));
+            };
+            let signal = AbortSignal.timeout(this.messageReceiveTimeout);
+            setMaxListeners(Infinity, signal);
+            signal.addEventListener('abort', abortListener);
+            await pipe(stream, (source) => lp.decode(source), async (source) => {
+                for await (const data of source) {
+                    try {
+                        const message = BitswapMessage.decode(data);
+                        this.log('incoming new bitswap %s message from %p %B', stream.protocol, connection.remotePeer, message);
+                        this.safeDispatchEvent('bitswap:message', {
+                            detail: {
+                                peer: connection.remotePeer,
+                                message
+                            }
+                        });
+                        // we have received some data so reset the timeout controller
+                        signal.removeEventListener('abort', abortListener);
+                        signal = AbortSignal.timeout(this.messageReceiveTimeout);
+                        setMaxListeners(Infinity, signal);
+                        signal.addEventListener('abort', abortListener);
+                    }
+                    catch (err) {
+                        this.log.error('error reading incoming bitswap message from %p', connection.remotePeer, err);
+                        stream.abort(err);
+                        break;
+                    }
+                }
+            });
+        })
+            .catch(err => {
+            this.log.error('error handling incoming stream from %p', connection.remotePeer, err);
+            stream.abort(err);
+        });
+    }
+    /**
+     * Find bitswap providers for a given `cid`.
+     */
+    async *findProviders(cid, options) {
+        options?.onProgress?.(new CustomProgressEvent('bitswap:network:find-providers', cid));
+        for await (const provider of this.routing.findProviders(cid, options)) {
+            // unless we explicitly run on transient connections, skip peers that only
+            // have circuit relay addresses as bitswap won't run over them
+            if (!this.runOnTransientConnections) {
+                let hasDirectAddress = false;
+                for (let ma of provider.multiaddrs) {
+                    if (ma.getPeerId() == null) {
+                        ma = ma.encapsulate(`/p2p/${provider.id}`);
+                    }
+                    if (!Circuit.exactMatch(ma)) {
+                        hasDirectAddress = true;
+                        break;
+                    }
+                }
+                if (!hasDirectAddress) {
+                    continue;
+                }
+            }
+            // ignore non-bitswap providers
+            if (provider.protocols?.includes('transport-bitswap') === false) {
+                continue;
+            }
+            yield provider;
+        }
+    }
+    /**
+     * Find the providers of a given `cid` and connect to them.
+     */
+    async findAndConnect(cid, options) {
+        await drain(take(map(this.findProviders(cid, options), async (provider) => this.connectTo(provider.id, options)), options?.maxProviders ?? DEFAULT_MAX_PROVIDERS_PER_REQUEST))
+            .catch(err => {
+            this.log.error(err);
+        });
+    }
+    /**
+     * Connect to the given peer
+     * Send the given msg (instance of Message) to the given peer
+     */
+    async sendMessage(peerId, msg, options) {
+        if (!this.running) {
+            throw new Error('network isn\'t running');
+        }
+        const message = {
+            wantlist: {
+                full: msg.wantlist?.full ?? false,
+                entries: msg.wantlist?.entries ?? []
+            },
+            blocks: msg.blocks ?? [],
+            blockPresences: msg.blockPresences ?? [],
+            pendingBytes: msg.pendingBytes ?? 0
+        };
+        const signal = anySignal([AbortSignal.timeout(this.messageSendTimeout), options?.signal]);
+        setMaxListeners(Infinity, signal);
+        try {
+            const existingJob = this.sendQueue.find(peerId);
+            if (existingJob?.status === 'queued') {
+                // merge messages instead of adding new job
+                existingJob.options.message = mergeMessages(existingJob.options.message, message);
+                await existingJob.join({
+                    signal
+                });
+                return;
+            }
+            await this.sendQueue.add(async (options) => {
+                const message = options?.message;
+                if (message == null) {
+                    throw new CodeError('No message to send', 'ERR_NO_MESSAGE');
+                }
+                this.log('sendMessage to %p %B', peerId, message);
+                options?.onProgress?.(new CustomProgressEvent('bitswap:network:send-wantlist', peerId));
+                const stream = await this.libp2p.dialProtocol(peerId, BITSWAP_120, options);
+                try {
+                    const lp = lpStream(stream);
+                    await lp.write(BitswapMessage.encode(message), options);
+                    await lp.unwrap().close(options);
+                }
+                catch (err) {
+                    options?.onProgress?.(new CustomProgressEvent('bitswap:network:send-wantlist:error', { peer: peerId, error: err }));
+                    this.log.error('error sending message to %p', peerId, err);
+                    stream.abort(err);
+                }
+                this._updateSentStats(peerId, message.blocks);
+            }, {
+                peerId,
+                signal,
+                message
+            });
+        }
+        finally {
+            signal.clear();
+        }
+    }
+    /**
+     * Connects to another peer
+     */
+    async connectTo(peer, options) {
+        if (!this.running) {
+            throw new CodeError('Network isn\'t running', 'ERR_NOT_STARTED');
+        }
+        options?.onProgress?.(new CustomProgressEvent('bitswap:network:dial', peer));
+        // dial and wait for identify - this is to avoid opening a protocol stream
+        // that we are not going to use but depends on the remote node running the
+        // identitfy protocol
+        const [connection] = await Promise.all([
+            this.libp2p.dial(peer, options),
+            raceEvent(this.libp2p, 'peer:identify', options?.signal, {
+                filter: (evt) => {
+                    if (!evt.detail.peerId.equals(peer)) {
+                        return false;
+                    }
+                    if (evt.detail.protocols.includes(BITSWAP_120)) {
+                        return true;
+                    }
+                    throw new CodeError(`${peer} did not support ${BITSWAP_120}`, 'ERR_BITSWAP_UNSUPPORTED_BY_PEER');
+                }
+            })
+        ]);
+        return connection;
+    }
+    _updateSentStats(peerId, blocks = []) {
+        if (this.metrics != null) {
+            let bytes = 0;
+            for (const block of blocks.values()) {
+                bytes += block.data.byteLength;
+            }
+            this.metrics.dataSent.increment({
+                global: bytes,
+                [peerId.toString()]: bytes
+            });
+            this.metrics.blocksSent.increment({
+                global: blocks.length,
+                [peerId.toString()]: blocks.length
+            });
+        }
+    }
+}
+function mergeMessages(messageA, messageB) {
+    const wantListEntries = new Map((messageA.wantlist?.entries ?? []).map(entry => ([
+        base64.encode(entry.cid),
+        entry
+    ])));
+    for (const entry of messageB.wantlist?.entries ?? []) {
+        const key = base64.encode(entry.cid);
+        const existingEntry = wantListEntries.get(key);
+        if (existingEntry != null) {
+            // take highest priority
+            if (existingEntry.priority > entry.priority) {
+                entry.priority = existingEntry.priority;
+            }
+            // take later values if passed, otherwise use earlier ones
+            entry.cancel = entry.cancel ?? existingEntry.cancel;
+            entry.wantType = entry.wantType ?? existingEntry.wantType;
+            entry.sendDontHave = entry.sendDontHave ?? existingEntry.sendDontHave;
+        }
+        wantListEntries.set(key, entry);
+    }
+    const blockPresences = new Map(messageA.blockPresences.map(presence => ([
+        base64.encode(presence.cid),
+        presence
+    ])));
+    for (const blockPresence of messageB.blockPresences) {
+        const key = base64.encode(blockPresence.cid);
+        // override earlier block presence with later one as if duplicated it is
+        // likely to be more accurate since it is more recent
+        blockPresences.set(key, blockPresence);
+    }
+    const blocks = new Map(messageA.blocks.map(block => ([
+        base64.encode(block.data),
+        block
+    ])));
+    for (const block of messageB.blocks) {
+        const key = base64.encode(block.data);
+        blocks.set(key, block);
+    }
+    const output = {
+        wantlist: {
+            full: messageA.wantlist?.full ?? messageB.wantlist?.full ?? false,
+            entries: [...wantListEntries.values()]
+        },
+        blockPresences: [...blockPresences.values()],
+        blocks: [...blocks.values()],
+        pendingBytes: messageA.pendingBytes + messageB.pendingBytes
+    };
+    return output;
+}
+//# sourceMappingURL=network.js.map