ostium-python-sdk 0.2.1__tar.gz → 0.2.101__tar.gz

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ostium-python-sdk
-Version: 0.2.1
+Version: 0.2.101
 Summary: A python based SDK developed for interacting with Ostium, a leveraged trading application for trading currencies, commodities, indices, crypto and more.
 Home-page: https://github.com/0xOstium/ostium-python-sdk
 Author: ami@ostium.io
@@ -424,8 +424,17 @@ TBD
 TBD
 
 
-### Funding rate calculation - SDK to get breakdown of FF, RF, PnL, etc.
-TBD
+### Get a certain Pair Net Rate % (Funding Fees, Rollover)
+
+```bash 
+### Use sdk.get_pair_net_rate_percent_per_hours()
+```
+
+### Open Trade Fees calculation - SDK to get breakdown of FF, RF, PnL, etc.
+
+```bash
+## Use sdk.get_open_trade_metrics()
+```
 
 
 ## Example Usage Scripts

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/README.md

@@ -385,8 +385,17 @@ TBD
 TBD
 
 
-### Funding rate calculation - SDK to get breakdown of FF, RF, PnL, etc.
-TBD
+### Get a certain Pair Net Rate % (Funding Fees, Rollover)
+
+```bash 
+### Use sdk.get_pair_net_rate_percent_per_hours()
+```
+
+### Open Trade Fees calculation - SDK to get breakdown of FF, RF, PnL, etc.
+
+```bash
+## Use sdk.get_open_trade_metrics()
+```
 
 
 ## Example Usage Scripts

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/config.py

@@ -22,7 +22,9 @@ class NetworkConfig:
 
     @classmethod
     def testnet(cls) -> 'NetworkConfig':
