@libp2p/interface
Version:
The interface implemented by a libp2p node
337 lines • 9.51 kB
JavaScript
/**
* When this error is thrown it means an operation was aborted,
* usually in response to the `abort` event being emitted by an
* AbortSignal.
*/
export class AbortError extends Error {
static name = 'AbortError';
constructor(message = 'The operation was aborted') {
super(message);
this.name = 'AbortError';
}
}
/**
* Thrown when a remote Peer ID does not match the expected one
*/
export class UnexpectedPeerError extends Error {
static name = 'UnexpectedPeerError';
constructor(message = 'Unexpected Peer') {
super(message);
this.name = 'UnexpectedPeerError';
}
}
/**
* Thrown when a crypto exchange fails
*/
export class InvalidCryptoExchangeError extends Error {
static name = 'InvalidCryptoExchangeError';
constructor(message = 'Invalid crypto exchange') {
super(message);
this.name = 'InvalidCryptoExchangeError';
}
}
/**
* Thrown when invalid parameters are passed to a function or method call
*/
export class InvalidParametersError extends Error {
static name = 'InvalidParametersError';
constructor(message = 'Invalid parameters') {
super(message);
this.name = 'InvalidParametersError';
}
}
/**
* Thrown when a public key is invalid
*/
export class InvalidPublicKeyError extends Error {
static name = 'InvalidPublicKeyError';
constructor(message = 'Invalid public key') {
super(message);
this.name = 'InvalidPublicKeyError';
}
}
/**
* Thrown when a private key is invalid
*/
export class InvalidPrivateKeyError extends Error {
static name = 'InvalidPrivateKeyError';
constructor(message = 'Invalid private key') {
super(message);
this.name = 'InvalidPrivateKeyError';
}
}
/**
* Thrown when a operation is unsupported
*/
export class UnsupportedOperationError extends Error {
static name = 'UnsupportedOperationError';
constructor(message = 'Unsupported operation') {
super(message);
this.name = 'UnsupportedOperationError';
}
}
/**
* Thrown when a connection is closing
*/
export class ConnectionClosingError extends Error {
static name = 'ConnectionClosingError';
constructor(message = 'The connection is closing') {
super(message);
this.name = 'ConnectionClosingError';
}
}
/**
* Thrown when a connection is closed
*/
export class ConnectionClosedError extends Error {
static name = 'ConnectionClosedError';
constructor(message = 'The connection is closed') {
super(message);
this.name = 'ConnectionClosedError';
}
}
/**
* Thrown when a connection fails
*/
export class ConnectionFailedError extends Error {
static name = 'ConnectionFailedError';
constructor(message = 'Connection failed') {
super(message);
this.name = 'ConnectionFailedError';
}
}
/**
* Thrown when the muxer is closed and an attempt to open a stream occurs
*/
export class MuxerClosedError extends Error {
static name = 'MuxerClosedError';
constructor(message = 'The muxer is closed') {
super(message);
this.name = 'MuxerClosedError';
}
}
/**
* Thrown when a protocol stream is reset by the remote muxer
*/
export class StreamResetError extends Error {
static name = 'StreamResetError';
constructor(message = 'The stream has been reset') {
super(message);
this.name = 'StreamResetError';
}
}
/**
* Thrown when a protocol stream is aborted locally
*/
export class StreamAbortedError extends Error {
static name = 'StreamAbortedError';
constructor(message = 'The stream has been aborted') {
super(message);
this.name = 'StreamAbortedError';
}
}
/**
* Thrown when a stream is in an invalid state
*/
export class StreamStateError extends Error {
static name = 'StreamStateError';
constructor(message = 'The stream is in an invalid state') {
super(message);
this.name = 'StreamStateError';
}
}
/**
* Thrown when a stream buffer is full
*/
export class StreamBufferError extends Error {
static name = 'StreamBufferError';
constructor(message = 'The stream buffer was full') {
super(message);
this.name = 'StreamBufferError';
}
}
/**
* Thrown when a value could not be found
*/
export class NotFoundError extends Error {
static name = 'NotFoundError';
constructor(message = 'Not found') {
super(message);
this.name = 'NotFoundError';
}
}
/**
* Thrown when an invalid peer ID is encountered
*/
export class InvalidPeerIdError extends Error {
static name = 'InvalidPeerIdError';
constructor(message = 'Invalid PeerID') {
super(message);
this.name = 'InvalidPeerIdError';
}
}
/**
* Thrown when an invalid multiaddr is encountered
*/
export class InvalidMultiaddrError extends Error {
static name = 'InvalidMultiaddrError';
constructor(message = 'Invalid multiaddr') {
super(message);
this.name = 'InvalidMultiaddrError';
}
}
/**
* Thrown when an invalid CID is encountered
*/
export class InvalidCIDError extends Error {
static name = 'InvalidCIDError';
constructor(message = 'Invalid CID') {
super(message);
this.name = 'InvalidCIDError';
}
}
/**
* Thrown when an invalid multihash is encountered
*/
export class InvalidMultihashError extends Error {
static name = 'InvalidMultihashError';
constructor(message = 'Invalid Multihash') {
super(message);
this.name = 'InvalidMultihashError';
}
}
/**
* Thrown when a protocol is not supported
*/
export class UnsupportedProtocolError extends Error {
static name = 'UnsupportedProtocolError';
constructor(message = 'Unsupported protocol error') {
super(message);
this.name = 'UnsupportedProtocolError';
}
}
/**
* An invalid or malformed message was encountered during a protocol exchange
*/
export class InvalidMessageError extends Error {
static name = 'InvalidMessageError';
constructor(message = 'Invalid message') {
super(message);
this.name = 'InvalidMessageError';
}
}
/**
* Thrown when a remote peer sends a structurally valid message that does not
* comply with the protocol
*/
export class ProtocolError extends Error {
static name = 'ProtocolError';
constructor(message = 'Protocol error') {
super(message);
this.name = 'ProtocolError';
}
}
/**
* Throw when an operation times out
*/
export class TimeoutError extends Error {
static name = 'TimeoutError';
constructor(message = 'Timed out') {
super(message);
this.name = 'TimeoutError';
}
}
/**
* Thrown when a startable component is interacted with but it has not been
* started yet
*/
export class NotStartedError extends Error {
static name = 'NotStartedError';
constructor(message = 'Not started') {
super(message);
this.name = 'NotStartedError';
}
}
/**
* Thrown when a component is started that has already been started
*/
export class AlreadyStartedError extends Error {
static name = 'AlreadyStartedError';
constructor(message = 'Already started') {
super(message);
this.name = 'AlreadyStartedError';
}
}
/**
* Thrown when dialing an address failed
*/
export class DialError extends Error {
static name = 'DialError';
constructor(message = 'Dial error') {
super(message);
this.name = 'DialError';
}
}
/**
* Thrown when listening on an address failed
*/
export class ListenError extends Error {
static name = 'ListenError';
constructor(message = 'Listen error') {
super(message);
this.name = 'ListenError';
}
}
/**
* This error is thrown when a limited connection is encountered, i.e. if the
* user tried to open a stream on a connection for a protocol that is not
* configured to run over limited connections.
*/
export class LimitedConnectionError extends Error {
static name = 'LimitedConnectionError';
constructor(message = 'Limited connection') {
super(message);
this.name = 'LimitedConnectionError';
}
}
/**
* This error is thrown where there are too many inbound protocols streams open
*/
export class TooManyInboundProtocolStreamsError extends Error {
static name = 'TooManyInboundProtocolStreamsError';
constructor(message = 'Too many inbound protocol streams') {
super(message);
this.name = 'TooManyInboundProtocolStreamsError';
}
}
/**
* This error is thrown where there are too many outbound protocols streams open
*/
export class TooManyOutboundProtocolStreamsError extends Error {
static name = 'TooManyOutboundProtocolStreamsError';
constructor(message = 'Too many outbound protocol streams') {
super(message);
this.name = 'TooManyOutboundProtocolStreamsError';
}
}
/**
* Thrown when an attempt to operate on an unsupported key was made
*/
export class UnsupportedKeyTypeError extends Error {
static name = 'UnsupportedKeyTypeError';
constructor(message = 'Unsupported key type') {
super(message);
this.name = 'UnsupportedKeyTypeError';
}
}
/**
* Thrown when an operation has not been implemented
*/
export class NotImplementedError extends Error {
static name = 'NotImplementedError';
constructor(message = 'Not implemented') {
super(message);
this.name = 'NotImplementedError';
}
}
//# sourceMappingURL=errors.js.map