Skip to content

refactor: implement unified CoreError enum and migrate 14 contracts #638

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
benedictworks-home wants to merge 1 commit into
base: main
Choose a base branch
from
+436 −3
Open

refactor: implement unified CoreError enum and migrate 14 contracts #638

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 20 additions & 0 deletions contracts/batch/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@
#![allow(clippy::too_many_arguments)]

use soroban_sdk::{contract, contracterror, contractimpl, contracttype, Address, Env, Vec};
use subtrackr_types::CoreError;

const MAX_BATCH_ITEMS: u32 = 100;
const GAS_BASE: u64 = 50_000;
Expand All @@ -15,6 +16,25 @@ pub enum BatchError {
AlreadyExecuted = 2,
}

impl From<BatchError> for CoreError {
fn from(err: BatchError) -> Self {
match err {
BatchError::InvalidBatch => CoreError::InvalidConfig,
BatchError::AlreadyExecuted => CoreError::InvalidStateTransition,
}
}
}

impl From<CoreError> for BatchError {
fn from(err: CoreError) -> Self {
match err {
CoreError::InvalidConfig => BatchError::InvalidBatch,
CoreError::InvalidStateTransition => BatchError::AlreadyExecuted,
_ => BatchError::InvalidBatch,
}
}
}

#[contracttype]
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum OperationType {
Expand Down
29 changes: 28 additions & 1 deletion contracts/credit/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@
use soroban_sdk::{
contract, contracterror, contractimpl, contracttype, symbol_short, Address, Env, String, Vec,
};
use subtrackr_types::SubscriptionId;
use subtrackr_types::{SubscriptionId, CoreError};

/// Maximum retained transaction-history and lot entries per account.
const MAX_HISTORY: u32 = 128;
Expand All @@ -35,6 +35,33 @@ pub enum CreditError {
SelfTransfer = 6,
}

impl From<CreditError> for CoreError {
fn from(err: CreditError) -> Self {
match err {
CreditError::AlreadyInitialized => CoreError::AlreadyInitialized,
CreditError::NotInitialized => CoreError::NotInitialized,
CreditError::Unauthorized => CoreError::Unauthorized,
CreditError::InvalidAmount => CoreError::InvalidAmount,
CreditError::InsufficientCredit => CoreError::InsufficientCredit,
CreditError::SelfTransfer => CoreError::SelfTransfer,
}
}
}

impl From<CoreError> for CreditError {
fn from(err: CoreError) -> Self {
match err {
CoreError::AlreadyInitialized => CreditError::AlreadyInitialized,
CoreError::NotInitialized => CreditError::NotInitialized,
CoreError::Unauthorized => CreditError::Unauthorized,
CoreError::InvalidAmount => CreditError::InvalidAmount,
CoreError::InsufficientCredit => CreditError::InsufficientCredit,
CoreError::SelfTransfer => CreditError::SelfTransfer,
_ => CreditError::InvalidAmount,
}
}
}

#[contracttype]
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CreditTxKind {
Expand Down
23 changes: 23 additions & 0 deletions contracts/metering/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,8 @@ const DEFAULT_PERIOD_SECS: u64 = 86_400;
/// Maximum number of retained period buckets per meter (~one quarter of days).
const MAX_BUCKETS: u32 = 90;

use subtrackr_types::CoreError;

#[contracterror]
#[derive(Clone, Debug, Copy, PartialEq, Eq)]
#[repr(u32)]
Expand All @@ -45,6 +47,27 @@ pub enum MeteringError {
MeterNotFound = 3,
}

impl From<MeteringError> for CoreError {
fn from(err: MeteringError) -> Self {
match err {
MeteringError::InvalidValue => CoreError::InvalidAmount,
MeteringError::InvalidPeriod => CoreError::InvalidInterval,
MeteringError::MeterNotFound => CoreError::NotFound,
}
}
}

impl From<CoreError> for MeteringError {
fn from(err: CoreError) -> Self {
match err {
CoreError::InvalidAmount => MeteringError::InvalidValue,
CoreError::InvalidInterval => MeteringError::InvalidPeriod,
CoreError::NotFound => MeteringError::MeterNotFound,
_ => MeteringError::InvalidValue,
}
}
}

#[contracttype]
#[derive(Clone)]
enum DataKey {
Expand Down
42 changes: 41 additions & 1 deletion contracts/oracle/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,8 +23,9 @@ pub use price::{
};

use soroban_sdk::{
contract, contracterror, contractimpl, contracttype, symbol_short, Address, Env, Symbol,
contract, contractimpl, contracttype, symbol_short, Address, Env, Symbol,
};
use subtrackr_types::CoreError;

/// Number of consecutive faults that trips a feed's circuit breaker.
const CIRCUIT_FAULT_LIMIT: u32 = 3;
Expand All @@ -51,6 +52,45 @@ pub enum OracleError {
InvalidConfig = 12,
}

impl From<OracleError> for CoreError {
fn from(err: OracleError) -> Self {
match err {
OracleError::AlreadyInitialized => CoreError::AlreadyInitialized,
OracleError::NotInitialized => CoreError::NotInitialized,
OracleError::Unauthorized => CoreError::Unauthorized,
OracleError::FeedNotFound => CoreError::FeedNotFound,
OracleError::FeedExists => CoreError::FeedExists,
OracleError::InvalidPrice => CoreError::InvalidPrice,
OracleError::InvalidTimestamp => CoreError::InvalidTimestamp,
OracleError::NoPriceAvailable => CoreError::NoPriceAvailable,
OracleError::StalePrice => CoreError::StalePrice,
OracleError::CircuitOpen => CoreError::CircuitOpen,
OracleError::NoHistory => CoreError::NoHistory,
OracleError::InvalidConfig => CoreError::InvalidConfig,
}
}
}

impl From<CoreError> for OracleError {
fn from(err: CoreError) -> Self {
match err {
CoreError::AlreadyInitialized => OracleError::AlreadyInitialized,
CoreError::NotInitialized => OracleError::NotInitialized,
CoreError::Unauthorized => OracleError::Unauthorized,
CoreError::FeedNotFound => OracleError::FeedNotFound,
CoreError::FeedExists => OracleError::FeedExists,
CoreError::InvalidPrice => OracleError::InvalidPrice,
CoreError::InvalidTimestamp => OracleError::InvalidTimestamp,
CoreError::NoPriceAvailable => OracleError::NoPriceAvailable,
CoreError::StalePrice => OracleError::StalePrice,
CoreError::CircuitOpen => OracleError::CircuitOpen,
CoreError::NoHistory => OracleError::NoHistory,
CoreError::InvalidConfig => OracleError::InvalidConfig,
_ => OracleError::InvalidConfig,
}
}
}

#[contracttype]
#[derive(Clone)]
enum DataKey {
Expand Down
76 changes: 76 additions & 0 deletions contracts/subscription/src/errors.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,6 +43,7 @@
//! | 30 | ChainReorgDetected | Chain reorganisation detected during timeout window. |

use soroban_sdk::contracterror;
use subtrackr_types::CoreError;

#[contracterror]
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
Expand Down Expand Up @@ -156,6 +157,81 @@ impl ContractError {
}
}

impl From<ContractError> for CoreError {
fn from(err: ContractError) -> Self {
match err {
ContractError::Unauthorized => CoreError::Unauthorized,
ContractError::PlanNotFound => CoreError::PlanNotFound,
ContractError::PlanInactive => CoreError::PlanInactive,
ContractError::SubscriptionNotFound => CoreError::SubscriptionNotFound,
ContractError::AlreadySubscribed => CoreError::AlreadySubscribed,
ContractError::SubscriptionNotActive => CoreError::SubscriptionNotActive,
ContractError::SubscriptionAlreadyCancelled => CoreError::SubscriptionAlreadyCancelled,
ContractError::SubscriptionAlreadyPaused => CoreError::SubscriptionAlreadyPaused,
ContractError::SubscriptionNotPaused => CoreError::SubscriptionNotPaused,
ContractError::PaymentNotYetDue => CoreError::PaymentNotYetDue,
ContractError::InsufficientAllowance => CoreError::InsufficientFunds,
ContractError::InvalidAmount => CoreError::InvalidAmount,
ContractError::InvalidInterval => CoreError::InvalidInterval,
ContractError::InvalidPriceBounds => CoreError::InvalidPriceBounds,
ContractError::MaxPauseDurationExceeded => CoreError::MaxPauseDurationExceeded,
ContractError::RateLimited => CoreError::RateLimited,
ContractError::OracleUnavailable => CoreError::OracleUnavailable,
ContractError::StorageVersionMismatch => CoreError::StorageVersionMismatch,
ContractError::InvalidMigrationPath => CoreError::InvalidMigrationPath,
ContractError::RefundExceedsTotalPaid => CoreError::RefundExceedsTotalPaid,
ContractError::PlanOwnerMismatch => CoreError::OwnerMismatch,
ContractError::EventNotFound => CoreError::EventNotFound,
ContractError::EventStoreFull => CoreError::EventStoreFull,
ContractError::InvalidEventSequence => CoreError::InvalidEventSequence,
ContractError::ExportWindowExceeded => CoreError::ExportWindowExceeded,
ContractError::PaymentTimedOut => CoreError::PaymentTimedOut,
ContractError::RecoveryAttemptsExhausted => CoreError::RecoveryAttemptsExhausted,
ContractError::TransactionNotRecoverable => CoreError::TransactionNotRecoverable,
ContractError::InvalidTimeoutConfig => CoreError::InvalidTimeoutConfig,
ContractError::ChainReorgDetected => CoreError::ChainReorgDetected,
}
}
}

impl From<CoreError> for ContractError {
fn from(err: CoreError) -> Self {
match err {
CoreError::Unauthorized => ContractError::Unauthorized,
CoreError::PlanNotFound => ContractError::PlanNotFound,
CoreError::PlanInactive => ContractError::PlanInactive,
CoreError::SubscriptionNotFound => ContractError::SubscriptionNotFound,
CoreError::AlreadySubscribed => ContractError::AlreadySubscribed,
CoreError::SubscriptionNotActive => ContractError::SubscriptionNotActive,
CoreError::SubscriptionAlreadyCancelled => ContractError::SubscriptionAlreadyCancelled,
CoreError::SubscriptionAlreadyPaused => ContractError::SubscriptionAlreadyPaused,
CoreError::SubscriptionNotPaused => ContractError::SubscriptionNotPaused,
CoreError::PaymentNotYetDue => ContractError::PaymentNotYetDue,
CoreError::InsufficientFunds => ContractError::InsufficientAllowance,
CoreError::InvalidAmount => ContractError::InvalidAmount,
CoreError::InvalidInterval => ContractError::InvalidInterval,
CoreError::InvalidPriceBounds => ContractError::InvalidPriceBounds,
CoreError::MaxPauseDurationExceeded => ContractError::MaxPauseDurationExceeded,
CoreError::RateLimited => ContractError::RateLimited,
CoreError::OracleUnavailable => ContractError::OracleUnavailable,
CoreError::StorageVersionMismatch => ContractError::StorageVersionMismatch,
CoreError::InvalidMigrationPath => ContractError::InvalidMigrationPath,
CoreError::RefundExceedsTotalPaid => ContractError::RefundExceedsTotalPaid,
CoreError::OwnerMismatch => ContractError::PlanOwnerMismatch,
CoreError::EventNotFound => ContractError::EventNotFound,
CoreError::EventStoreFull => ContractError::EventStoreFull,
CoreError::InvalidEventSequence => ContractError::InvalidEventSequence,
CoreError::ExportWindowExceeded => ContractError::ExportWindowExceeded,
CoreError::PaymentTimedOut => ContractError::PaymentTimedOut,
CoreError::RecoveryAttemptsExhausted => ContractError::RecoveryAttemptsExhausted,
CoreError::TransactionNotRecoverable => ContractError::TransactionNotRecoverable,
CoreError::InvalidTimeoutConfig => ContractError::InvalidTimeoutConfig,
CoreError::ChainReorgDetected => ContractError::ChainReorgDetected,
_ => ContractError::InvalidAmount,
}
}
}

// ─── Tests ────────────────────────────────────────────────────────────────────

#[cfg(test)]
Expand Down
Loading