ostium-python-sdk 0.1.42__tar.gz → 0.2.0__tar.gz

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ostium-python-sdk
-Version: 0.1.42
+Version: 0.2.0
 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
@@ -100,8 +100,6 @@ Developed using:
 You can instantiate the SDK with the following parameters. 
 Ostium Platform is deployed on Arbitrum. You can use the testnet or mainnet config via the `NetworkConfig` class, see below for an example.
 
-
-
 ```python
 from dotenv import load_dotenv
 from ostium_python_sdk import OstiumSDK, NetworkConfig
@@ -118,14 +116,12 @@ rpc_url = os.getenv('RPC_URL')
 if not rpc_url:
     raise ValueError("RPC_URL not found in .env file")
 
-# Initialize SDK
+# Initialize SDK (default: verbose=False for quiet operation)
 configTestnet = NetworkConfig.testnet()
 sdk = OstiumSDK(configTestnet, private_key)
 
-# NOTE: When you are ready to go live, you can switch to mainnet usage as simple as specifying the below init code:
-# configMainnet = NetworkConfig.mainnet()
-# sdk = OstiumSDK(configMainnet, private_key)
-#
+# For verbose mode with detailed logging:
+sdk = OstiumSDK(configTestnet, private_key, verbose=True)
 ```
 
 <b>NOTE:</b> create a .env file with PRIVATE_KEY and RPC_URL to use the SDK. An RPC URL is required to use the SDK. You can get one by signing up for a free account at https://www.alchemy.com/ and creating an app. 
@@ -275,6 +271,8 @@ trade_params = {
     'asset_type': 0,          # 0 for BTC, see pair_details above for other asset types 
     'direction': True,        # True for Long, False for Short
     'order_type': 'MARKET'    # 'MARKET', 'LIMIT', or 'STOP'
+    #'tp': 0,                 # Take Profit price - if not specified or Zero means no TP
+    #'sl': 0,                 # Stop Loss price - if not specified or Zero means no SL
 }
 
 try:
@@ -329,6 +327,20 @@ except Exception as e:
 
 ```
 
+
+**NOTE:** Use SDK method `get_open_trade_metrics` every so often while trade is open to get the trade's metrics such as:
+
+- Funding fee
+- Roll over fee
+- Unrealized Pnl and Pnl Percent
+- Total Profit
+- Liquidation Price 
+
+```python
+metrics = await sdk.get_open_trade_metrics(pair_id, trade_index)
+print(metrics)
+```
+
 ### Create a Short ETH Limit Order
 
 This example shows how to create a short ETH limit order, 10% above the current ETHUSD price. So if price goes up 10% we order a Short ETH trade.
@@ -490,6 +502,19 @@ All notable changes to the Ostium Python SDK will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2025-02-20
+
+### Added
+
+- Added sdk method `get_open_trade_metrics` to get open trade metrics such as:
+  - Funding fee
+  - Roll over fee
+  - Unrealized Pnl and Pnl Percent
+  - Total Profit
+  - Liquidation Price 
+
+- Added verbose mode to sdk (default is False, set to True to see debug logs)
+
 ## [0.1.36] - 2025-01-14
 
 ### Added

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/README.md

@@ -61,8 +61,6 @@ Developed using:
 You can instantiate the SDK with the following parameters. 
 Ostium Platform is deployed on Arbitrum. You can use the testnet or mainnet config via the `NetworkConfig` class, see below for an example.
 
-
-
 ```python
 from dotenv import load_dotenv
 from ostium_python_sdk import OstiumSDK, NetworkConfig
@@ -79,14 +77,12 @@ rpc_url = os.getenv('RPC_URL')
 if not rpc_url:
     raise ValueError("RPC_URL not found in .env file")
 
-# Initialize SDK
+# Initialize SDK (default: verbose=False for quiet operation)
 configTestnet = NetworkConfig.testnet()
 sdk = OstiumSDK(configTestnet, private_key)
 
