lfest 0.77.0

A leveraged perpetual futures exchange for simulated trading and backtesting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use tracing::trace;

use super::{
    account::TAccount, transaction::Transaction, utils::debug_assert_accounting_equation,
    AccountId, TransactionAccounting,
};
use crate::{
    types::{Error, MarginCurrency},
    Result,
};

const N_ACCOUNTS: usize = 6;
// The accounts denoted in the margin currency.
/// The users wallet account.
pub const USER_WALLET_ACCOUNT: usize = 0;
/// The users order margin account
pub const USER_ORDER_MARGIN_ACCOUNT: usize = 1;
/// The users position margin account.
pub const USER_POSITION_MARGIN_ACCOUNT: usize = 2;
/// The exchanges fee account.
pub const EXCHANGE_FEE_ACCOUNT: usize = 3;
/// The brokers margin account.
pub const BROKER_MARGIN_ACCOUNT: usize = 4;
/// The treasury account.
pub const TREASURY_ACCOUNT: usize = 5;

/// Keeps track of transaction in memory.
#[derive(Debug)]
pub struct InMemoryTransactionAccounting<M>
where
    M: MarginCurrency,
{
    /// Accounts are allocated at the start as they are known upfront.
    margin_accounts: [TAccount<M>; N_ACCOUNTS],
    // TODO: keep track of transaction log or emit `Transactions` to users.
}

impl<M> TransactionAccounting<M> for InMemoryTransactionAccounting<M>
where
    M: MarginCurrency,
{
    fn new(user_starting_wallet_balance: M) -> Self {
        let mut s = Self {
            margin_accounts: [TAccount::default(); N_ACCOUNTS],
        };
        s.margin_accounts[USER_WALLET_ACCOUNT].post_debit(user_starting_wallet_balance);
        s.margin_accounts[TREASURY_ACCOUNT].post_credit(user_starting_wallet_balance);
        debug_assert_accounting_equation(&s.margin_accounts);

        s
    }

    fn create_margin_transfer(&mut self, transaction: Transaction<M>) -> Result<()> {
        trace!("create_margin_transfer: {transaction:?}");
        let mut debit_account = self
            .margin_accounts
            .get(transaction.debit_account_id())
            .cloned()
            .ok_or(Error::AccountLookupFailure)?;
        let credit_account = self
            .margin_accounts
            .get_mut(transaction.credit_account_id())
            .ok_or(Error::AccountLookupFailure)?;

        let amnt = transaction.amount();
        debit_account.post_debit(amnt);
        credit_account.post_credit(amnt);

        self.margin_accounts[transaction.debit_account_id()] = debit_account;

        debug_assert_accounting_equation(&self.margin_accounts);

        Ok(())
    }

    fn margin_balance_of(&self, account: AccountId) -> Result<M> {
        self.margin_accounts
            .get(account)
            .ok_or(Error::AccountLookupFailure)
            .map(|account| account.net_balance())
    }
}