示例#1
0
def test_balance_calculation_out_canceled() -> None:
    account_id = 1
    counter_id = 0
    income = Transaction(
        source_id=counter_id,
        destination_id=account_id,
        amount=100,
        currency=DiemCurrency.XUS,
        status=TransactionStatus.COMPLETED,
    )
    outgoing = Transaction(
        source_id=account_id,
        destination_id=counter_id,
        amount=50,
        currency=DiemCurrency.XUS,
        status=TransactionStatus.CANCELED,
    )
    balance = calc_account_balance(account_id=account_id,
                                   transactions=[income, outgoing])

    assert balance.total == {
        DiemCurrency.XUS: 100,
    }
    assert balance.frozen == {
        DiemCurrency.XUS: 0,
    }
示例#2
0
def add_outgoing_user_transaction_to_db(amount, account_name, receiver_address,
                                        sender_sub_address, sequence, user,
                                        version):
    user_account_id = Account.query.filter_by(name=account_name).first().id
    tx = Transaction(
        amount=amount,
        source_address=VASP_ADDRESS,
        destination_address=receiver_address,
    )

    if version is not None:
        tx.blockchain_version = version

    if sequence is not None:
        tx.sequence = sequence

    tx.created_timestamp = datetime.now()
    tx.type = TransactionType.EXTERNAL
    tx.currency = CURRENCY
    tx.status = TransactionStatus.COMPLETED
    tx.source_id = user.id
    tx.source_subaddress = sender_sub_address
    user.account.sent_transactions.append(tx)

    db_session.add(
        SubAddress(address=sender_sub_address, account_id=user_account_id))

    db_session.commit()
    def run(
        db_session,
        account_amount: int,
        account_currency: DiemCurrency,
        inventory_amount: int,
        inventory_currency: DiemCurrency,
        convert_from_amount: int,
        convert_to_amount: int,
    ) -> Tuple[int, int, Order]:
        user = deepcopy(prototypes.user)
        user.account = Account(name="fake_account_seed")
        inventory_account = Account(name=INVENTORY_ACCOUNT_NAME)
        db_session.add(user)
        db_session.add(inventory_account)
        db_session.commit()

        inventory_income = Transaction(
            created_timestamp=datetime.now(),
            amount=inventory_amount,
            currency=inventory_currency,
            type=TransactionType.EXTERNAL,
            status=TransactionStatus.COMPLETED,
            source_address="lp",
            destination_id=inventory_account.id,
        )
        inventory_account.received_transactions.append(inventory_income)
        user_income = Transaction(
            created_timestamp=datetime.now(),
            amount=account_amount,
            currency=account_currency,
            type=TransactionType.EXTERNAL,
            status=TransactionStatus.COMPLETED,
            source_address="na",
            destination_id=user.account.id,
        )
        user.account.received_transactions.append(user_income)
        order = Order(
            amount=convert_from_amount,
            direction=Direction.Buy,
            base_currency=account_currency,
            quote_currency=inventory_currency,
            order_status=OrderStatus.PendingExecution,
            cover_status=CoverStatus.PendingCover,
            order_expiration=datetime.utcnow() + timedelta(minutes=10),
            exchange_amount=convert_to_amount,
            order_type=OrderType.DirectConvert,
        )
        user.orders.append(order)
        db_session.add(order)
        db_session.commit()

        return inventory_account.id, user.account.id, order
示例#4
0
 def send_mock(
     sender_id: int,
     amount: int,
     currency: DiemCurrency,
     destination_address: str,
     destination_subaddress: Optional[str] = None,
     payment_type: Optional[TransactionType] = None,
 ) -> Optional[Transaction]:
     saved.update({
         "sender_id": sender_id,
         "amount": amount,
         "currency": currency,
         "destination_address": destination_address,
         "destination_subaddress": destination_subaddress,
         "payment_type": payment_type,
     })
     tx = Transaction(
         id=5,
         type=TransactionType.EXTERNAL.value,
         amount=amount,
         currency=currency.value,
         status=TransactionStatus.PENDING.value,
         source_id=sender_id,
         source_subaddress="122ce7420f15bec5",
         source_address="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         destination_address=destination_address,
         destination_subaddress=destination_subaddress,
         created_timestamp=datetime.fromisoformat(
             "2020-06-23T19:50:26.989849"),
         blockchain_version=55,
         sequence=10,
     )
     return tx
示例#5
0
def add_inventory_account_with_initial_funds_to_db(amount):
    inventory_user = User(
        username=INVENTORY_ACCOUNT_NAME,
        registration_status=RegistrationStatus.Approved,
        selected_fiat_currency=FiatCurrency.USD,
        selected_language="en",
        password_salt="123",
        password_hash="deadbeef",
    )

    inventory_user.account = Account(name=INVENTORY_ACCOUNT_NAME)

    tx = Transaction(
        created_timestamp=datetime.now(),
        amount=amount,
        currency=CURRENCY,
        type=TransactionType.EXTERNAL,
        status=TransactionStatus.COMPLETED,
        sequence=0,
        blockchain_version=0,
        source_address=DD_ADDRESS,
        destination_address=VASP_ADDRESS,
        destination_id=inventory_user.id,
    )

    inventory_user.account.received_transactions.append(tx)

    db_session.add(inventory_user)
    db_session.commit()
