ostium-python-sdk 0.1.3__py3-none-any.whl

ostium_python_sdk/formulae_wrapper.py

@@ -0,0 +1,294 @@
+from decimal import Decimal
+from formulae import (PRECISION_18, PRECISION_2, PRECISION_6, GetCurrentRolloverFee,
+                      GetTradeFundingFee, GetTradeLiquidationPrice, GetTradeRolloverFee,
+                      GetFundingRate, GetPriceImpact, CurrentTradeProfitRaw,
+                      CurrentTotalProfitRaw, CurrentTotalProfitP)
+from typing import Dict, Union
+
+
+def get_liq_price(trade_details, pair_info, block_number):
+    current_funding_fee = GetTradeFundingFee(trade_details['funding'], pair_info['accFundingLong'] if trade_details['isBuy']
+                                             else pair_info['accFundingShort'], trade_details['collateral'], trade_details['leverage'])
+
+    current_rollover_fee = GetCurrentRolloverFee(
+        pair_info['accRollover'], pair_info['lastRolloverBlock'], pair_info['rolloverFeePerBlock'], block_number)
+
+    trade_rollover_fee = GetTradeRolloverFee(
+        trade_details['rollover'], current_rollover_fee, trade_details['collateral'], trade_details['leverage'])
+
+    liq_price = GetTradeLiquidationPrice(trade_details['openPrice'], trade_details['isBuy'], Decimal(trade_details['collateral']) / PRECISION_6, Decimal(
+        trade_details['leverage']) / PRECISION_2, Decimal(trade_rollover_fee)/PRECISION_6, Decimal(current_funding_fee) / PRECISION_6)
+
+    return liq_price / PRECISION_18
+
+
+def get_funding_fee_long_short(pair_info, block_number):
+    funding_rate_raw = GetFundingRate(
+        pair_info['accFundingLong'],
+        pair_info['accFundingShort'],
+        pair_info['lastFundingRate'],
+        pair_info['lastFundingVelocity'],
+        pair_info['maxFundingFeePerBlock'],
+        pair_info['lastFundingBlock'],
+        str(block_number),
+        pair_info['longOI'],
+        pair_info['shortOI']
+    )
+
+    # Convert latest funding rate to decimal
+    latest_rate = Decimal(
+        funding_rate_raw['latestFundingRate']) / PRECISION_18  # Fixed key name
+
+    # Convert OI values to decimal
+    long_oi = Decimal(pair_info['longOI']) / PRECISION_18
+    short_oi = Decimal(pair_info['shortOI']) / PRECISION_18
+
+    if funding_rate_raw['longsPay']:
+        # If longs pay, they get negative rate
+        long_rate = -latest_rate
+        # Shorts receive proportional to OI ratio
+        short_rate = latest_rate * long_oi / \
+            short_oi if short_oi > 0 else Decimal('0')
+    else:
+        # If shorts pay, they get negative rate
+        short_rate = -latest_rate
+        # Longs receive proportional to OI ratio
+        long_rate = latest_rate * short_oi / \
+            long_oi if long_oi > 0 else Decimal('0')
+
+    return float(long_rate), float(short_rate)
+
+
+def get_trade_pnl(trade_details, pair_info, 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:
+        return {
+            'pnl': 0,
+            'pnl_raw': '0',
+            'pnl_percent': 0,
+            'rollover': 0,
+            'funding': 0,
+            'total_profit': 0,
+            'net_pnl': 0,
+            'net_value': 0,
+            'liquidation_price': 0
+        }
+
+    # Calculate current rollover fee
+    current_rollover_raw = GetCurrentRolloverFee(
+        pair_info['accRollover'],
+        pair_info['lastRolloverBlock'],
+        pair_info['rolloverFeePerBlock'],
+        str(block_number)
+    )
+
+    # Calculate rollover for this trade
+    rollover_raw = GetTradeRolloverFee(
+        trade_details['rollover'],
+        current_rollover_raw,
+        trade_details['collateral'],
+        trade_details['leverage']
+    )
+
+    # Get funding rate
+    funding_rate_raw = GetFundingRate(
+        pair_info['accFundingLong'],
+        pair_info['accFundingShort'],
+        pair_info['lastFundingRate'],
+        pair_info['lastFundingVelocity'],
+        pair_info['maxFundingFeePerBlock'],
+        pair_info['lastFundingBlock'],
+        str(block_number),
+        pair_info['longOI'],
+        pair_info['shortOI']
+    )
+
+    # Calculate funding fee
+    funding_raw = GetTradeFundingFee(
+        trade_details['funding'],
+        funding_rate_raw['accFundingLong'] if trade_details['isBuy'] else funding_rate_raw['accFundingShort'],
+        trade_details['collateral'],
+        trade_details['leverage']
+    )
+
+    # Calculate liquidation price
+    liquidation_price = GetTradeLiquidationPrice(
+        trade_details['openPrice'],
+        trade_details['isBuy'],
+        trade_details['collateral'],
+        trade_details['leverage'],
+        str(rollover_raw),
+        str(funding_raw)
+    )
+    liquidation_price = Decimal(liquidation_price) / PRECISION_18
+
+    # Calculate price impact
+    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']
+    )
+    price_after_impact = price_impact_raw['priceAfterImpact']
+
+    # Calculate PNL
+    pnl_raw = CurrentTradeProfitRaw(
+        trade_details['openPrice'],
+        price_after_impact,
+        trade_details['isBuy'],
+        trade_details['leverage'],
+        trade_details['collateral']
+    )
+
+    # Calculate total profit
+    total_profit_raw = CurrentTotalProfitRaw(
+        trade_details['openPrice'],
+        price_after_impact,
+        trade_details['isBuy'],
+        trade_details['leverage'],
+        trade_details['collateral'],
+        str(rollover_raw),
+        str(funding_raw)
+    )
+
+    # Calculate PNL percentage
+    pnl_percent_raw = CurrentTotalProfitP(
+        str(total_profit_raw), trade_details['collateral'])
+
+    # Convert values to proper decimals
+    pnl = Decimal(pnl_raw) / PRECISION_6
+    pnl_percent = Decimal(pnl_percent_raw) / PRECISION_6
+    net_pnl = Decimal(total_profit_raw) / PRECISION_6
+    total_profit = Decimal(total_profit_raw) / PRECISION_6
+    funding = Decimal(funding_raw) / PRECISION_6
+    rollover = Decimal(rollover_raw) / PRECISION_6
+    net_value = net_pnl + (Decimal(trade_details['collateral']) / PRECISION_6)
+    price_impact = Decimal(price_after_impact) / PRECISION_18
+
+    return {
+        'pnl': float(pnl),
+        '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),
+        'total_profit': float(total_profit),
+        'net_pnl': float(net_pnl),
+        'net_value': float(net_value),
+        'liquidation_price': float(liquidation_price),
+        'price_impact': float(price_impact)
+    }
+
+
+def ceil_div(a: int, b: int) -> int:
+    """Implements ceiling division for integers"""
+    return -((-a) // b)
+
+
+def GetFundingRate(
+    acc_per_oi_long: str,
+    acc_per_oi_short: str,
+    last_funding_rate: str,
+    last_velocity: str,
+    max_funding_fee_per_block: str,
+    last_update_block: str,
+    latest_block: str,
+    oi_long: str,
+    oi_short: str,
+) -> Dict[str, Union[str, bool]]:
+    # Convert string inputs to integers (similar to BigNumber.from)
+    acc_per_oi_long_bn = int(acc_per_oi_long)
+    acc_per_oi_short_bn = int(acc_per_oi_short)
+    last_funding_rate_bn = int(last_funding_rate)
+    last_velocity_bn = int(last_velocity)
+    max_funding_fee_per_block_bn = int(max_funding_fee_per_block)
+    last_update_block_bn = int(last_update_block)
+    latest_block_bn = int(latest_block)
+    oi_long_bn = int(oi_long)
+    oi_short_bn = int(oi_short)
+
+    value_long = acc_per_oi_long_bn
+    value_short = acc_per_oi_short_bn
+    fr = 0
+
+    abs_last_funding_rate = abs(last_funding_rate_bn)
+    abs_last_velocity = abs(last_velocity_bn)
+
+    num_blocks = latest_block_bn - last_update_block_bn
+    new_funding_rate = last_funding_rate_bn + (last_velocity_bn * num_blocks)
+    abs_new_funding_rate = abs(new_funding_rate)
+
+    num_blocks_to_charge = num_blocks
+
+    accumulated_funding_rate_change = 0
+    longs_pay = False
+    funding_rate_to_use = 0
+
+    if abs_new_funding_rate > max_funding_fee_per_block_bn:
+        num_blocks_to_limit = (
+            max_funding_fee_per_block_bn - abs_last_funding_rate) // abs_last_velocity
+
+        if (new_funding_rate * last_funding_rate_bn) < 0:
+            num_blocks_to_charge = num_blocks_to_charge + \
+                (2 * last_funding_rate_bn) // last_velocity_bn
+
+        accumulated_funding_rate_change = (
+            abs_last_funding_rate +
+            (ceil_div(num_blocks_to_limit, 2) * abs_last_velocity)
+        ) * num_blocks_to_limit + (
+            (num_blocks_to_charge - num_blocks_to_limit) *
+            max_funding_fee_per_block_bn
+        )
+
+        if new_funding_rate > 0:
+            longs_pay = True
+            fr = max_funding_fee_per_block_bn
+        else:
+            longs_pay = False
+            fr = -max_funding_fee_per_block_bn
+    else:
+        funding_rate_to_use = abs_new_funding_rate if abs_new_funding_rate > abs_last_funding_rate else abs_last_funding_rate
+
+        if (last_funding_rate_bn * new_funding_rate) < 0:
+            num_blocks_to_charge = num_blocks_to_charge - \
+                (2 * funding_rate_to_use) // abs_last_velocity
+
+        longs_pay = (new_funding_rate + last_funding_rate_bn) >= 0
+
+        accumulated_funding_rate_change = (
+            funding_rate_to_use +
+            (ceil_div(num_blocks_to_charge, 2) * abs_last_velocity)
+        ) * num_blocks_to_charge
+
+        fr = new_funding_rate
+
+    if longs_pay:
+        value_long = value_long + \
+            (accumulated_funding_rate_change if oi_long_bn > 0 else 0)
+
+        if oi_short_bn != 0:
+            value_short = value_short - \
+                (accumulated_funding_rate_change * oi_long_bn) // oi_short_bn
+    else:
+        value_short = value_short + \
+            (accumulated_funding_rate_change if oi_short_bn > 0 else 0)
+
+        if oi_long_bn != 0:
+            value_long = value_long - \
+                (accumulated_funding_rate_change * oi_short_bn) // oi_long_bn
+
+    return {
+        'accFundingLong': str(value_long),
+        'accFundingShort': str(value_short),
+        'latestFundingRate': str(fr),
+        'longsPay': longs_pay,
+    }

ostium_python_sdk/ostium.py

@@ -0,0 +1,320 @@
+import os
+import traceback
+from enum import Enum
+
+from .abi import usdc_abi, ostium_trading_abi, ostium_trading_storage_abi
+from web3 import Web3
+from .utils import convert_to_scaled_integer, fromErrorCodeToMessage, get_tp_sl_prices, to_base_units
+
+
+class OpenOrderType(Enum):
+    MARKET = 0
+    LIMIT = 1
+    STOP = 2
+
+
+class Ostium:
+    def __init__(self, w3: Web3, usdc_address: str, ostium_trading_storage_address: str, ostium_trading_address: str) -> None:
+        self.web3 = w3
+
+        self.usdc_address = usdc_address
+        self.ostium_trading_storage_address = ostium_trading_storage_address
+        self.ostium_trading_address = ostium_trading_address
+
+        # Create contract instance
+        self.usdc_contract = self.web3.eth.contract(
+            address=self.usdc_address, abi=usdc_abi)
+        self.ostium_trading_storage_contract = self.web3.eth.contract(
+            address=self.ostium_trading_storage_address, abi=ostium_trading_storage_abi)
+        self.ostium_trading_contract = self.web3.eth.contract(
+            address=self.ostium_trading_address, abi=ostium_trading_abi)
+
+    def get_block_number(self):
+        return self.web3.eth.get_block('latest')['number']
+
+    def get_nonce(self, address):
+        return self.web3.eth.get_transaction_count(address)
+
+    def perform_trade(self, trade_params, pvt_key, at_price):
+        account = self.web3.eth.account.from_key(pvt_key)
+
+        amount = to_base_units(trade_params['collateral'], decimals=6)
+        self.__approve(account, amount)
+        try:
+            # Log input trade parameters for verification
+            print("Final trade parameters being sent:", trade_params)
+
+            tp_price, sl_price = get_tp_sl_prices(trade_params)
+            # Define trade parameters and execute trade
+            trade = {
+                'collateral': convert_to_scaled_integer(trade_params['collateral'], precision=5, scale=6),
+                # Example open price, adjust as needed
+                'openPrice': convert_to_scaled_integer(at_price),
+                'tp': convert_to_scaled_integer(tp_price),
+                'sl': convert_to_scaled_integer(sl_price),
+                'trader': account.address,
+                'leverage': to_base_units(trade_params['leverage'], decimals=2),
+                'pairIndex': int(trade_params['asset_type']),
+                'index': 0,
+                'buy': trade_params['direction']
+            }
+
+            order_type = OpenOrderType.MARKET.value  # assume market order
+
+            if 'order_type' in trade_params:
+                if trade_params['order_type'] == 'LIMIT':
+                    order_type = OpenOrderType.LIMIT.value
+                elif trade_params['order_type'] == 'STOP':
+                    order_type = OpenOrderType.STOP.value
+                elif trade_params['order_type'] == 'MARKET':
+                    pass
+                else:
+                    raise Exception('Invalid order type')
+
+            # Log the structured trade object to be sent
+            # print("Structured trade object:", trade)
+
+            trade_tx = self.ostium_trading_contract.functions.openTrade(
+                trade, order_type, 9000).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=account.key)
+            trade_tx_hash = self.web3.eth.send_raw_transaction(
+                signed_tx.raw_transaction)
+            # print('Trade TX Hash:', trade_tx_hash.hex())
+
+            # Wait for the trade transaction to be mined
+            trade_receipt = self.web3.eth.wait_for_transaction_receipt(
+                trade_tx_hash)
+            print('Trade Receipt:', trade_receipt)
+            return trade_receipt
+        except Exception as e:
+            reason_string, suggestion = fromErrorCodeToMessage(e)
+            print(
+                f"An error ({str(e)}) occurred during the trading process - parsed as {reason_string}")
+            # traceback.print_exc()  # This prints the full traceback
+            raise Exception(
+                f'{reason_string}\n\n{suggestion}' if suggestion != None else reason_string)
+
+    # Cancel Limit and Stop orders
+
+    def cancel_limit_order(self, pairID, index, pvt_key):
+        account = self.web3.eth.account.from_key(pvt_key)
+
+        trade_tx = self.ostium_trading_contract.functions.cancelOpenLimitOrder(
+            int(pairID), int(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=account.key)
+        trade_tx_hash = self. web3.eth.send_raw_transaction(
+            signed_tx.raw_transaction)
+        print('Cancel Limit Order TX Hash:', trade_tx_hash.hex())
+
+        # Wait for the trade transaction to be mined
+        trade_receipt = self.web3.eth.wait_for_transaction_receipt(
+            trade_tx_hash)
+        print('Cancel Limit Order Receipt:', trade_receipt)
+        return trade_receipt
+
+    def close_trade(self, pairID, index, pvt_key):
+        account = self.web3.eth.account.from_key(pvt_key)
+
+        trade_tx = self.ostium_trading_contract.functions.closeTradeMarket(
+            int(pairID), int(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=account.key)
+        trade_tx_hash = self. web3.eth.send_raw_transaction(
+            signed_tx.raw_transaction)
+        print('Trade TX Hash:', trade_tx_hash.hex())
+
+        # Wait for the trade transaction to be mined
+        trade_receipt = self.web3.eth.wait_for_transaction_receipt(
+            trade_tx_hash)
+        print('Trade Receipt:', trade_receipt)
+        return trade_receipt
+
+    def add_collateral(self, pairID, index, collateral, pvt_key):
+        try:
+            account = self.web3.eth.account.from_key(pvt_key)
+            amount = to_base_units(collateral, decimals=6)
+            self.__approve(account, amount)
+
+            add_collateral_tx = self.ostium_trading_contract.functions.topUpCollateral(
+                int(pairID), int(index), amount).build_transaction({'from': account.address})
+            add_collateral_tx['nonce'] = self.get_nonce(account.address)
+
+            signed_tx = self.web3.eth.account.sign_transaction(
+                add_collateral_tx, private_key=account.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())
+            # Wait for the trade transaction to be mined
+            add_collateral_receipt = self.web3.eth.wait_for_transaction_receipt(
+                add_collateral_tx_hash)
+            print('Add Collateral Receipt:', add_collateral_receipt)
+            return add_collateral_receipt
+
+        except Exception as e:
+            print("An error occurred during the add collateral process:")
+            traceback.print_exc()  # This prints the full traceback
+            raise e  # Optionally re-raise the exception if you want it to propagate
+
+    def update_tp(self, pairID, index, tp, pvt_key):
+        try:
+            account = self.web3.eth.account.from_key(pvt_key)
+
+            tp_value = to_base_units(tp, decimals=18)
+
+            update_tp_tx = self.ostium_trading_contract.functions.updateTp(
+                int(pairID), int(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=account.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())
+        except Exception as e:
+            print("An error occurred during the update tp process:")
+            traceback.print_exc()  # This prints the full traceback
+            raise e  # Optionally re-raise the exception if you want it to propagate
+
+    def update_sl(self, pairID, index, sl, pvt_key):
+        try:
+            account = self.web3.eth.account.from_key(pvt_key)
+            sl_value = to_base_units(sl, decimals=18)
+
+            update_sl_tx = self.ostium_trading_contract.functions.updateSl(
+                int(pairID), int(index), sl_value).build_transaction({'from': account.address})
+            update_sl_tx['nonce'] = self.get_nonce(account.address)
+
+            signed_tx = self.web3.eth.account.sign_transaction(
+                update_sl_tx, private_key=account.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())
+        except Exception as e:
+            print(f"An error occurred during the update sl process: {e}")
+            reason_string, suggestion = fromErrorCodeToMessage(str(e))
+            print(
+                f"An error occurred during the update sl process: {reason_string}")
+            # traceback.print_exc()  # This prints the full traceback
+            # Optionally re-raise the exception if you want it to propagate
+            raise Exception(
+                f'{reason_string}\n\n{suggestion}' if suggestion != None else reason_string)
+
+    def __approve(self, account, collateral):
+        # Approve the transaction
+        # Approval tx should only be done if sufficient amount is not already approved.
+
+        allowance = self.usdc_contract.functions.allowance(
+            account.address, self.ostium_trading_storage_address).call()
+
+        if allowance < collateral:
+            approve_tx = self.usdc_contract.functions.approve(
+                self.ostium_trading_storage_address,
+                self.web3.to_wei(1000000, 'mwei')
+            ).build_transaction({'from': account.address})
+
+            approve_tx['nonce'] = self.get_nonce(account.address)
+
+            signed_tx = self.web3.eth.account.sign_transaction(
+                approve_tx, private_key=account.key)
+            approve_tx_hash = self.web3.eth.send_raw_transaction(
+                signed_tx.raw_transaction)
+            print('Approval TX Hash:', approve_tx_hash.hex())
+
+            # Ensure the approval transaction is mined
+            approve_receipt = self.web3.eth.wait_for_transaction_receipt(
+                approve_tx_hash)
+            print('Approval Receipt:', approve_receipt)
+
+    def withdraw(self, amount, receiving_address, pvt_key):
+        try:
+            account = self.web3.eth.account.from_key(pvt_key)
+            amount_in_base_units = to_base_units(amount, decimals=6)
+
+            if not self.web3.is_address(receiving_address):
+                raise ValueError("Invalid Arbitrum address format")
+
+            # Use USDCs' transfer function to send funds to the receiving address
+            transfer_tx = self.usdc_contract.functions.transfer(
+                receiving_address,
+                amount_in_base_units
+            ).build_transaction({'from': account.address})
+
+            transfer_tx['nonce'] = self.get_nonce(account.address)
+
+            signed_tx = self.web3.eth.account.sign_transaction(
+                transfer_tx, private_key=account.key)
+            transfer_tx_hash = self.web3.eth.send_raw_transaction(
+                signed_tx.raw_transaction)
+            print('Transfer TX Hash:', transfer_tx_hash.hex())
+
+            transfer_receipt = self.web3.eth.wait_for_transaction_receipt(
+                transfer_tx_hash)
+            print('Transfer Receipt:', transfer_receipt)
+            return transfer_receipt
+
+        except Exception as e:
+            reason_string, suggestion = fromErrorCodeToMessage(str(e))
+            print(
+                f"An error occurred during the transfer process: {reason_string}")
+            raise Exception(
+                f'{reason_string}\n\n{suggestion}' if suggestion != None else reason_string)
+
+    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,
+                int(pair_id),
+                int(index)
+            ).call()
+
+            print('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
+            tp_value = convert_to_scaled_integer(
+                tp) if tp is not None else existing_order[2]    # tp
+            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),
+                price_value,
+                tp_value,
+                sl_value
+            ).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=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())
+
+            trade_receipt = self.web3.eth.wait_for_transaction_receipt(
+                trade_tx_hash)
+            print('Update Limit Order Receipt:', trade_receipt)
+            return trade_receipt
+
+        except Exception as e:
+            reason_string, suggestion = fromErrorCodeToMessage(str(e))
+            print(
+                f"An error occurred during the update limit order process: {reason_string}")
+            raise Exception(
+                f'{reason_string}\n\n{suggestion}' if suggestion != None else reason_string)

