Enum btc_relay::pallet::Error

pub enum Error<T> {
    AlreadyInitialized,
    InvalidStartHeight,
    MissingBlockHeight,
    InvalidHeaderSize,
    DuplicateBlock,
    PrevBlock,
    InvalidChainID,
    LowDiff,
    DiffTargetHeader,
    MalformedTxid,
    BitcoinConfirmations,
    ParachainConfirmations,
    OngoingFork,
    MalformedMerkleProof,
    InvalidMerkleProof,
    Shutdown,
    InvalidTxid,
    InvalidPaymentAmount,
    MalformedTransaction,
    InvalidPayment,
    InvalidOutputFormat,
    InvalidOpReturn,
    InvalidTxVersion,
    UnknownErrorcode,
    ForkIdNotFound,
    BlockNotFound,
    AlreadyReported,
    UnauthorizedRelayer,
    ChainCounterOverflow,
    BlockHeightOverflow,
    ChainsUnderflow,
    EndOfFile,
    MalformedHeader,
    InvalidBlockVersion,
    MalformedWitnessOutput,
    MalformedP2PKHOutput,
    MalformedP2SHOutput,
    MalformedOpReturnOutput,
    UnsupportedOutputFormat,
    UnsupportedInputFormat,
    InvalidBtcHash,
    InvalidScript,
    InvalidBtcAddress,
    ArithmeticOverflow,
    ArithmeticUnderflow,
    TryIntoIntError,
    InvalidTransaction,
    InvalidOpReturnTransaction,
    InvalidCompact,
    WrongForkBound,
    BoundExceeded,
    InvalidCoinbasePosition,
    // some variants omitted
}

The Error enum of this pallet.

Variants

AlreadyInitialized

Already initialized

InvalidStartHeight

Start height must be start of difficulty period

MissingBlockHeight

Missing the block at this height

InvalidHeaderSize

Invalid block header size

DuplicateBlock

Block already stored

PrevBlock

Previous block hash not found

InvalidChainID

Invalid chain ID

LowDiff

PoW hash does not meet difficulty target of header

DiffTargetHeader

Incorrect difficulty target specified in block header

MalformedTxid

Malformed transaction identifier

BitcoinConfirmations

Transaction has less confirmations of Bitcoin blocks than required

ParachainConfirmations

Transaction has less confirmations of Parachain blocks than required

OngoingFork

Current fork ongoing

MalformedMerkleProof

Merkle proof is malformed

InvalidMerkleProof

Invalid merkle proof

Shutdown

BTC Parachain has shut down

InvalidTxid

Transaction hash does not match given txid

InvalidPaymentAmount

Invalid payment amount

MalformedTransaction

Transaction has incorrect format

InvalidPayment

Incorrect recipient Bitcoin address

InvalidOutputFormat

Incorrect transaction output format

InvalidOpReturn

Incorrect identifier in OP_RETURN field

InvalidTxVersion

Invalid transaction version

UnknownErrorcode

Error code not applicable to blocks

ForkIdNotFound

Blockchain with requested ID not found

BlockNotFound

Block header not found for given hash

AlreadyReported

Error code already reported

UnauthorizedRelayer

Unauthorized staked relayer

ChainCounterOverflow

Overflow of chain counter

BlockHeightOverflow

Overflow of block height

ChainsUnderflow

Underflow of stored blockchains counter

EndOfFile

EndOfFile reached while parsing

MalformedHeader

Format of the header is invalid

InvalidBlockVersion

Invalid block header version

MalformedWitnessOutput

Format of the BIP141 witness transaction output is invalid

MalformedP2PKHOutput

MalformedP2SHOutput

MalformedOpReturnOutput

Format of the OP_RETURN transaction output is invalid

UnsupportedOutputFormat

UnsupportedInputFormat

InvalidBtcHash

User supplied an invalid address

InvalidScript

User supplied an invalid script

InvalidBtcAddress

Specified invalid Bitcoin address

ArithmeticOverflow

Arithmetic overflow

ArithmeticUnderflow

Arithmetic underflow

TryIntoIntError

TryInto failed on integer

InvalidTransaction

Transaction does meet the requirements to be considered valid

InvalidOpReturnTransaction

Transaction does meet the requirements to be a valid op-return payment

InvalidCompact

Invalid compact value in header

WrongForkBound

Wrong fork bound, should be higher

BoundExceeded

Weight bound exceeded

InvalidCoinbasePosition

Coinbase tx must be the first transaction in the block

Trait Implementations

impl<T: Config> Debug for Error<T>

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

Formats the value using the given formatter.

impl<T> Decode for Error<T>

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T> Encode for Error<T>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> From<Error<T>> for &'static str

fn from(err: Error<T>) -> &'static str

Converts to this type from the input type.

impl<T: Config> From<Error<T>> for DispatchError

fn from(err: Error<T>) -> Self

Converts to this type from the input type.

impl<T: Config> From<Error> for Error<T>

fn from(err: BitcoinError) -> Self

Converts to this type from the input type.

impl<T> PalletError for Error<T>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T> TypeInfo for Error<T>where PhantomData<T>: TypeInfo + 'static, T: 'static,

type Identity = Error<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T> EncodeLike<Error<T>> for Error<T>