-# NOTE: When you are ready to go live, you can switch to mainnet usage as simple as specifying the below init code:
-# configMainnet = NetworkConfig.mainnet()
-# sdk = OstiumSDK(configMainnet, private_key)
-#
+# For verbose mode with detailed logging:
+sdk = OstiumSDK(configTestnet, private_key, verbose=True)
 ```
 
 <b>NOTE:</b> create a .env file with PRIVATE_KEY and RPC_URL to use the SDK. An RPC URL is required to use the SDK. You can get one by signing up for a free account at https://www.alchemy.com/ and creating an app. 
@@ -236,6 +232,8 @@ trade_params = {
     'asset_type': 0,          # 0 for BTC, see pair_details above for other asset types 
     'direction': True,        # True for Long, False for Short
     'order_type': 'MARKET'    # 'MARKET', 'LIMIT', or 'STOP'
+    #'tp': 0,                 # Take Profit price - if not specified or Zero means no TP
+    #'sl': 0,                 # Stop Loss price - if not specified or Zero means no SL
 }
 
 try:
@@ -290,6 +288,20 @@ except Exception as e:
 
 ```
 
+
+**NOTE:** Use SDK method `get_open_trade_metrics` every so often while trade is open to get the trade's metrics such as:
+
+- Funding fee
+- Roll over fee
+- Unrealized Pnl and Pnl Percent
+- Total Profit
+- Liquidation Price 
+
+```python
+metrics = await sdk.get_open_trade_metrics(pair_id, trade_index)
+print(metrics)
+```
+
 ### Create a Short ETH Limit Order
 
 This example shows how to create a short ETH limit order, 10% above the current ETHUSD price. So if price goes up 10% we order a Short ETH trade.

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/ostium_python_sdk/balance.py

@@ -8,14 +8,19 @@ REFRESH_BALANCE_SECONDS_INTERVAL = 60 * 5
 
 
 class Balance:
-    def __init__(self, w3: Web3, usdc_address: str) -> None:
+    def __init__(self, w3: Web3, usdc_address: str, verbose=False) -> None:
         self.web3 = w3
         self.usdc_address = usdc_address
+        self.verbose = verbose
         self.usdc_contract = self.web3.eth.contract(
             address=self.usdc_address, abi=usdc_abi)
         # Format: {address: {'ether': value, 'usdc': value, 'last_refresh': timestamp}}
         self.balances = {}
 
