///
import BitField from 'bitfield';
import stream from 'readable-stream';
import { ExtendedHandshake } from './Extension';
import { IExtension } from './models/IExtension';
import { PieceRequest, RequestCallback } from './models/PieceRequest';
import { ParseRequest } from './models/ParseRequest';
import { WireEvents } from './models/WireEvents';
import { ExtensionsMap } from './models/ExtensionsMap';
export declare class Wire extends stream.Duplex {
_debugId: string;
peerId: string | undefined;
peerIdBuffer: Buffer | undefined;
type: 'webrtc' | 'tcpIncoming' | 'tcpOutgoing' | 'webSeed' | null;
amChoking: boolean;
amInterested: boolean;
peerChoking: boolean;
peerInterested: boolean;
peerPieces: BitField;
peerExtensions: ExtensionsMap;
requests: PieceRequest[];
peerRequests: PieceRequest[];
extendedMapping: {
[key: number]: string;
};
peerExtendedMapping: {
[key: string]: number;
};
extendedHandshake: ExtendedHandshake;
peerExtendedHandshake: ExtendedHandshake;
_ext: {
[extensionName: string]: IExtension;
};
_nextExt: number;
uploaded: number;
downloaded: number;
uploadSpeed: (speed: number) => void;
downloadSpeed: (speed: number) => void;
_keepAliveInterval: number | NodeJS.Timeout | undefined;
_timeout: number | NodeJS.Timeout | undefined;
_timeoutMs: number;
destroyed: boolean;
_finished: boolean;
_parseRequests: Array;
_buffer: Buffer;
_timeoutUnref: unknown;
_handshakeSent: boolean;
_extendedHandshakeSent: boolean;
_handshakeSuccess: boolean;
_extendedHandshakeSuccess: boolean;
wireName: string | undefined;
constructor(name?: string);
once(event: U, listener: WireEvents[U]): this;
on(event: U, listener: WireEvents[U]): this;
off(event: U, listener: WireEvents[U]): this;
emit(event: U, ...args: Parameters): boolean;
/**
* Set whether to send a "keep-alive" ping (sent every 55s)
* @param {boolean} enable
*/
setKeepAlive(enable: boolean): void;
/**
* Set the amount of time to wait before considering a request to be "timed out"
* @param {number} ms
* @param {boolean=} unref (should the timer be unref'd? default: false)
*/
setTimeout(ms: number, unref?: boolean): void;
destroy(): this;
end(...args: any[]): void;
/**
* Use the specified protocol extension.
* @param {function} Extension
*/
use(newExtension: (wire: Wire) => IExtension): void;
/**
* Message "keep-alive":
*/
keepAlive(): void;
/**
* Message: "handshake"
* @param {Buffer|string} infoHash (as Buffer or *hex* string)
* @param {Buffer|string} peerId
* @param {Object} extensions
*/
handshake(infoHash: Buffer | string, peerId: Buffer | string, extensions?: any): void;
private _sendExtendedHandshake;
/**
* Message "choke":
*/
choke(): void;
/**
* Message "unchoke":
*/
unchoke(): void;
/**
* Message "interested":
*/
interested(): void;
/**
* Message "uninterested":
*/
uninterested(): void;
/**
* Message "have":
* @param {number} index
*/
have(index: number): void;
/**
* Message "bitfield":
* @param {BitField|Buffer} bitfield
*/
bitfield(bitfield: BitField | Buffer): void;
/**
* Callback will be resolved when onPiece(index, offset, length, buffer) is called or something fails when requesting.
*
* NOTE: index,offset,length are used as a key to look up the callback later.
*
* So make sure you specify the length correctly or you will never get your callback.
*
* If the other party sends the same index and offset but a buffer of a different length, you will not recieve your callback.
*
* Message "request":
* @param {number} index
* @param {number} offset
* @param {number} length
* @param {function} cb
*/
request(index: number, offset: number, length: number, cb: RequestCallback): void;
/**
* Message "piece":
* @param {number} index
* @param {number} offset
* @param {Buffer} buffer
*/
piece(index: number, offset: number, buffer: Buffer): void;
/**
* Message "cancel":
* @param {number} index
* @param {number} offset
* @param {number} length
*/
cancel(index: number, offset: number, length: number): void;
/**
* Message: "port"
* @param {Number} port
*/
port(port: number): void;
/**
* Message: "extended"
* @param {number|string} ext
* @param {Object} obj
*/
extended(ext: number | string, obj: object): void;
/**
* Duplex stream method. Called whenever the remote peer stream wants data. No-op
* since we'll just push data whenever we get it.
*/
_read(): void;
/**
* Send a message to the remote peer.
*/
private _message;
private _push;
private _onKeepAlive;
private _onHandshake;
private _onChoke;
private _onUnchoke;
private _onInterested;
private _onUninterested;
private _onHave;
private _onBitField;
private _onRequest;
private _onPiece;
private _onCancel;
private _onPort;
private onExtendedMessage;
private onExtendedHandshake;
private _onExtended;
private _onTimeout;
/**
* Duplex stream method. Called whenever the remote peer has data for us. Data that the
* remote peer sends gets buffered (i.e. not actually processed) until the right number
* of bytes have arrived, determined by the last call to `this._parse(number, callback)`.
* Once enough bytes have arrived to process the message, the callback function
* (i.e. `this._parser`) gets called with the full buffer of data.
* @param {Buffer} data
* @param {string} encoding
* @param {function} cb
*/
_write(data: Buffer, encoding: string, cb: (e: any) => void): void;
private parseStream;
private _callback;
private _clearTimeout;
private _updateTimeout;
/**
* Takes a number of bytes that the local peer is waiting to receive from the remote peer
* in order to parse a complete message, and a callback function to be called once enough
* bytes have arrived.
* @param {number} size
* @param {function} parser
*/
private _parse;
/**
* Handle the first 4 bytes of a message, to determine the length of bytes that must be
* waited for in order to have the whole message.
* @param {Buffer} buffer
*/
private _onMessageLength;
/**
* Handle a message from the remote peer.
* @param {Buffer} buffer
*/
private _onMessage;
private _parseHandshake;
private _onFinish;
private _debug;
/**
* Retrieves the first entity from the requests array that matches the index, offset and length given.
*
* Often used in conjunction with _callback to call back to waiting piece requests
* @param requests
* @param pieceIdx
* @param offset
* @param length
*/
private _pull;
}
export default Wire;