mirror of
https://github.com/jwinterm/grin-wallet.git
synced 2026-10-17 15:21:39 +02:00
YeastplumeandGitHub
6566fc184e
* add all comsig code, update to master branch * refactor code into libwallet, remove some redundancy and update type exports * added api calls and unit test for comsig request creation * Addition of JSON-RPC mwixnet function call * attempt to debug invalid params * additions to support json doctesting for comsig creation * tweaks to testing and documentation updates * dependencies for tests
364 lines
9.0 KiB
Rust
364 lines
9.0 KiB
Rust
// Copyright 2021 The Grin Developers
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
//! Error types for libwallet
|
|
|
|
use crate::grin_core::core::{committed, transaction};
|
|
use crate::grin_core::libtx;
|
|
use crate::grin_keychain;
|
|
use crate::grin_util::secp;
|
|
use crate::util;
|
|
use grin_store;
|
|
|
|
/// Wallet errors, mostly wrappers around underlying crypto or I/O errors.
|
|
#[derive(Clone, Eq, PartialEq, Debug, thiserror::Error, Serialize, Deserialize)]
|
|
pub enum Error {
|
|
/// Not enough funds
|
|
#[error("Not enough funds. Required: {needed_disp:?}, Available: {available_disp:?}")]
|
|
NotEnoughFunds {
|
|
/// available funds
|
|
available: u64,
|
|
/// Display friendly
|
|
available_disp: String,
|
|
/// Needed funds
|
|
needed: u64,
|
|
/// Display friendly
|
|
needed_disp: String,
|
|
},
|
|
|
|
/// Fee error
|
|
#[error("Fee Error: {0}")]
|
|
Fee(String),
|
|
|
|
/// LibTX Error
|
|
#[error("LibTx Error")]
|
|
LibTX(#[from] libtx::Error),
|
|
|
|
/// Keychain error
|
|
#[error("Keychain error")]
|
|
Keychain(#[from] grin_keychain::Error),
|
|
|
|
/// Transaction Error
|
|
#[error("Transaction error")]
|
|
Transaction(#[from] transaction::Error),
|
|
|
|
/// API Error
|
|
#[error("Client Callback Error: {0}")]
|
|
ClientCallback(String),
|
|
|
|
/// Error from underlying secp lib
|
|
#[error("Secp Lib Error")]
|
|
Secp(#[from] secp::Error),
|
|
|
|
/// Onion V3 Address Error
|
|
#[error("Onion V3 Address Error: {0}")]
|
|
OnionV3Address(#[from] util::OnionV3AddressError),
|
|
|
|
/// Callback implementation error conversion
|
|
#[error("Trait Implementation error")]
|
|
CallbackImpl(&'static str),
|
|
|
|
/// Wallet backend error
|
|
#[error("Wallet store error: {0}")]
|
|
Backend(String),
|
|
|
|
/// Callback implementation error conversion
|
|
#[error("Restore Error")]
|
|
Restore,
|
|
|
|
/// An error in the format of the JSON structures exchanged by the wallet
|
|
#[error("JSON format error: {0}")]
|
|
Format(String),
|
|
|
|
/// Other serialization errors
|
|
#[error("Ser/Deserialization error")]
|
|
Deser(crate::grin_core::ser::Error),
|
|
|
|
/// IO Error
|
|
#[error("I/O error {0}")]
|
|
IO(String),
|
|
|
|
/// Error when contacting a node through its API
|
|
#[error("Node API error")]
|
|
Node,
|
|
|
|
/// Error contacting wallet API
|
|
#[error("Wallet Communication Error: {0}")]
|
|
WalletComms(String),
|
|
|
|
/// Error originating from hyper.
|
|
#[error("Hyper error")]
|
|
Hyper,
|
|
|
|
/// Error originating from hyper uri parsing.
|
|
#[error("Uri parsing error")]
|
|
Uri,
|
|
|
|
/// Signature error
|
|
#[error("Signature error: {0}")]
|
|
Signature(String),
|
|
|
|
/// OwnerAPIEncryption
|
|
#[error("{}", _0)]
|
|
APIEncryption(String),
|
|
|
|
/// Attempt to use duplicate transaction id in separate transactions
|
|
#[error("Duplicate transaction ID error")]
|
|
DuplicateTransactionId,
|
|
|
|
/// Wallet seed already exists
|
|
#[error("Wallet seed exists error: {0}")]
|
|
WalletSeedExists(String),
|
|
|
|
/// Wallet seed doesn't exist
|
|
#[error("Wallet seed doesn't exist error")]
|
|
WalletSeedDoesntExist,
|
|
|
|
/// Wallet seed doesn't exist
|
|
#[error("Wallet seed decryption error")]
|
|
WalletSeedDecryption,
|
|
|
|
/// Transaction doesn't exist
|
|
#[error("Transaction {0} doesn't exist")]
|
|
TransactionDoesntExist(String),
|
|
|
|
/// Transaction already rolled back
|
|
#[error("Transaction {0} cannot be cancelled")]
|
|
TransactionNotCancellable(String),
|
|
|
|
/// Cancellation error
|
|
#[error("Cancellation Error: {0}")]
|
|
TransactionCancellationError(&'static str),
|
|
|
|
/// Cancellation error
|
|
#[error("Tx dump Error: {0}")]
|
|
TransactionDumpError(&'static str),
|
|
|
|
/// Attempt to repost a transaction that's already confirmed
|
|
#[error("Transaction already confirmed error")]
|
|
TransactionAlreadyConfirmed,
|
|
|
|
/// Transaction has already been received
|
|
#[error("Transaction {0} has already been received")]
|
|
TransactionAlreadyReceived(String),
|
|
|
|
/// Transaction has been cancelled
|
|
#[error("Transaction {0} has been cancelled")]
|
|
TransactionWasCancelled(String),
|
|
|
|
/// Attempt to repost a transaction that's not completed and stored
|
|
#[error("Transaction building not completed: {0}")]
|
|
TransactionBuildingNotCompleted(u32),
|
|
|
|
/// Invalid BIP-32 Depth
|
|
#[error("Invalid BIP32 Depth (must be 1 or greater)")]
|
|
InvalidBIP32Depth,
|
|
|
|
/// Attempt to add an account that exists
|
|
#[error("Account Label '{0}' already exists")]
|
|
AccountLabelAlreadyExists(String),
|
|
|
|
/// Reference unknown account label
|
|
#[error("Unknown Account Label '{0}'")]
|
|
UnknownAccountLabel(String),
|
|
|
|
/// Error from summing commitments via committed trait.
|
|
#[error("Committed Error")]
|
|
Committed(committed::Error),
|
|
|
|
/// Error from summing commitments
|
|
#[error("Committed Error: {0}")]
|
|
Commit(String),
|
|
|
|
/// Error Deserializing commit
|
|
#[error("Commit Deserialize Error: {0}")]
|
|
CommitDeser(String),
|
|
|
|
/// Error Deserializing key
|
|
#[error("Server Key Deserialize Error: {0}")]
|
|
ServerKeyDeser(String),
|
|
|
|
/// Parsing integert
|
|
#[error("Can't parse as u64: {0}")]
|
|
U64Deser(String),
|
|
|
|
/// Can't parse slate version
|
|
#[error("Can't parse slate version")]
|
|
SlateVersionParse,
|
|
|
|
/// Can't serialize slate
|
|
#[error("Can't Serialize slate")]
|
|
SlateSer,
|
|
|
|
/// Can't deserialize slate
|
|
#[error("Can't Deserialize slate")]
|
|
SlateDeser,
|
|
|
|
/// Invalid slate state
|
|
#[error("Invalid slate state")]
|
|
SlateState,
|
|
|
|
/// Can't serialize slate pack
|
|
#[error("Can't Serialize slatepack")]
|
|
SlatepackSer,
|
|
|
|
/// Can't deserialize slate
|
|
#[error("Can't Deserialize slatepack: {0}")]
|
|
SlatepackDeser(String),
|
|
|
|
/// Unknown slate version
|
|
#[error("Unknown Slate Version: {0}")]
|
|
SlateVersion(u16),
|
|
|
|
/// Attempt to use slate transaction data that doesn't exists
|
|
#[error("Slate transaction required in this context")]
|
|
SlateTransactionRequired,
|
|
|
|
/// Attempt to downgrade slate that can't be downgraded
|
|
#[error("Can't downgrade slate: {0}")]
|
|
SlateInvalidDowngrade(String),
|
|
|
|
/// Compatibility error between incoming slate versions and what's expected
|
|
#[error("Compatibility Error: {0}")]
|
|
Compatibility(String),
|
|
|
|
/// Keychain doesn't exist (wallet not openend)
|
|
#[error("Keychain doesn't exist (has wallet been opened?)")]
|
|
KeychainDoesntExist,
|
|
|
|
/// Lifecycle Error
|
|
#[error("Lifecycle Error: {0}")]
|
|
Lifecycle(String),
|
|
|
|
/// Invalid Keychain Mask Error
|
|
#[error("Supplied Keychain Mask Token is incorrect")]
|
|
InvalidKeychainMask,
|
|
|
|
/// Tor Process error
|
|
#[error("Tor Process Error: {0}")]
|
|
TorProcess(String),
|
|
|
|
/// Tor Configuration Error
|
|
#[error("Tor Config Error: {0}")]
|
|
TorConfig(String),
|
|
|
|
/// Generating ED25519 Public Key
|
|
#[error("Error generating ed25519 secret key: {0}")]
|
|
ED25519Key(String),
|
|
|
|
/// Generating Payment Proof
|
|
#[error("Payment Proof generation error: {0}")]
|
|
PaymentProof(String),
|
|
|
|
/// Retrieving Payment Proof
|
|
#[error("Payment Proof retrieval error: {0}")]
|
|
PaymentProofRetrieval(String),
|
|
|
|
/// Retrieving Payment Proof
|
|
#[error("Payment Proof parsing error: {0}")]
|
|
PaymentProofParsing(String),
|
|
|
|
/// Decoding OnionV3 addresses to payment proof addresses
|
|
#[error("Proof Address decoding: {0}")]
|
|
AddressDecoding(String),
|
|
|
|
/// Transaction has expired it's TTL
|
|
#[error("Transaction Expired")]
|
|
TransactionExpired,
|
|
|
|
/// Kernel features args don't exist
|
|
#[error("Kernel Features Arg {0} missing")]
|
|
KernelFeaturesMissing(String),
|
|
|
|
/// Unknown Kernel Feature
|
|
#[error("Unknown Kernel Feature: {0}")]
|
|
UnknownKernelFeatures(u8),
|
|
|
|
/// Invalid Kernel Feature
|
|
#[error("Invalid Kernel Feature: {0}")]
|
|
InvalidKernelFeatures(u8),
|
|
|
|
/// Invalid Slatepack Data
|
|
#[error("Invalid Slatepack Data: {0}")]
|
|
InvalidSlatepackData(String),
|
|
|
|
/// Slatepack Encryption
|
|
#[error("Couldn't encrypt Slatepack: {0}")]
|
|
SlatepackEncryption(String),
|
|
|
|
/// Slatepack Decryption
|
|
#[error("Couldn't decrypt Slatepack: {0}")]
|
|
SlatepackDecryption(String),
|
|
|
|
/// age error
|
|
#[error("Age error: {0}")]
|
|
Age(String),
|
|
|
|
/// Rewind Hash parsing error
|
|
#[error("Rewind Hash error: {0}")]
|
|
RewindHash(String),
|
|
|
|
/// Nonce creation error
|
|
#[error("Nonce error: {0}")]
|
|
Nonce(String),
|
|
|
|
/// Slatepack address parsing error
|
|
#[error("SlatepackAddress error: {0}")]
|
|
SlatepackAddress(String),
|
|
|
|
/// Retrieving Stored Tx
|
|
#[error("Stored Tx error: {0}")]
|
|
StoredTx(String),
|
|
|
|
/// Other
|
|
#[error("Generic error: {0}")]
|
|
GenericError(String),
|
|
}
|
|
|
|
impl From<grin_store::Error> for Error {
|
|
fn from(error: grin_store::Error) -> Error {
|
|
Error::Backend(format!("{}", error))
|
|
}
|
|
}
|
|
|
|
impl From<age::EncryptError> for Error {
|
|
fn from(error: age::EncryptError) -> Error {
|
|
Error::Age(format!("{}", error))
|
|
}
|
|
}
|
|
|
|
impl From<age::DecryptError> for Error {
|
|
fn from(error: age::DecryptError) -> Error {
|
|
Error::Age(format!("{}", error))
|
|
}
|
|
}
|
|
|
|
impl From<std::io::Error> for Error {
|
|
fn from(e: std::io::Error) -> Error {
|
|
Error::IO(e.to_string())
|
|
}
|
|
}
|
|
|
|
impl From<&str> for Error {
|
|
fn from(error: &str) -> Error {
|
|
Error::Age(format!("Bech32 Key Encoding - {}", error))
|
|
}
|
|
}
|
|
|
|
impl From<bech32::Error> for Error {
|
|
fn from(error: bech32::Error) -> Error {
|
|
Error::SlatepackAddress(format!("{}", error))
|
|
}
|
|
}
|