ipfs-bitswap/dist/src/index.d.ts

JavaScript implementation of the Bitswap data exchange protocol used by IPFS

/**
 * @packageDocumentation
 *
 * This module implements the [Bitswap protocol](https://docs.ipfs.tech/concepts/bitswap/) in TypeScript.
 */
import type { Message } from './message/message';
import type { BitswapNetworkNotifyProgressEvents, BitswapNetworkWantProgressEvents } from './network.js';
import type { Libp2p, AbortOptions, PeerId, Startable } from '@libp2p/interface';
import type { IMovingAverage } from '@vascosantos/moving-average';
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 interface WantListEntry {
    cid: CID;
    priority: number;
    wantType: Message.Wantlist.WantType;
    inc(): void;
    dec(): void;
    hasRefs(): boolean;
}
export interface Wantlist {
    length: number;
    add(cid: CID, priority: number, wantType: Message.Wantlist.WantType): void;
    remove(cid: CID): void;
    removeForce(cid: string): void;
    forEach(fn: (entry: WantListEntry, key: string) => void): void;
    sortedEntries(): Map<string, WantListEntry>;
    contains(cid: CID): boolean;
    get(cid: CID): WantListEntry;
}
export interface Ledger {
    peer: PeerId;
    value: number;
    sent: number;
    recv: number;
    exchanged: number;
}
export interface Stat {
    enable(): void;
    disable(): void;
    stop(): void;
    snapshot: Record<string, bigint>;
    movingAverages: Record<string, Record<number, IMovingAverage>>;
    push(counter: string, inc: number): void;
}
export interface Stats {
    snapshot: Record<string, bigint>;
    movingAverages: Record<string, Record<number, IMovingAverage>>;
    enable(): void;
    disable(): void;
    stop(): void;
    forPeer(peerId: PeerId | string): Stat | undefined;
    push(peer: string, counter: string, inc: number): void;
}
export type BitswapWantProgressEvents = BitswapWantBlockProgressEvents;
export type BitswapNotifyProgressEvents = BitswapNetworkNotifyProgressEvents;
export type BitswapWantBlockProgressEvents = ProgressEvent<'bitswap:want-block:unwant', CID> | ProgressEvent<'bitswap:want-block:block', CID> | BitswapNetworkWantProgressEvents;
export interface Bitswap extends Startable {
    /**
     * Bitswap statistics
     */
    stats: Stats;
    /**
     * The peers that we are tracking a ledger for
     */
    peers: PeerId[];
    wantlistForPeer(peerId: PeerId): Map<string, WantListEntry>;
    ledgerForPeer(peerId: PeerId): Ledger | undefined;
    unwant(cids: CID | CID[]): void;
    cancelWants(cids: CID | CID[]): void;
    getWantlist(): IterableIterator<[string, WantListEntry]>;
    /**
     * Notify bitswap that a new block is available
     */
    notify(cid: CID, block: Uint8Array, options?: ProgressOptions<BitswapNotifyProgressEvents>): void;
    /**
     * Retrieve a block from the network
     */
    want(cid: CID, options?: AbortOptions & ProgressOptions<BitswapWantProgressEvents>): Promise<Uint8Array>;
}
export interface MultihashHasherLoader {
    getHasher(codeOrName: number | string): Promise<MultihashHasher>;
}
export interface BitswapOptions {
    /**
     * Whether stats are enabled. Default: false
     */
    statsEnabled?: boolean;
    /**
     * Default: 1000
     */
    statsComputeThrottleTimeout?: number;
    /**
     * Default: 1000
     */
    statsComputeThrottleMaxQueueSize?: number;
    /**
     * Default: 32
     */
    maxInboundStreams?: number;
    /**
     * Default: 128
     */
    maxOutboundStreams?: number;
    /**
     * Default: 30000
     */
    incomingStreamTimeout?: number;
    /**
     * Enables loading esoteric hash functions
     */
    hashLoader?: MultihashHasherLoader;
}
export declare const createBitswap: (libp2p: Libp2p, blockstore: Blockstore, options?: BitswapOptions) => Bitswap;
//# sourceMappingURL=index.d.ts.map