示例#6
0
    def run(
        db_session,
        account_amount: Optional[int] = None,
        account_currency: Optional[DiemCurrency] = None,
        registration_status: Optional[RegistrationStatus] = RegistrationStatus.
        Approved,
        account_name: str = "fake_account",
        username: Optional[str] = None,
    ) -> User:
        user = deepcopy(prototypes.user)

        if username:
            user.username = username
            user.first_name = f"{username} first name"
            user.last_name = f"{username} last name"
        user.registration_status = registration_status
        user.account = Account(name=account_name)
        db_session.add(user)
        db_session.commit()

        if account_amount and account_currency:
            user_income = Transaction(
                created_timestamp=datetime.now(),
                amount=account_amount,
                currency=account_currency,
                type=TransactionType.EXTERNAL,
                status=TransactionStatus.COMPLETED,
                source_address="na",
                destination_id=user.account.id,
            )
            user.account.received_transactions.append(user_income)
            db_session.commit()

        return user
示例#7
0
def test_balance_calculation_simple_income() -> None:
    account_id = 1
    counter_id = 0
    tx = Transaction(
        source_id=counter_id,
        destination_id=account_id,
        amount=100,
        currency=DiemCurrency.XUS,
        status=TransactionStatus.COMPLETED,
    )
    balance = calc_account_balance(account_id=account_id, transactions=[tx])

    assert balance.total == {
        DiemCurrency.XUS: 100,
    }
def test_balance_calculation_in_pending() -> None:
    account_id = 1
    counter_id = 0
    income = Transaction(
        source_id=counter_id,
        destination_id=account_id,
        amount=100,
        currency=DiemCurrency.Coin1,
        status=TransactionStatus.PENDING,
    )
    balance = calc_account_balance(account_id=account_id, transactions=[income])

    assert balance.total == {
        DiemCurrency.Coin1: 0,
    }
def test_balance_calculation_in_and_out() -> None:
    account_id = 1
    counter_id = 0
    income = Transaction(
        source_id=counter_id,
        destination_id=account_id,
        amount=100,
        currency=DiemCurrency.Coin1,
        status=TransactionStatus.COMPLETED,
    )
    outgoing = Transaction(
        source_id=account_id,
        destination_id=counter_id,
        amount=50,
        currency=DiemCurrency.Coin1,
        status=TransactionStatus.COMPLETED,
    )
    balance = calc_account_balance(
        account_id=account_id, transactions=[income, outgoing]
    )

    assert balance.total == {
        DiemCurrency.Coin1: 50,
    }
示例#10
0
def add_inventory_account_with_initial_funds_to_db(amount):
    inventory_user = add_inventory_account_to_db()

    tx = Transaction(
        created_timestamp=datetime.now(),
        amount=amount,
        currency=CURRENCY,
        type=TransactionType.EXTERNAL,
        status=TransactionStatus.COMPLETED,
        sequence=0,
        blockchain_version=0,
        source_address=DD_ADDRESS,
        destination_address=VASP_ADDRESS,
        destination_id=inventory_user.id,
    )

    inventory_user.account.received_transactions.append(tx)

    db_session.add(inventory_user)
    db_session.commit()
示例#11
0
from wallet.storage import Transaction
from wallet.types import (
    Balance,
    TransactionDirection,
    TransactionStatus,
    TransactionType,
    TransactionSortOption,
)

INTERNAL_TX = Transaction(
    id=1,
    type=TransactionType.INTERNAL.value,
    amount=100,
    currency=DiemCurrency.Coin1.value,
    status=TransactionStatus.COMPLETED.value,
    source_id=1,
    source_address="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    source_subaddress="863bc063df8b2bf3",
    destination_id=2,
    destination_address="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    destination_subaddress="75b12ccd3ab503a6",
    created_timestamp=datetime.fromisoformat("2020-06-23T19:49:26.989849"),
)
FULL_ADDRESS = "tlb1pztdjx2z8wp0q25jakqeklk0nxj2wmk2kg9whu8cxdewwy"


@pytest.fixture
def allow_user_to_account(monkeypatch):
    monkeypatch.setattr(account_service, "is_user_allowed_for_account",
                        lambda user, account_name: True)

示例#12
0
    password_hash="deadbeef",
)

order = Order(
    amount=10,
    direction=Direction.Buy.value,
    base_currency=Currency.Coin1,
    quote_currency=Currency.USD,
    order_status=OrderStatus.PendingExecution,
    cover_status=CoverStatus.PendingCover,
    payment_method="payment_method",
    exchange_amount=10,
    order_expiration=datetime.utcnow() + timedelta(minutes=10),
    order_type=OrderType.Trade,
)

tx = Transaction(
    amount=1000000,
    currency="Coin1",
    type="transfer_internal",
    status="completed",
    created_timestamp=datetime.utcnow(),
    source_id=0,
    source_address="source_address",
    source_subaddress="source_subaddress",
    destination_id=1,
    destination_address="destination_address",
    destination_subaddress="destination_subaddress",
    sequence=1,
)