+    def log(self, message):
+        if self.verbose:
+            print(message)
+
     def get_balance(self, address, refresh=False):
         if address not in self.balances:
             self.balances[address] = {'ether': None,
@@ -34,7 +39,6 @@ class Balance:
         return self.balances[address]['ether'], self.balances[address]['usdc']
 
     def read_balances(self, address):
-        # print(f'actual [{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}] {address} - reading balances')
         start_time = time.time()
         self.balances[address] = {
             'ether': Decimal(self.get_ether_balance(address)),

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/ostium_python_sdk/faucet.py

@@ -8,8 +8,9 @@ from ostium_python_sdk.abi.faucet_abi import faucet_abi  # Import the ABI
 
 
 class Faucet:
-    def __init__(self, w3: Web3, private_key: str) -> None:
+    def __init__(self, w3: Web3, private_key: str, verbose=False) -> None:
         self.web3 = w3
+        self.verbose = verbose
         self.private_key = private_key
         self.faucet_address = "0x6830C550814105d8B27bDAEC0DB391cAa7B967c8"
         self.faucet_contract = self.web3.eth.contract(
@@ -17,6 +18,10 @@ class Faucet:
             abi=faucet_abi
         )
 
+    def log(self, message):
+        if self.verbose:
+            print(message)
+
     def _format_waiting_time(self, next_request_time: int) -> str:
         """Format the waiting time into a human-readable string"""
         current_time = int(time.time())
@@ -51,6 +56,7 @@ class Faucet:
 
     def request_tokens(self) -> dict:
         account = self._get_account()
+        self.log("Requesting tokens from faucet")
         """
         Request testnet USDC tokens from the faucet.
         Raises:
@@ -114,10 +120,10 @@ class Faucet:
     def get_token_amount(self) -> int:
         """Get the amount of tokens that will be received from the faucet"""
         try:
-            print(f"Debug - Calling tokenAmount() function")  # Add debug print
+            self.log("Calling tokenAmount() function")  # Add debug print
             return self.faucet_contract.functions.tokenAmount().call()
         except Exception as e:
-            print(f"Debug - Error details: {str(e)}")  # Add debug print
+            self.log(f"Error details: {str(e)}")  # Add debug print
             raise Exception(f"Failed to get token amount: {str(e)}")
 
     def get_next_request_time(self, address: str) -> int:

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/ostium_python_sdk/formulae.py

@@ -96,11 +96,8 @@ def GetTradeLiquidationPrice(
             leverage
         )
 
-        # print('# liq_price_distance', liq_price_distance)
         liq_price = open_price - liq_price_distance if long else open_price + liq_price_distance
-
         liq_price = liq_price if liq_price > 0 else 0
-        # print('---> liq_price', liq_price)
         return liq_price
 
     except Exception as error:

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/ostium_python_sdk/formulae_wrapper.py

@@ -1,8 +1,8 @@
 from decimal import Decimal
-from formulae import (PRECISION_18, PRECISION_2, PRECISION_6, GetCurrentRolloverFee,
-                      GetTradeFundingFee, GetTradeLiquidationPrice, GetTradeRolloverFee,
-                      GetFundingRate, GetPriceImpact, CurrentTradeProfitRaw,
-                      CurrentTotalProfitRaw, CurrentTotalProfitP)
+from .formulae import (PRECISION_18, PRECISION_2, PRECISION_6, GetCurrentRolloverFee,
+                       GetTradeFundingFee, GetTradeLiquidationPrice, GetTradeRolloverFee,
+                       GetFundingRate, GetPriceImpact, CurrentTradeProfitRaw,
+                       CurrentTotalProfitRaw, CurrentTotalProfitP)
 from typing import Dict, Union
 
 
@@ -59,11 +59,11 @@ def get_funding_fee_long_short(pair_info, block_number):
     return float(long_rate), float(short_rate)
 
 
-def get_trade_pnl(trade_details, pair_info, price_data, block_number):
+def get_trade_metrics(trade_details, price_data, block_number):
     """
     Calculate PNL and related metrics for a trade.
     """
-    if not trade_details or not price_data or not block_number or not pair_info:
+    if not trade_details or not price_data or not block_number:
         return {
             'pnl': 0,
             'pnl_raw': '0',
@@ -76,6 +76,7 @@ def get_trade_pnl(trade_details, pair_info, price_data, block_number):
             'liquidation_price': 0
         }
 
+    pair_info = trade_details['pair']
     # Calculate current rollover fee
     current_rollover_raw = GetCurrentRolloverFee(
         pair_info['accRollover'],

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/ostium_python_sdk/ostium.py

@@ -2,6 +2,7 @@ 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
@@ -15,8 +16,9 @@ class OpenOrderType(Enum):
 
 
 class Ostium:
-    def __init__(self, w3: Web3, usdc_address: str, ostium_trading_storage_address: str, ostium_trading_address: str, private_key: str) -> None:
+    def __init__(self, w3: Web3, usdc_address: str, ostium_trading_storage_address: str, ostium_trading_address: str, private_key: str, verbose=False) -> None:
         self.web3 = w3
+        self.verbose = verbose
         self.private_key = private_key
         self.usdc_address = usdc_address
         self.ostium_trading_storage_address = ostium_trading_storage_address
@@ -32,12 +34,20 @@ class Ostium:
 
         self.slippage_percentage = 2  # 2%
 
+    def log(self, message):
+        if self.verbose:
+            print(message)
+
     def set_slippage_percentage(self, slippage_percentage):
         self.slippage_percentage = slippage_percentage
 
     def get_slippage_percentage(self):
         return self.slippage_percentage
 
+    def get_public_address(self):
+        public_address = self._get_account().address
+        return public_address
+
     def _get_account(self) -> Account:
         self._check_private_key()
         """Get account from stored private key"""
@@ -55,12 +65,13 @@ class Ostium:
                 "Private key is required for Ostium platform write-operations")
 
     def perform_trade(self, trade_params, at_price):
+        self.log(f"Performing trade with params: {trade_params}")
         account = self._get_account()
         amount = to_base_units(trade_params['collateral'], decimals=6)
         self.__approve(account, amount)
 
         try:
-            print("Final trade parameters being sent:", trade_params)
+            self.log(f"Final trade parameters being sent: {trade_params}")
             tp_price, sl_price = get_tp_sl_prices(trade_params)
 
             trade = {
@@ -97,50 +108,52 @@ class Ostium:
                 signed_tx.raw_transaction)
             trade_receipt = self.web3.eth.wait_for_transaction_receipt(
                 trade_tx_hash)
-            print('Trade Receipt:', trade_receipt)
+            self.log(f"Trade Receipt: {trade_receipt}")
             return trade_receipt
 
         except Exception as e:
-            reason_string, suggestion = fromErrorCodeToMessage(e)
+            reason_string, suggestion = fromErrorCodeToMessage(
+                e, verbose=self.verbose)
             print(
                 f"An error ({str(e)}) occurred during the trading process - parsed as {reason_string}")
             raise Exception(
                 f'{reason_string}\n\n{suggestion}' if suggestion != None else reason_string)
 
-    def cancel_limit_order(self, pairID, index):
+    def cancel_limit_order(self, pair_id, trade_index):
         account = self._get_account()
 
         trade_tx = self.ostium_trading_contract.functions.cancelOpenLimitOrder(
-            int(pairID), int(index)).build_transaction({'from': account.address})
+            int(pair_id), int(trade_index)).build_transaction({'from': account.address})
         trade_tx['nonce'] = self.get_nonce(account.address)
 
         signed_tx = self.web3.eth.account.sign_transaction(
             trade_tx, private_key=self.private_key)
         trade_tx_hash = self.web3.eth.send_raw_transaction(
             signed_tx.raw_transaction)
-        print('Cancel Limit Order TX Hash:', trade_tx_hash.hex())
+        self.log(f"Cancel Limit Order TX Hash: {trade_tx_hash.hex()}")
 
         trade_receipt = self.web3.eth.wait_for_transaction_receipt(
             trade_tx_hash)
-        print('Cancel Limit Order Receipt:', trade_receipt)
+        self.log(f"Cancel Limit Order Receipt: {trade_receipt}")
         return trade_receipt
 
-    def close_trade(self, pairID, index):
+    def close_trade(self, pair_id, trade_index):
+        self.log(f"Closing trade for pair {pair_id}, index {trade_index}")
         account = self._get_account()
 
         trade_tx = self.ostium_trading_contract.functions.closeTradeMarket(
-            int(pairID), int(index)).build_transaction({'from': account.address})
+            int(pair_id), int(trade_index)).build_transaction({'from': account.address})
         trade_tx['nonce'] = self.get_nonce(account.address)
 
         signed_tx = self.web3.eth.account.sign_transaction(
             trade_tx, private_key=self.private_key)
         trade_tx_hash = self.web3.eth.send_raw_transaction(
             signed_tx.raw_transaction)
-        print('Trade TX Hash:', trade_tx_hash.hex())
+        self.log(f"Trade TX Hash: {trade_tx_hash.hex()}")
 
         trade_receipt = self.web3.eth.wait_for_transaction_receipt(
             trade_tx_hash)
-        print('Trade Receipt:', trade_receipt)
+        self.log(f"Trade Receipt: {trade_receipt}")
         return trade_receipt
 
     def add_collateral(self, pairID, index, collateral):
@@ -157,11 +170,11 @@ class Ostium:
                 add_collateral_tx, private_key=self.private_key)
             add_collateral_tx_hash = self.web3.eth.send_raw_transaction(
                 signed_tx.raw_transaction)
-            print('Add Collateral TX Hash:', add_collateral_tx_hash.hex())
+            self.log(f"Add Collateral TX Hash: {add_collateral_tx_hash.hex()}")
 
             add_collateral_receipt = self.web3.eth.wait_for_transaction_receipt(
                 add_collateral_tx_hash)
-            print('Add Collateral Receipt:', add_collateral_receipt)
+            self.log(f"Add Collateral Receipt: {add_collateral_receipt}")
             return add_collateral_receipt
 
         except Exception as e:
@@ -169,20 +182,22 @@ class Ostium:
             traceback.print_exc()
             raise e
 
-    def update_tp(self, pairID, index, tp):
+    def update_tp(self, pair_id, trade_index, tp_price):
+        self.log(
+            f"Updating TP for pair {pair_id}, index {trade_index} to {tp_price}")
         account = self._get_account()
         try:
-            tp_value = to_base_units(tp, decimals=18)
+            tp_value = to_base_units(tp_price, decimals=18)
 
             update_tp_tx = self.ostium_trading_contract.functions.updateTp(
-                int(pairID), int(index), tp_value).build_transaction({'from': account.address})
+                int(pair_id), int(trade_index), tp_value).build_transaction({'from': account.address})
             update_tp_tx['nonce'] = self.get_nonce(account.address)
 
             signed_tx = self.web3.eth.account.sign_transaction(
                 update_tp_tx, private_key=self.private_key)
             update_tp_tx_hash = self.web3.eth.send_raw_transaction(
                 signed_tx.raw_transaction)
-            print('Update TP TX Hash:', update_tp_tx_hash.hex())
+            self.log(f"Update TP TX Hash: {update_tp_tx_hash.hex()}")
 
         except Exception as e:
             print("An error occurred during the update tp process:")
@@ -202,10 +217,11 @@ class Ostium:
                 update_sl_tx, private_key=self.private_key)
             update_sl_tx_hash = self.web3.eth.send_raw_transaction(
                 signed_tx.raw_transaction)
-            print('Update SL TX Hash:', update_sl_tx_hash.hex())
+            self.log(f"Update SL TX Hash: {update_sl_tx_hash.hex()}")
 
         except Exception as e:
-            reason_string, suggestion = fromErrorCodeToMessage(str(e))
+            reason_string, suggestion = fromErrorCodeToMessage(
+                str(e), verbose=self.verbose)
             print(
                 f"An error occurred during the update sl process: {reason_string}")
             raise Exception(
@@ -227,11 +243,11 @@ class Ostium:
                 approve_tx, private_key=self.private_key)
             approve_tx_hash = self.web3.eth.send_raw_transaction(
                 signed_tx.raw_transaction)
-            print('Approval TX Hash:', approve_tx_hash.hex())
+            self.log(f"Approval TX Hash: {approve_tx_hash.hex()}")
 
             approve_receipt = self.web3.eth.wait_for_transaction_receipt(
                 approve_tx_hash)
-            print('Approval Receipt:', approve_receipt)
+            self.log(f"Approval Receipt: {approve_receipt}")
 
     def withdraw(self, amount, receiving_address):
         account = self._get_account()
@@ -253,15 +269,16 @@ class Ostium:
                 transfer_tx, private_key=self.private_key)
             transfer_tx_hash = self.web3.eth.send_raw_transaction(
                 signed_tx.raw_transaction)
-            print('Transfer TX Hash:', transfer_tx_hash.hex())
+            self.log(f"Transfer TX Hash: {transfer_tx_hash.hex()}")
 
             transfer_receipt = self.web3.eth.wait_for_transaction_receipt(
                 transfer_tx_hash)
-            print('Transfer Receipt:', transfer_receipt)
+            self.log(f"Transfer Receipt: {transfer_receipt}")
             return transfer_receipt
 
         except Exception as e:
-            reason_string, suggestion = fromErrorCodeToMessage(str(e))
+            reason_string, suggestion = fromErrorCodeToMessage(
+                str(e), verbose=self.verbose)
             print(
                 f"An error occurred during the transfer process: {reason_string}")
             raise Exception(
@@ -269,10 +286,7 @@ class Ostium:
 
     def update_limit_order(self, pair_id, index, pvt_key, price=None, tp=None, sl=None):
         try:
-            print('update_limit_order called with pair_id', pair_id, 'index',
-                  index, 'pvt_key', pvt_key, 'price', price, 'tp', tp, 'sl', sl)
             account = self.web3.eth.account.from_key(pvt_key)
-
             # Get existing order details (tbd why read from storage)
             existing_order = self.ostium_trading_storage_contract.functions.getOpenLimitOrder(
                 account.address,
@@ -280,7 +294,7 @@ class Ostium:
                 int(index)
             ).call()
 
-            print('existing_order', existing_order)
+            self.log(f"existing_order {existing_order}")
             # Use existing values if new values are not provided
             price_value = convert_to_scaled_integer(
                 price) if price is not None else existing_order[1]  # openPrice
@@ -289,8 +303,6 @@ class Ostium:
             sl_value = convert_to_scaled_integer(
                 sl) if sl is not None else existing_order[3]    # sl
 
-            print('calling updateOpenLimitOrder with price_value',
-                  price_value, 'tp_value', tp_value, 'sl_value', sl_value)
             trade_tx = self.ostium_trading_contract.functions.updateOpenLimitOrder(
                 int(pair_id),
                 int(index),
@@ -305,15 +317,16 @@ class Ostium:
                 trade_tx, private_key=account.key)
             trade_tx_hash = self.web3.eth.send_raw_transaction(
                 signed_tx.raw_transaction)
-            print('Update Limit Order TX Hash:', trade_tx_hash.hex())
+            self.log(f"Update Limit Order TX Hash: {trade_tx_hash.hex()}")
 
             trade_receipt = self.web3.eth.wait_for_transaction_receipt(
                 trade_tx_hash)
-            print('Update Limit Order Receipt:', trade_receipt)
+            self.log(f"Update Limit Order Receipt: {trade_receipt}")
             return trade_receipt
 
         except Exception as e:
-            reason_string, suggestion = fromErrorCodeToMessage(str(e))
+            reason_string, suggestion = fromErrorCodeToMessage(
+                str(e), verbose=self.verbose)
             print(
                 f"An error occurred during the update limit order process: {reason_string}")
             raise Exception(

ostium_python_sdk-0.2.0/ostium_python_sdk/price.py

@@ -0,0 +1,47 @@
+import aiohttp
+from typing import Tuple
+
+
+class Price:
+    def __init__(self, verbose=False):
+        self.verbose = verbose
+        self.base_url = "https://listener.ostium.io"
+
+    def log(self, message):
+        if self.verbose:
+            print(message)
+
+    # Returns a list of price data, e.g: [{'feed_id': '0x00039d9e45394f473ab1f050a1b963e6b05351e52d71e507509ada0c95ed75b8', 'bid': 97241.43864211132, 'mid': 97243.36503172085, 'ask': 97245.2739217016, 'isMarketOpen': True, 'from': 'BTC', 'to': 'USD', 'timestampSeconds': 1740043714}, ...]
+    async def get_latest_prices(self):
+        """
+        Fetches the latest prices from the Ostium price listener service.
+        Returns a dictionary of price data.
+        """
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{self.base_url}/PricePublish/latest-prices") as response:
+                if response.status == 200:
+                    return await response.json()
+                else:
+                    raise Exception(
+                        f"Failed to fetch prices: {response.status}")
+
+    # Returns a json, e.g: {'feed_id': '0x00039d9e45394f473ab1f050a1b963e6b05351e52d71e507509ada0c95ed75b8', 'bid': 97241.43864211132, 'mid': 97243.36503172085, 'ask': 97245.2739217016, 'isMarketOpen': True, 'from': 'BTC', 'to': 'USD', 'timestampSeconds': 1740043714}
+    async def get_latest_price_json(self, from_asset: str, to_asset: str) -> Tuple[float, bool]:
+        prices = await self.get_latest_prices()
+        for price_data in prices:
+            if (price_data.get('from') == from_asset and
+                    price_data.get('to') == to_asset):
+                self.log(f"get_latest_price_json: {price_data}")
+                return price_data
+        raise ValueError(f"No price found for pair: {from_asset}/{to_asset}")
+
+    # Returns a mid price and isMarketOpen tuple, e.g: (97243.36503172085, True)
+    async def get_price(self, from_currency, to_currency):
+        self.log(f"Getting price for {from_currency}/{to_currency}")
+        prices = await self.get_latest_prices()
+        for price_data in prices:
+            if (price_data.get('from') == from_currency and
+                    price_data.get('to') == to_currency):
+                return float(price_data.get('mid', 0)), price_data.get('isMarketOpen', False)
+        raise ValueError(
+            f"No price found for pair: {from_currency}/{to_currency}")

{ostium_python_sdk-0.1.42 → ostium_python_sdk-0.2.0}/ostium_python_sdk/sdk.py

@@ -1,6 +1,8 @@
 from dotenv import load_dotenv
 import os
 from decimal import Decimal
+
+from .formulae_wrapper import get_trade_metrics
 from .constants import PRECISION_2, PRECISION_6, PRECISION_12, PRECISION_18, PRECISION_9
 
 from ostium_python_sdk.faucet import Faucet
@@ -14,7 +16,8 @@ from .subgraph import SubgraphClient
 
 
 class OstiumSDK:
-    def __init__(self, network: Union[str, NetworkConfig], private_key: str = None, rpc_url: str = None):
+    def __init__(self, network: Union[str, NetworkConfig], private_key: str = None, rpc_url: str = None, verbose=False):
+        self.verbose = verbose
         load_dotenv()
         self.private_key = private_key or os.getenv('PRIVATE_KEY')
         # if not self.private_key:
@@ -52,20 +55,60 @@ class OstiumSDK:
             self.network_config.contracts["usdc"],
             self.network_config.contracts["tradingStorage"],
             self.network_config.contracts["trading"],
-            private_key=self.private_key
+            private_key=self.private_key,
+            verbose=self.verbose
         )
 
         # Initialize subgraph client
-        self.subgraph = SubgraphClient(url=self.network_config.graph_url)
+        self.subgraph = SubgraphClient(
+            url=self.network_config.graph_url, verbose=self.verbose)
 
-        self.balance = Balance(self.w3, self.network_config.contracts["usdc"])
-        self.price = Price()
+        self.balance = Balance(
+            self.w3, self.network_config.contracts["usdc"], verbose=self.verbose)
+        self.price = Price(verbose=self.verbose)
 
         if self.network_config.is_testnet:
-            self.faucet = Faucet(self.w3, self.private_key)
+            self.faucet = Faucet(self.w3, self.private_key,
+                                 verbose=self.verbose)
         else:
             self.faucet = None
 
+    def log(self, message):
+        if self.verbose:
+            print(message)
+
+    # if SDK instantiated with a private key, this function will return a given open trade metrics,
+    # such as: funding fee, roll over fee, Unrealized Pnl, Profit Percent, etc.
+    #
+    # Will thorw in case SDK instantiated with no private key
+    async def get_open_trade_metrics(self, pair_id, trade_index):
+        trader_public_address = self.ostium.get_public_address()
+        self.log(f"Trader public address: {trader_public_address}")
+        open_trades = await self.subgraph.get_open_trades(trader_public_address)
+
+        trade_details = None
+
+        if len(open_trades) == 0:
+            raise ValueError(f"No Open Trades for {trader_public_address}")
+
+        for t in open_trades:
+            if int(t['pair']['id']) == int(pair_id) and int(t['index']) == int(trade_index):
+                trade_details = t
+                break
+
+        if trade_details is None:
+            raise ValueError(
+                f"Trade not found for {trader_public_address} pair {pair_id} and index {trade_index}")
+
+        self.log(f"Trade details: {trade_details}")
+        # get the price for this trade's asset/feed
+        price_data = await self.price.get_latest_price_json(trade_details['pair']['from'], trade_details['pair']['to'])
+        self.log(f"Price data: {price_data} (need here bid, mid, ask prices)")
+        # 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)
+
     async def get_formatted_pairs_details(self) -> list:
         """
         Get formatted details for all trading pairs, with proper decimal conversion.