use crate::grin_core::core::{committed, transaction};
use crate::grin_core::libtx;
use crate::grin_keychain;
use crate::grin_store;
use crate::grin_util::secp;
use crate::util;
use failure::{Backtrace, Context, Fail};
use std::env;
use std::fmt::{self, Display};
use std::io;
#[derive(Debug, Fail)]
pub struct Error {
inner: Context<ErrorKind>,
}
#[derive(Clone, Eq, PartialEq, Debug, Fail, Serialize, Deserialize)]
pub enum ErrorKind {
#[fail(
display = "Not enough funds. Required: {}, Available: {}",
needed_disp, available_disp
)]
NotEnoughFunds {
available: u64,
available_disp: String,
needed: u64,
needed_disp: String,
},
#[fail(display = "Fee Error: {}", _0)]
Fee(String),
#[fail(display = "LibTx Error")]
LibTX(libtx::ErrorKind),
#[fail(display = "Keychain error")]
Keychain(grin_keychain::Error),
#[fail(display = "Transaction error")]
Transaction(transaction::Error),
#[fail(display = "Client Callback Error: {}", _0)]
ClientCallback(String),
#[fail(display = "Secp error")]
Secp(secp::Error),
#[fail(display = "Onion V3 Address Error")]
OnionV3Address(util::OnionV3AddressError),
#[fail(display = "Trait Implementation error")]
CallbackImpl(&'static str),
#[fail(display = "Wallet store error: {}", _0)]
Backend(String),
#[fail(display = "Restore Error")]
Restore,
#[fail(display = "JSON format error: {}", _0)]
Format(String),
#[fail(display = "Ser/Deserialization error")]
Deser(crate::grin_core::ser::Error),
#[fail(display = "I/O error")]
IO,
#[fail(display = "Node API error")]
Node,
#[fail(display = "Wallet Communication Error: {}", _0)]
WalletComms(String),
#[fail(display = "Hyper error")]
Hyper,
#[fail(display = "Uri parsing error")]
Uri,
#[fail(display = "Signature error: {}", _0)]
Signature(String),
#[fail(display = "{}", _0)]
APIEncryption(String),
#[fail(display = "Duplicate transaction ID error")]
DuplicateTransactionId,
#[fail(display = "Wallet seed exists error: {}", _0)]
WalletSeedExists(String),
#[fail(display = "Wallet seed doesn't exist error")]
WalletSeedDoesntExist,
#[fail(display = "Wallet seed decryption error")]
WalletSeedDecryption,
#[fail(display = "Transaction {} doesn't exist", _0)]
TransactionDoesntExist(String),
#[fail(display = "Transaction {} cannot be cancelled", _0)]
TransactionNotCancellable(String),
#[fail(display = "Cancellation Error: {}", _0)]
TransactionCancellationError(&'static str),
#[fail(display = "Tx dump Error: {}", _0)]
TransactionDumpError(&'static str),
#[fail(display = "Transaction already confirmed error")]
TransactionAlreadyConfirmed,
#[fail(display = "Transaction {} has already been received", _0)]
TransactionAlreadyReceived(String),
#[fail(display = "Transaction building not completed: {}", _0)]
TransactionBuildingNotCompleted(u32),
#[fail(display = "Invalid BIP32 Depth (must be 1 or greater)")]
InvalidBIP32Depth,
#[fail(display = "Account Label '{}' already exists", _0)]
AccountLabelAlreadyExists(String),
#[fail(display = "Unknown Account Label '{}'", _0)]
UnknownAccountLabel(String),
#[fail(display = "Committed Error")]
Committed(committed::Error),
#[fail(display = "Committed Error: {}", _0)]
Commit(String),
#[fail(display = "Can't parse slate version")]
SlateVersionParse,
#[fail(display = "Can't Serialize slate")]
SlateSer,
#[fail(display = "Can't Deserialize slate")]
SlateDeser,
#[fail(display = "Can't Serialize slatepack")]
SlatepackSer,
#[fail(display = "Can't Deserialize slatepack: {}", _0)]
SlatepackDeser(String),
#[fail(display = "Unknown Slate Version: {}", _0)]
SlateVersion(u16),
#[fail(display = "Slate transaction required in this context")]
SlateTransactionRequired,
#[fail(display = "Can't downgrade slate: {}", _0)]
SlateInvalidDowngrade(String),
#[fail(display = "Compatibility Error: {}", _0)]
Compatibility(String),
#[fail(display = "Keychain doesn't exist (has wallet been opened?)")]
KeychainDoesntExist,
#[fail(display = "Lifecycle Error: {}", _0)]
Lifecycle(String),
#[fail(display = "Supplied Keychain Mask Token is incorrect")]
InvalidKeychainMask,
#[fail(display = "Tor Process Error: {}", _0)]
TorProcess(String),
#[fail(display = "Tor Config Error: {}", _0)]
TorConfig(String),
#[fail(display = "Error generating ed25519 secret key: {}", _0)]
ED25519Key(String),
#[fail(display = "Payment Proof generation error: {}", _0)]
PaymentProof(String),
#[fail(display = "Payment Proof retrieval error: {}", _0)]
PaymentProofRetrieval(String),
#[fail(display = "Payment Proof parsing error: {}", _0)]
PaymentProofParsing(String),
#[fail(display = "Proof Address decoding: {}", _0)]
AddressDecoding(String),
#[fail(display = "Transaction Expired")]
TransactionExpired,
#[fail(display = "Kernel Features Arg {} missing", _0)]
KernelFeaturesMissing(String),
#[fail(display = "Unknown Kernel Feature: {}", _0)]
UnknownKernelFeatures(u8),
#[fail(display = "Invalid Kernel Feature: {}", _0)]
InvalidKernelFeatures(u8),
#[fail(display = "Invalid Slatepack Data: {}", _0)]
InvalidSlatepackData(String),
#[fail(display = "Couldn't encrypt Slatepack: {}", _0)]
SlatepackEncryption(String),
#[fail(display = "Couldn't decrypt Slatepack: {}", _0)]
SlatepackDecryption(String),
#[fail(display = "Age error: {}", _0)]
Age(String),
#[fail(display = "SlatepackAddress error: {}", _0)]
SlatepackAddress(String),
#[fail(display = "Stored Tx error: {}", _0)]
StoredTx(String),
#[fail(display = "Generic error: {}", _0)]
GenericError(String),
}
impl Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let show_bt = match env::var("RUST_BACKTRACE") {
Ok(r) => r == "1",
Err(_) => false,
};
let backtrace = match self.backtrace() {
Some(b) => format!("{}", b),
None => String::from("Unknown"),
};
let inner_output = format!("{}", self.inner,);
let backtrace_output = format!("\n Backtrace: {}", backtrace);
let mut output = inner_output;
if show_bt {
output.push_str(&backtrace_output);
}
Display::fmt(&output, f)
}
}
impl Error {
pub fn kind(&self) -> ErrorKind {
self.inner.get_context().clone()
}
pub fn cause_string(&self) -> String {
match self.cause() {
Some(k) => format!("{}", k),
None => "Unknown".to_string(),
}
}
pub fn cause(&self) -> Option<&dyn Fail> {
self.inner.cause()
}
pub fn backtrace(&self) -> Option<&Backtrace> {
self.inner.backtrace()
}
}
impl From<ErrorKind> for Error {
fn from(kind: ErrorKind) -> Error {
Error {
inner: Context::new(kind),
}
}
}
impl From<Context<ErrorKind>> for Error {
fn from(inner: Context<ErrorKind>) -> Error {
Error { inner: inner }
}
}
impl From<io::Error> for Error {
fn from(_error: io::Error) -> Error {
Error {
inner: Context::new(ErrorKind::IO),
}
}
}
impl From<grin_keychain::Error> for Error {
fn from(error: grin_keychain::Error) -> Error {
Error {
inner: Context::new(ErrorKind::Keychain(error)),
}
}
}
impl From<libtx::Error> for Error {
fn from(error: crate::grin_core::libtx::Error) -> Error {
Error {
inner: Context::new(ErrorKind::LibTX(error.kind())),
}
}
}
impl From<transaction::Error> for Error {
fn from(error: transaction::Error) -> Error {
Error {
inner: Context::new(ErrorKind::Transaction(error)),
}
}
}
impl From<crate::grin_core::ser::Error> for Error {
fn from(error: crate::grin_core::ser::Error) -> Error {
Error {
inner: Context::new(ErrorKind::Deser(error)),
}
}
}
impl From<secp::Error> for Error {
fn from(error: secp::Error) -> Error {
Error {
inner: Context::new(ErrorKind::Secp(error)),
}
}
}
impl From<committed::Error> for Error {
fn from(error: committed::Error) -> Error {
Error {
inner: Context::new(ErrorKind::Committed(error)),
}
}
}
impl From<grin_store::Error> for Error {
fn from(error: grin_store::Error) -> Error {
Error::from(ErrorKind::Backend(format!("{}", error)))
}
}
impl From<util::OnionV3AddressError> for Error {
fn from(error: util::OnionV3AddressError) -> Error {
Error::from(ErrorKind::OnionV3Address(error))
}
}
impl From<age::Error> for Error {
fn from(error: age::Error) -> Error {
Error {
inner: Context::new(ErrorKind::Age(format!("{}", error))),
}
}
}
impl From<bech32::Error> for Error {
fn from(error: bech32::Error) -> Error {
Error {
inner: Context::new(ErrorKind::SlatepackAddress(format!("{}", error))),
}
}
}