-        return cls(
+        return cls(  # tbd
+
+
             graph_url="https://subgraph.satsuma-prod.com/391a61815d32/ostium/ost-sep-final/api",
             contracts={
                 "usdc": "0xe73B11Fb1e3eeEe8AF2a23079A4410Fe1B370548",

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/constants.py

@@ -10,6 +10,7 @@ PRECISION_2 = Decimal('100')
 PRECISION_6 = Decimal('1000000')
 PRECISION_9 = Decimal('1000000000')
 PRECISION_12 = Decimal('1000000000000')
+PRECISION_16 = Decimal('10000000000000000')
 PRECISION_18 = Decimal('1000000000000000000')
 
 LIQ_THRESHOLD_P = Decimal('90')  # -90% (of collateral)

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/formulae.py

@@ -1,5 +1,6 @@
 from decimal import Decimal
-from .constants import MAX_PROFIT_P, MAX_STOP_LOSS_P, PRECISION_2, PRECISION_6, PRECISION_12, PRECISION_18, LIQ_THRESHOLD_P
+from .constants import MAX_PROFIT_P, MAX_STOP_LOSS_P, PRECISION_16, PRECISION_2, PRECISION_6, PRECISION_12, PRECISION_18, LIQ_THRESHOLD_P
+from typing import Dict
 
 #
 # This is a copy-cat of formulae repo originally written in TypeScript
@@ -73,6 +74,8 @@ def CurrentTradeProfitP(open_price: str, current_price: str, long: bool, leverag
     except Exception as e:
         return str(e)
 
+# tbd - used by SDK
+
 
 def GetTradeLiquidationPrice(
     open_price: str,
@@ -147,6 +150,8 @@ def GetTradeRolloverFee(
     except Exception as error:
         raise Exception(f"Unable to compute Trade Rollover Fee: {error}")
 
+# Gets the funding fee (abs) for an open trade (up to this block, aka based on current_funding up till this block)
+
 
 def GetTradeFundingFee(
     trade_funding: str,
@@ -230,46 +235,34 @@ def GetPriceImpact(
     mid_price: str,
     bid_price: str,
     ask_price: str,
-    spread_p: str,
-    is_limit: bool,
-    is_buy: bool,
-    is_close: bool,
-    trade_size: str,
-    trade_size_ref: str
+    is_open: bool,
+    is_long: bool,  # aka is_long
 ) -> dict:
     try:
         mid_price = Decimal(mid_price)
         bid_price = Decimal(bid_price)
         ask_price = Decimal(ask_price)
-        spread_p = Decimal(spread_p)
-        trade_size = Decimal(trade_size)
-        trade_size_ref = Decimal(trade_size_ref)
-
-        # Calculate base spread
-        base_spread = (ask_price - bid_price) / mid_price
-
-        # Calculate impact spread
-        impact_spread = base_spread * (trade_size / trade_size_ref)
-
-        # Calculate price after impact
-        price_after_impact = mid_price
-        if not is_limit:
-            if is_buy:
-                price_after_impact = mid_price * \
-                    (Decimal('1') + impact_spread / Decimal('2'))
-            else:
-                price_after_impact = mid_price * \
-                    (Decimal('1') - impact_spread / Decimal('2'))
+
+        if (mid_price == 0):
+            return {
+                'priceImpactP': str(0),
+                'priceAfterImpact': str(0)
+            }
+
+        above_spot = is_open == is_long
+        used_price = ask_price if above_spot else bid_price
+        priceImpactP = 100 * (abs(mid_price - used_price) / mid_price)
 
         return {
-            'priceAfterImpact': str(price_after_impact),
-            'impactSpread': str(impact_spread)
+            'priceImpactP': str(priceImpactP),
+            'priceAfterImpact': str(used_price)
         }
 
     except Exception as error:
         raise Exception(f"Unable to compute Price Impact: {error}")
 
 
+# calculates the gross (without fees) profit (abs) of an open trade
 def CurrentTradeProfitRaw(
     open_price: str,
     current_price: str,
@@ -298,6 +291,8 @@ def CurrentTradeProfitRaw(
     except Exception as error:
         raise Exception(f"Unable to compute Current Trade Profit Raw: {error}")
 
+# calculates the net profit (after fees) of an open trade (abs)
+
 
 def CurrentTotalProfitRaw(
     open_price: str,
@@ -328,6 +323,8 @@ def CurrentTotalProfitRaw(
         raise Exception(f"Unable to compute Current Total Profit Raw: {error}")
 
 
+# TBD- used by sdk. calculates the net profit percentage of an open trade
+# What's the diff between this and CurrentTradeProfitP?
 def CurrentTotalProfitP(total_profit: str, collateral: str) -> str:
     try:
         total_profit = Decimal(total_profit)
@@ -347,3 +344,169 @@ def CurrentTotalProfitP(total_profit: str, collateral: str) -> str:
             f"Unable to compute Current Total Profit Percentage: {error}")
 
 # given desired TP percentage, like 35, 50, 75, 100, 500 and 900 which is max: gives you the TP price
+
+
+def get_target_funding_rate(
+    normalized_oi_delta: Decimal,
+    hill_inflection_point: Decimal,
+    max_fr: Decimal,
+    hill_pos_scale: Decimal,
+    hill_neg_scale: Decimal,
+) -> Decimal:
+    a = Decimal('184')
+    k = Decimal('16')
+
+    x = a * normalized_oi_delta / PRECISION_2
+    x2 = x * x * PRECISION_6  # convert to PRECISION_18
+    hill = x2 * PRECISION_18 / (k * PRECISION_16 + x2)
+
+    if normalized_oi_delta >= 0:
+        target_fr = hill_pos_scale * hill / PRECISION_2 + hill_inflection_point
+    else:
+        target_fr = hill_neg_scale * \
+            Decimal('-1') * hill / PRECISION_2 + hill_inflection_point
+
+    if target_fr > PRECISION_18:
+        target_fr = PRECISION_18
+    elif target_fr < PRECISION_18 * Decimal('-1'):
+        target_fr = PRECISION_18 * Decimal('-1')
+
+    return target_fr * max_fr / PRECISION_18
+
+
+def exponential_approximation(x: Decimal) -> Decimal:
+    approx_threshold = Decimal('793231258909201900')
+
+    if abs(x) < approx_threshold:
+        three_with_precision = PRECISION_18 * 3
+        numerator = x + three_with_precision
+        numerator = numerator * numerator / PRECISION_18 + three_with_precision
+        denominator = x - three_with_precision
+        denominator = denominator * denominator / PRECISION_18 + three_with_precision
+
+        return numerator * PRECISION_18 / denominator
+    else:
+        k = [1648721, 1284025, 1133148, 1064494, 1031743,
+             1015748, 1007843, 1003915, 1001955, 1000977]
+        integer_part = abs(x) // PRECISION_18
+        decimal_part = abs(x) - (integer_part * PRECISION_18)
+
+        approx = PRECISION_6
+
+        for ki in k:
+            decimal_part = decimal_part * 2
+            if decimal_part >= PRECISION_18:
+                approx = approx * Decimal(str(ki)) / PRECISION_6
+                decimal_part = decimal_part - PRECISION_18
+            if decimal_part == 0:
+                break
+
+        return (PRECISION_18 * PRECISION_18 /
+                (Decimal('2') ** integer_part *
+                 (approx / Decimal('1000') * Decimal('1e15'))) /
+                Decimal('1e15') * Decimal('1e15'))
+
+
+def get_funding_rate(
+    acc_per_oi_long: str,
+    acc_per_oi_short: str,
+    last_funding_rate: str,
+    max_funding_fee_per_block: str,
+    last_update_block: str,
+    latest_block: str,
+    oi_long: str,
+    oi_short: str,
+    oi_cap: str,
+    hill_inflection_point: str,
+    hill_pos_scale: str,
+    hill_neg_scale: str,
+    spring_factor: str,
+    s_factor_up_scale_p: str,
+    s_factor_down_scale_p: str,
+    verbose: bool = False
+) -> Dict[str, str]:
+    # Convert string inputs to Decimal
+    acc_per_oi_long_dec = Decimal(acc_per_oi_long)
+    acc_per_oi_short_dec = Decimal(acc_per_oi_short)
+    last_funding_rate_dec = Decimal(last_funding_rate)
+    max_funding_fee_per_block_dec = Decimal(max_funding_fee_per_block)
+    last_update_block_dec = Decimal(last_update_block)
+    latest_block_dec = Decimal(latest_block)
+    oi_long_dec = Decimal(oi_long)
+    oi_short_dec = Decimal(oi_short)
+    oi_cap_dec = Decimal(oi_cap)
+    spring_factor_dec = Decimal(spring_factor)
+    s_factor_up_scale_p_dec = Decimal(s_factor_up_scale_p)
+    s_factor_down_scale_p_dec = Decimal(s_factor_down_scale_p)
+    hill_inflection_point_dec = Decimal(hill_inflection_point)
+    hill_pos_scale_dec = Decimal(hill_pos_scale)
+    hill_neg_scale_dec = Decimal(hill_neg_scale)
+
+    # Calculate open interest max
+    open_interest_max = max(oi_long_dec, oi_short_dec)
+    denominator = max(oi_cap_dec, open_interest_max)
+    oi_delta = (oi_long_dec - oi_short_dec) * PRECISION_6 / denominator
+
+    if verbose:
+        print(f"open_interest_max: {open_interest_max}")
+        print(f"denominator: {denominator}")
+
+        print(
+            f"oi_long_dec: {oi_long_dec} (make sure this is in notional aka usd)")
+        print(
+            f"oi_short_dec: {oi_short_dec} (make sure this is in notional aka usd)")
+        print(f"oi_cap_dec: {oi_cap_dec}")
+        print(f"oi_delta: {oi_delta}")
+
+    # Get target funding rate
+    target_fr = get_target_funding_rate(
+        oi_delta,
+        hill_inflection_point_dec,
+        max_funding_fee_per_block_dec,
+        hill_pos_scale_dec,
+        hill_neg_scale_dec,
+    )
+
+    if verbose:
+        print(f"target_fr: {target_fr}")
+
+    # Calculate spring factor
+    s_factor = Decimal('0')
+    if last_funding_rate_dec * target_fr >= 0:
+        if abs(target_fr) > abs(last_funding_rate_dec):
+            s_factor = spring_factor_dec
+        else:
+            s_factor = s_factor_down_scale_p_dec * \
+                spring_factor_dec / Decimal('10000')
+    else:
+        s_factor = s_factor_up_scale_p_dec * \
+            spring_factor_dec / Decimal('10000')
+
+    # Calculate blocks to charge and exponential
+    num_blocks_to_charge = latest_block_dec - last_update_block_dec
+    exp = exponential_approximation(
+        s_factor * num_blocks_to_charge * Decimal('-1'))
+
+    # Calculate funding rates
+    acc_funding_rate = (target_fr * num_blocks_to_charge +
+                        (PRECISION_18 - exp) * (last_funding_rate_dec - target_fr) / s_factor)
+    fr = target_fr + (last_funding_rate_dec - target_fr) * exp / PRECISION_18
+
+    # Update accumulations
+    if acc_funding_rate > 0:
+        if oi_long_dec > 0:
+            acc_per_oi_long_dec += acc_funding_rate
+            acc_per_oi_short_dec -= (acc_funding_rate * oi_long_dec / oi_short_dec
+                                     if oi_short_dec > 0 else Decimal('0'))
+    else:
+        if oi_short_dec > 0:
+            acc_per_oi_short_dec -= acc_funding_rate
+            acc_per_oi_long_dec += (acc_funding_rate * oi_short_dec / oi_long_dec
+                                    if oi_long_dec > 0 else Decimal('0'))
+
+    return {
+        'accFundingLong': str(acc_per_oi_long_dec),
+        'accFundingShort': str(acc_per_oi_short_dec),
+        'latestFundingRate': str(fr),
+        'targetFr': str(target_fr)
+    }

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/formulae_wrapper.py

@@ -5,6 +5,8 @@ from .formulae import (PRECISION_18, PRECISION_2, PRECISION_6, GetCurrentRollove
                        CurrentTotalProfitRaw, CurrentTotalProfitP)
 from typing import Dict, Union
 
+# TBD - Not used by SDK
+
 
 def get_liq_price(trade_details, pair_info, block_number):
     current_funding_fee = GetTradeFundingFee(trade_details['funding'], pair_info['accFundingLong'] if trade_details['isBuy']
@@ -21,6 +23,8 @@ def get_liq_price(trade_details, pair_info, block_number):
 
     return liq_price / PRECISION_18
 
+# TBD - used by SDK
+
 
 def get_funding_fee_long_short(pair_info, block_number):
     funding_rate_raw = GetFundingRate(
@@ -58,15 +62,18 @@ def get_funding_fee_long_short(pair_info, block_number):
 
     return float(long_rate), float(short_rate)
 
+# TBD - used by SDK
+# Gets an open trade metrics: such as the open pnl, rollover, funding, liquidation price, price impact, etc.
+
 
-def get_trade_metrics(trade_details, price_data, block_number):
+def get_trade_metrics(trade_details, price_data, block_number, verbose=False):
     """
     Calculate PNL and related metrics for a trade.
     """
     if not trade_details or not price_data or not block_number:
         return {
             'pnl': 0,
-            'pnl_raw': '0',
+            # 'pnl_raw': '0',
             'pnl_percent': 0,
             'rollover': 0,
             'funding': 0,
@@ -85,6 +92,9 @@ def get_trade_metrics(trade_details, price_data, block_number):
         str(block_number)
     )
 
+    if verbose:
+        print(f"Current rollover fee: {current_rollover_raw}")
+
     # Calculate rollover for this trade
     rollover_raw = GetTradeRolloverFee(
         trade_details['rollover'],
@@ -93,6 +103,9 @@ def get_trade_metrics(trade_details, price_data, block_number):
         trade_details['leverage']
     )
 
+    if verbose:
+        print(f"Rollover fee: {rollover_raw}")
+
     # Get funding rate
     funding_rate_raw = GetFundingRate(
         pair_info['accFundingLong'],
@@ -106,6 +119,9 @@ def get_trade_metrics(trade_details, price_data, block_number):
         pair_info['shortOI']
     )
 
+    if verbose:
+        print(f"Funding rate: {funding_rate_raw}")
+
     # Calculate funding fee
     funding_raw = GetTradeFundingFee(
         trade_details['funding'],
@@ -114,6 +130,9 @@ def get_trade_metrics(trade_details, price_data, block_number):
         trade_details['leverage']
     )
 
+    if verbose:
+        print(f"Funding fee: {funding_raw}")
+
     # Calculate liquidation price
     liquidation_price = GetTradeLiquidationPrice(
         trade_details['openPrice'],
@@ -125,22 +144,23 @@ def get_trade_metrics(trade_details, price_data, block_number):
     )
     liquidation_price = Decimal(liquidation_price) / PRECISION_18
 
+    if verbose:
+        print(
+            f"Liquidation price: {liquidation_price} with rollover {rollover_raw} and funding {funding_raw}")
+
     # Calculate price impact
+    is_open = False  # Get the price assuming a close
+
     price_impact_raw = GetPriceImpact(
         str(int(Decimal(str(price_data['mid'])) * PRECISION_18)),
         str(int(Decimal(str(price_data['bid'])) * PRECISION_18)),
         str(int(Decimal(str(price_data['ask'])) * PRECISION_18)),
-        pair_info['spreadP'],
-        False,
-        trade_details['isBuy'],
-        True,
-        str(Decimal(trade_details['collateral']) *
-            Decimal(trade_details['leverage']) / PRECISION_2),
-        pair_info['tradeSizeRef']
+        is_open,
+        trade_details['isBuy']
     )
     price_after_impact = price_impact_raw['priceAfterImpact']
 
-    # Calculate PNL
+    # Calculate PNL (abs)
     pnl_raw = CurrentTradeProfitRaw(
         trade_details['openPrice'],
         price_after_impact,
@@ -149,7 +169,7 @@ def get_trade_metrics(trade_details, price_data, block_number):
         trade_details['collateral']
     )
 
-    # Calculate total profit
+    # Calculate total profit (abs)
     total_profit_raw = CurrentTotalProfitRaw(
         trade_details['openPrice'],
         price_after_impact,
@@ -176,13 +196,14 @@ def get_trade_metrics(trade_details, price_data, block_number):
 
     return {
         'pnl': float(pnl),
-        'pnl_raw': str(pnl_raw),
+        # 'pnl_raw': str(pnl_raw),
         'pnl_percent': float(pnl_percent),
         'rollover': float(rollover),
         'funding': float(funding),
-        'funding_raw': str(funding_raw),
-        'rollover_raw': str(rollover_raw),
+        # 'funding_raw': str(funding_raw),
+        # 'rollover_raw': str(rollover_raw),
         'total_profit': float(total_profit),
+        # 'total_profit_percent': float(total_profit_percent),
         'net_pnl': float(net_pnl),
         'net_value': float(net_value),
         'liquidation_price': float(liquidation_price),

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/ostium.py

@@ -1,8 +1,6 @@
-import os
 import traceback
 from enum import Enum
 from ostium_python_sdk.constants import PRECISION_2
-from ostium_python_sdk.formulae_wrapper import get_trade_metrics
 from web3 import Web3
 from .abi.abi import usdc_abi, ostium_trading_abi, ostium_trading_storage_abi
 from .utils import convert_to_scaled_integer, fromErrorCodeToMessage, get_tp_sl_prices, to_base_units

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/sdk.py

@@ -2,7 +2,8 @@ from dotenv import load_dotenv
 import os
 from decimal import Decimal
 
-from ostium_python_sdk.utils import calculate_fee_per_hours, convert_decimals, format_with_precision
+from ostium_python_sdk.formulae import get_funding_rate
+from ostium_python_sdk.utils import calculate_fee_per_hours, format_with_precision
 
 from .formulae_wrapper import get_funding_fee_long_short, get_trade_metrics
 from .constants import PRECISION_2, PRECISION_6, PRECISION_12, PRECISION_18, PRECISION_9
@@ -109,7 +110,7 @@ class OstiumSDK:
         # get the block number
         block_number = self.ostium.get_block_number()
         self.log(f"Block number: {block_number}")
-        return get_trade_metrics(trade_details, price_data, block_number)
+        return get_trade_metrics(trade_details, price_data, block_number, verbose=self.verbose)
 
     async def get_pair_net_rate_percent_per_hours(self, pair_id, period_hours=24):
         pair_details = await self.subgraph.get_pair_details(pair_id)
@@ -134,6 +135,52 @@ class OstiumSDK:
             ff_short-rollover_value, precision=4)
         return net_long_percent, net_short_percent
 
+    async def get_funding_rate_for_pair_id(self, pair_id):
+        pair_details = await self.subgraph.get_pair_details(pair_id)
+        # get the block number
+        block_number = self.ostium.get_block_number()
+
+        self.log(f"Pair details: {pair_details}")
+        self.log(f"Block number: {block_number}")
+
+        # Get current price
+        price, _ = await self.price.get_price(
+            pair_details['from'],
+            pair_details['to']
+        )
+        self.log(f"Price: {price}")
+
+        notional_long_oi = int(
+            (Decimal(pair_details['longOI']) / PRECISION_18) * Decimal(price) * PRECISION_6)
+        notional_short_oi = int(
+            (Decimal(pair_details['shortOI']) / PRECISION_18) * Decimal(price) * PRECISION_6)
+
+        self.log(f"notional_long_oi: {notional_long_oi}")
+        self.log(f"notional_short_oi: {notional_short_oi}")
+
+        ret = get_funding_rate(
+            pair_details['curFundingLong'],
+            pair_details['curFundingShort'],
+            pair_details['lastFundingRate'],
+            # pair_details['lastFundingVelocity'],
+            pair_details['maxFundingFeePerBlock'],
+            pair_details['lastFundingBlock'],
+            block_number,
+            notional_long_oi,  # Needs to be in notional aka usd
+            notional_short_oi,  # Needs to be in notional aka usd
+            pair_details['maxOI'],
+            pair_details['hillInflectionPoint'],
+            pair_details['hillPosScale'],
+            pair_details['hillNegScale'],
+            pair_details['springFactor'],
+            pair_details['sFactorUpScaleP'],
+            pair_details['sFactorDownScaleP'],
+            self.verbose
+        )
+
+        self.log(f"Funding rate: {ret}")
+        return ret
+
     async def get_formatted_pairs_details(self) -> list:
         """
         Get formatted details for all trading pairs, with proper decimal conversion.

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/subgraph.py

@@ -56,7 +56,8 @@ class SubgraphClient:
               curFundingLong  
               curFundingShort
               curRollover
-              maxLeverage
+              totalOpenTrades
+              totalOpenLimitOrders
               accRollover
               lastRolloverBlock
               rolloverFeePerBlock
@@ -64,8 +65,18 @@ class SubgraphClient:
               accFundingShort
               lastFundingBlock
               maxFundingFeePerBlock
-              lastFundingVelocity
               lastFundingRate
+              maxOI
+              hillInflectionPoint
+              hillPosScale
+              hillNegScale
+              lastOiDelta
+              springFactor
+              sFactorUpScaleP
+              sFactorDownScaleP
+              lastTradePrice
+              maxLeverage
+              lastFundingVelocity
               group {
                 id
                 name

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk/utils.py

@@ -1,12 +1,9 @@
 from datetime import datetime
 from decimal import Decimal
-import os
-from humanize import naturaltime
 from web3 import Web3
 from ast import literal_eval
 
 from .constants import MAX_PROFIT_P, MAX_STOP_LOSS_P
-from .formulae import GetTakeProfitPrice
 
 
 def format_with_precision(number, precision):

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ostium-python-sdk
-Version: 0.2.1
+Version: 0.2.101
 Summary: A python based SDK developed for interacting with Ostium, a leveraged trading application for trading currencies, commodities, indices, crypto and more.
 Home-page: https://github.com/0xOstium/ostium-python-sdk
 Author: ami@ostium.io
@@ -424,8 +424,17 @@ TBD
 TBD
 
 
-### Funding rate calculation - SDK to get breakdown of FF, RF, PnL, etc.
-TBD
+### Get a certain Pair Net Rate % (Funding Fees, Rollover)
+
+```bash 
+### Use sdk.get_pair_net_rate_percent_per_hours()
+```
+
+### Open Trade Fees calculation - SDK to get breakdown of FF, RF, PnL, etc.
+
+```bash
+## Use sdk.get_open_trade_metrics()
+```
 
 
 ## Example Usage Scripts

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/ostium_python_sdk.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ ostium_python_sdk/abi/__init__.py
 ostium_python_sdk/abi/abi.py
 ostium_python_sdk/abi/faucet_abi.py
 tests/__init__.py
+tests/test_get_price_impact.py
 tests/test_slippage.py
 tests/test_trade_get_tp_price.py
 tests/test_trade_liquidation_price.py

{ostium_python_sdk-0.2.1 → ostium_python_sdk-0.2.101}/setup.py

@@ -19,7 +19,7 @@ if changelog_path.exists():
 
 setup(
     name="ostium-python-sdk",
-    version="0.2.1",
+    version="0.2.101",
     packages=find_packages(),
     install_requires=read_requirements('requirements.txt'),
     extras_require={

ostium_python_sdk-0.2.101/tests/test_get_price_impact.py

@@ -0,0 +1,60 @@
+from ostium_python_sdk.formulae import GetPriceImpact
+from decimal import Decimal
+import pytest
+
+
+@pytest.fixture
+def test_cases():
+    return [
+        {
+            'midPrice': Decimal('0'),
+            'bidPrice': Decimal('98'),
+            'askPrice': Decimal('0'),
+            'is_open': True,
+            'is_long': True,
+            'expected_price_impact_p': '0',
+            'expected_price_after_impact': '0'
+        },
+        {
+            'midPrice': Decimal('100'),
+            'bidPrice': Decimal('99'),
+            'askPrice': Decimal('101'),
+            'is_open': True,
+            'is_long': True,
+            'expected_price_impact_p': '1.00',
+            'expected_price_after_impact': '101'
+        },
+        {
+            'midPrice': Decimal('100'),
+            'bidPrice': Decimal('99'),
+            'askPrice': Decimal('101'),
+            'is_open': False,
+            'is_long': True,
+            'expected_price_impact_p': '1.00',
+            'expected_price_after_impact': '99'
+        },
+        {
+            'midPrice': Decimal('100'),
+            'bidPrice': Decimal('99'),
+            'askPrice': Decimal('101'),
+            'is_open': False,
+            'is_long': False,
+            'expected_price_impact_p': '1.00',
+            'expected_price_after_impact': '101'
+        },
+    ]
+
+
+def test_get_price_impact(test_cases):
+    for case in test_cases:
+        response = GetPriceImpact(
+            case['midPrice'],
+            case['bidPrice'],
+            case['askPrice'],
+            case['is_open'],
+            case['is_long']
+        )
+        assert pytest.approx(response['priceAfterImpact'], rel=Decimal(1e-7)
+                             ) == case['expected_price_after_impact']
+        assert pytest.approx(response['priceImpactP'], rel=Decimal(1e-7)
+                             ) == case['expected_price_impact_p']