ostium_python_sdk/price.py

@@ -0,0 +1,37 @@
+import aiohttp
+import json
+from typing import Tuple
+
+
+class Price:
+    def __init__(self):
+        self.base_url = "https://listener.ostium.io"
+
+    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}")
+
+    async def get_price(self, from_asset: str, to_asset: str) -> Tuple[float, bool]:
+        """
+        Get the latest price and market status for a specific asset pair.
+        Args:
+            from_asset: The base asset symbol (e.g., "BTC")
+            to_asset: The quote asset symbol (e.g., "USD")
+        Returns:
+            Tuple[float, bool]: The latest price and market open status for the asset pair
+        """
+        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):
+                return float(price_data.get('mid', 0)), price_data.get('isMarketOpen', False)
+        raise ValueError(f"No price found for pair: {from_asset}/{to_asset}")

ostium_python_sdk/sdk.py

@@ -0,0 +1,33 @@
+from typing import Optional
+from web3 import Web3
+from .config import NetworkConfig
+from .ostium import Ostium
+# from .formulae import Formulae
+from .subgraph import SubgraphClient
+from .price import Price
+from .balance import Balance
+
+
+class OstiumSDK:
+    def __init__(
+        self,
+        network_config: NetworkConfig,
+        custom_rpc_url: Optional[str] = None,
+        custom_graph_url: Optional[str] = None
+    ):
+        self.config = network_config
+        self.w3 = Web3(Web3.HTTPProvider(
+            custom_rpc_url or network_config.rpc_url
+        ))
+        self.ostium = Ostium(
+            self.w3,
+            network_config.contracts["usdc"],
+            network_config.contracts["trading"],
+            network_config.contracts["tradingStorage"]
+        )
+        # self.formulae = Formulae()
+        self.subgraph = SubgraphClient(
+            custom_graph_url or network_config.graph_url
+        )
+        self.price = Price()
+        self.balance = Balance(self.w3, network_config.contracts["usdc"])