Enum PolicyError

pub enum PolicyError {
    ToSelfDelayUnreasonablyLarge {
        proposed: u16,
        allowed_maximum: u16,
    },
    MaxAcceptedHtlcLimitExceeded(u16),
    FeeRateUnreasonable {
        proposed: u32,
        lowest_accepted: u32,
        highest_accepted: u32,
    },
    ChannelReserveLessDust {
        reserve: u64,
        dust_limit: u64,
    },
    DustLimitTooSmall(u64),
    ChannelFundingTooSmall {
        proposed: u64,
        required_minimum: u64,
    },
    HtlcMinimumTooLarge {
        proposed: u64,
        allowed_maximum: u64,
    },
    HtlcInFlightMaximumTooSmall {
        proposed: u64,
        required_minimum: u64,
    },
    ChannelReserveTooLarge {
        proposed: u64,
        allowed_maximum: u64,
    },
    MaxAcceptedHtlcsTooSmall {
        proposed: u16,
        required_minimum: u16,
    },
    DustLimitTooLarge {
        proposed: u64,
        allowed_maximum: u64,
    },
    UnreasonableMinDepth {
        proposed: u32,
        allowed_maximum: u32,
    },
    LocalDustExceedsRemoteReserve {
        channel_reserve: u64,
        dust_limit: u64,
    },
    RemoteDustExceedsLocalReserve {
        channel_reserve: u64,
        dust_limit: u64,
    },
}

Errors from BOLT-2 policy validations for open_channel and accept_channel messages.

Variants

ToSelfDelayUnreasonablyLarge

proposed to_self_delay value {proposed} is unreasonably large and exceeds node policy limit of {allowed_maximum}; rejecting the channel according to BOLT-2

Fields

proposed: u16

allowed_maximum: u16

MaxAcceptedHtlcLimitExceeded(u16)

proposed limit for maximum accepted number of HTLCs {0} exceeds BOLT-3 requirement to be below 483; rejecting the channel according to BOLT-2

FeeRateUnreasonable

proposed fee rate {proposed} sat/kw is outside of the fee rate policy of the local node ({lowest_accepted}..{highest_accepted} sat/kw); rejecting the channel according to BOLT-2

Fields

proposed: u32

lowest_accepted: u32

highest_accepted: u32

ChannelReserveLessDust

proposed channel reserve limit {reserve} sat is less than dust limit {dust_limit} sat; rejecting the channel according to BOLT-2

Fields

reserve: u64

dust_limit: u64

DustLimitTooSmall(u64)

dust limit {0} sat is less than protocol minimum requirement of 354 sat; rejecting the channel according to BOLT-2

ChannelFundingTooSmall

offered channel funding of {proposed} sat is too small and less than {required_minimum} required by the node policy; rejecting the channel according to BOLT-2

Fields

proposed: u64

required_minimum: u64

HtlcMinimumTooLarge

HTLC minimum {proposed} is too large and exceeds node policy requirements ({allowed_maximum}); rejecting the channel according to BOLT-2

Fields

proposed: u64

allowed_maximum: u64

HtlcInFlightMaximumTooSmall

HTLC-in-flight maximum requirement of {proposed} is too small and does not match the node policy; the smallest requirement is {required_minimum}; rejecting the channel according to BOLT-2

Fields

proposed: u64

required_minimum: u64

ChannelReserveTooLarge

requested {proposed} channel reserve is too large and exceeds local policy requirement of {allowed_maximum}; rejecting the channel according to BOLT-2

Fields

proposed: u64

allowed_maximum: u64

MaxAcceptedHtlcsTooSmall

maximum number of HTLCs {proposed} that can be accepted by the remote node is too small and does not match node policy requirement of {required_minimum}; rejecting the channel according to BOLT-2

Fields

proposed: u16

required_minimum: u16

DustLimitTooLarge

dust limit {proposed} sats exceeds node policy requirement of {allowed_maximum}; rejecting the channel according to BOLT-2

Fields

proposed: u64

allowed_maximum: u64

UnreasonableMinDepth

minimum depth of {proposed} requested by the remote peer is exceeds local policy limit of {allowed_maximum}; rejecting the channel according to BOLT-2

Fields

proposed: u32

allowed_maximum: u32

LocalDustExceedsRemoteReserve

channel_reserve_satoshis ({channel_reserve}) is less than dust_limit_satoshis ({dust_limit}) within the open_channel message; rejecting the channel according to BOLT-2

Fields

channel_reserve: u64

dust_limit: u64

RemoteDustExceedsLocalReserve

channel_reserve_satoshis from the open_channel message ({channel_reserve}) is less than dust_limit_satoshis ({dust_limit}; rejecting the channel according to BOLT-2

Fields

channel_reserve: u64

dust_limit: u64

Trait Implementations

impl Clone for PolicyError

fn clone(&self) -> PolicyError

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PolicyError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for PolicyError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for PolicyError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<PolicyError> for Error

fn from(v: PolicyError) -> Self

Converts to this type from the input type.

impl From<PolicyError> for String

fn from(err: PolicyError) -> Self

Converts to this type from the input type.

impl Hash for PolicyError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PolicyError

fn eq(&self, other: &PolicyError) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StrictDecode for PolicyError

fn strict_decode<D: Read>(d: D) -> Result<Self, Error>

Decode with the given std::io::Read instance; must either construct an instance or return implementation-specific error type.

fn strict_deserialize(data: impl AsRef<[u8]>) -> Result<Self, Error>

Tries to deserialize byte array into the current type using StrictDecode::strict_decode. If there are some data remains in the buffer once deserialization is completed, fails with Error::DataNotEntirelyConsumed. Use io::Cursor over the buffer and StrictDecode::strict_decode to avoid such failures.

fn strict_file_load(path: impl AsRef<Path>) -> Result<Self, Error>

Reads data from file at path and reconstructs object from it. Fails with Error::DataNotEntirelyConsumed if file contains remaining data after the object reconstruction.

impl StrictEncode for PolicyError

fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

Encode with the given std::io::Write instance; must return result with either amount of bytes encoded – or implementation-specific error type.

fn strict_serialize(&self) -> Result<Vec<u8>, Error>

Serializes data as a byte array using StrictEncode::strict_encode function

fn strict_file_save(&self, path: impl AsRef<Path>) -> Result<usize, Error>

Saves data to a file at a given path. If the file does not exists, attempts to create the file. If the file already exists, it gets truncated.

impl Copy for PolicyError

impl Eq for PolicyError

impl StructuralPartialEq for PolicyError