influenceth / cairo-math-64x61 Goto Github PK

func ceil_spec{range_check_ptr}():
    alloc_locals
    let (local x) = SymbolicMath64x61()
    let (local res) = Math64x61.ceil(x)
    verify_le_signed(x, res)
    verify_lt_signed(res - Math64x61.ONE, x)
    let (_, rem) = signed_div_rem(res, Math64x61.ONE, Math64x61.BOUND)
    medjai_assert_eq_felt(rem, 0)
    return ()
end

// SPDX-License-Identifier: Apache-2.0
%lang starknet

from cairo_math_64x61.math64x61 import Math64x61
from starkware.cairo.common.bool import TRUE, FALSE
from starkware.cairo.common.cairo_builtins import HashBuiltin

struct FeeRate {
    exists: felt,
    maker: felt,
    taker: felt,
}

@storage_var
func global_fee_rate() -> (feeRate: FeeRate) {
}

@storage_var
func account_fee_rate(account: felt) -> (feeRate: FeeRate) {
}

namespace Math {
    const DOT8 = (10 ** 8) * Math64x61.FRACT_PART;
    func to_decimal8{range_check_ptr}(num: felt) -> felt {
       alloc_locals;
       // To fixed precision
       local _ans = Math64x61.fromFelt(num);
       // Remove quantum precision
       let ans = Math64x61.div(_ans, DOT8);
       return ans;
    }

    func to_felt8{range_check_ptr}(num: felt) -> felt {
        // Add quantum precision
        let _ans =  Math64x61.mul(num, DOT8);
        // Remove fixed precision
        let ans = Math64x61.toFelt(_ans);
        return ans;
    }
}

@external
func convertAndSetGlobalFeeRate{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
    maker_fee: felt, taker_fee: felt
) {
    alloc_locals;

    let maker_fee_d = Math.to_decimal8(maker_fee);
    let taker_fee_d = Math.to_decimal8(taker_fee);

    let fee_rate_d = FeeRate(exists=1, maker=maker_fee_d, taker=taker_fee_d);
    global_fee_rate.write(fee_rate_d);

    return ();
}

@view
func convertAndGetAccountFeeRate{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
    account: felt) -> (fee_rate: FeeRate) {
    alloc_locals;
    let (_account_fee_rate) = account_fee_rate.read(account);

    if (_account_fee_rate.exists != FALSE) {
        return (_account_fee_rate,);
    }

    // Return global fee rate if account fee rate is not set
    let (_global_fee_rate) = global_fee_rate.read();
    let maker_fee = Math.to_felt8(_global_fee_rate.maker);
    let taker_fee = Math.to_felt8(_global_fee_rate.taker);

    let fee_rate = FeeRate(
        exists=1,
        maker=maker_fee,
        taker=taker_fee,
    );
    return (fee_rate,);
}

import dataclasses
import os

import pytest
from starkware.starknet.testing.starknet import Starknet
from starkware.starkware_utils.error_handling import StarkException

from .types import TokenAsset
from .utils import str_to_felt, to_quantum

FILE_DIR = os.path.dirname(__file__)
CAIRO_PATH = [os.path.join(FILE_DIR, "../contracts")]
ROUNDING_FILE = os.path.join(FILE_DIR, "../contracts/test/Rounding.cairo")
ACCOUNT_ADDRESS = str_to_felt("ACCOUNT ADDRESS")

@pytest.fixture()
async def contracts():
    starknet = await Starknet.empty()
    rounding_contract = await starknet.deploy(
        source=ROUNDING_FILE, cairo_path=CAIRO_PATH, disable_hint_validation=True
    )

    return rounding_contract

async def test_fee_rate_with_rounding(contracts):
    rounding_contract = contracts
    maker_fee_rate = to_quantum(0.0001)
    taker_fee_rate = to_quantum(0.0004)
    await rounding_contract.convertAndSetGlobalFeeRate(
        maker_fee_rate,
        taker_fee_rate
    ).execute()

    account_fee_rates = await rounding_contract.convertAndGetAccountFeeRate(ACCOUNT_ADDRESS).call()
    assert not (account_fee_rates.result.fee_rate.maker == maker_fee_rate)
    assert not (account_fee_rates.result.fee_rate.taker == taker_fee_rate)