introduce to tests
This commit is contained in:
607
florida/tests/backtest/mocks.py
Normal file
607
florida/tests/backtest/mocks.py
Normal file
@ -0,0 +1,607 @@
|
||||
|
||||
import time
|
||||
import logging
|
||||
from decimal import Decimal
|
||||
from typing import Dict, List, Any, Optional
|
||||
from hexbytes import HexBytes
|
||||
|
||||
logger = logging.getLogger("BACKTEST_MOCK")
|
||||
|
||||
class MockExchangeState:
|
||||
"""
|
||||
Central source of truth for the simulation.
|
||||
Acts as the "Blockchain" and the "CEX Engine".
|
||||
"""
|
||||
def __init__(self):
|
||||
self.current_time_ms = 0
|
||||
self.prices = {} # symbol -> price (Decimal)
|
||||
self.ticks = {} # symbol -> current tick (int)
|
||||
|
||||
# Balances
|
||||
self.wallet_balances = {
|
||||
"NATIVE": Decimal("100.0"), # ETH or BNB
|
||||
"ETH": Decimal("100.0"),
|
||||
"USDC": Decimal("100000.0"),
|
||||
"WETH": Decimal("100.0"),
|
||||
"BNB": Decimal("100.0"),
|
||||
"WBNB": Decimal("100.0"),
|
||||
"USDT": Decimal("100000.0")
|
||||
}
|
||||
self.hl_balances = {"USDC": Decimal("10000.0"), "USDT": Decimal("10000.0")}
|
||||
self.hl_positions = {} # symbol -> {size, entry_px, unrealized_pnl}
|
||||
|
||||
# Uniswap Positions
|
||||
self.next_token_id = 1000
|
||||
self.uni_positions = {} # token_id -> {liquidity, tickLower, tickUpper, ...}
|
||||
|
||||
# Hyperliquid Orders
|
||||
self.hl_orders = [] # List of {oid, coin, side, limitPx, sz, timestamp}
|
||||
self.next_oid = 1
|
||||
|
||||
# Fees/PnL Tracking
|
||||
self.uni_fees_collected = Decimal("0.0")
|
||||
self.hl_fees_paid = Decimal("0.0")
|
||||
self.hl_realized_pnl = Decimal("0.0")
|
||||
|
||||
# Pending TXs (Simulating Mempool/Execution)
|
||||
self.pending_txs = []
|
||||
|
||||
def update_price(self, symbol: str, price: Decimal, tick: int = 0):
|
||||
self.prices[symbol] = price
|
||||
if tick:
|
||||
self.ticks[symbol] = tick
|
||||
|
||||
# Update PnL for open positions
|
||||
if symbol in self.hl_positions:
|
||||
pos = self.hl_positions[symbol]
|
||||
size = pos['size']
|
||||
if size != 0:
|
||||
# Long: (Price - Entry) * Size
|
||||
# Short: (Entry - Price) * abs(Size)
|
||||
if size > 0:
|
||||
pos['unrealized_pnl'] = (price - pos['entry_px']) * size
|
||||
else:
|
||||
pos['unrealized_pnl'] = (pos['entry_px'] - price) * abs(size)
|
||||
|
||||
def process_trade(self, trade_data):
|
||||
"""Simulate fee accumulation from market trades."""
|
||||
# trade_data: {price, size, ...} from CSV
|
||||
try:
|
||||
# DEBUG: Confirm entry
|
||||
if getattr(self, '_debug_trade_entry', False) is False:
|
||||
logger.info(f"DEBUG: Processing Trades... Positions: {len(self.uni_positions)}")
|
||||
self._debug_trade_entry = True
|
||||
|
||||
price = Decimal(trade_data['price'])
|
||||
size = Decimal(trade_data['size']) # Amount in Base Token (BNB)
|
||||
|
||||
# Simple Fee Logic:
|
||||
# If trade price is within a position's range, it earns fees.
|
||||
# Fee = Volume * 0.05% (Fee Tier) * MarketShare (Assume 10%)
|
||||
|
||||
fee_tier = Decimal("0.0005") # 0.05%
|
||||
|
||||
# Realistic Market Share Simulation
|
||||
# Assume Pool Depth in active ticks is $5,000,000
|
||||
# Our Position is approx $1,000
|
||||
# Share = 1,000 / 5,000,000 = 0.0002 (0.02%)
|
||||
market_share = Decimal("0.0002")
|
||||
|
||||
import math
|
||||
# Current Tick of the trade
|
||||
try:
|
||||
# price = 1.0001^tick -> tick = log(price) / log(1.0001)
|
||||
# Note: If T0=USDT, Price T0/T1 = 1/Price_USD.
|
||||
# But our TickLower/Upper in Mock are generated based on T0=USDT logic?
|
||||
# clp_manager calculates ticks based on price_from_tick logic.
|
||||
|
||||
# If T0=USDT, T1=WBNB. Price (T0/T1) ~ 0.00116.
|
||||
# Ticks will be negative.
|
||||
# Trade Price is 860.
|
||||
# We need to invert price to get tick if the pool is inverted.
|
||||
# For BNB tests, we know T0=USDT.
|
||||
|
||||
# Invert price for tick calc
|
||||
inv_price = Decimal("1") / price
|
||||
tick = int(math.log(float(inv_price)) / math.log(1.0001))
|
||||
except:
|
||||
tick = 0
|
||||
|
||||
# Iterate all OPEN Uniswap positions
|
||||
for token_id, pos in self.uni_positions.items():
|
||||
# Check Range
|
||||
if pos['tickLower'] <= tick <= pos['tickUpper']:
|
||||
vol_usd = price * size
|
||||
fee_earned = vol_usd * fee_tier * market_share
|
||||
pos['tokensOwed0'] = pos.get('tokensOwed0', 0) + int(fee_earned * 10**18)
|
||||
|
||||
# Debug logging (Disabled for production runs)
|
||||
# if getattr(self, '_debug_fee_log_count', 0) < 10:
|
||||
# logger.info(f"DEBUG: Fee Earned! Tick {tick} inside {pos['tickLower']} <-> {pos['tickUpper']}. Fee: {fee_earned}")
|
||||
# self._debug_fee_log_count = getattr(self, '_debug_fee_log_count', 0) + 1
|
||||
|
||||
else:
|
||||
# Debug logging (Disabled)
|
||||
# if getattr(self, '_debug_tick_log_count', 0) < 10:
|
||||
# logger.info(f"DEBUG: Trade Tick {tick} OUTSIDE {pos['tickLower']} <-> {pos['tickUpper']} (Price: {price})")
|
||||
# self._debug_tick_log_count = getattr(self, '_debug_tick_log_count', 0) + 1
|
||||
pass
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error processing trade: {e}")
|
||||
|
||||
def process_transaction(self, tx_data):
|
||||
"""Executes a pending transaction and updates state."""
|
||||
func = tx_data['func']
|
||||
args = tx_data['args']
|
||||
value = tx_data.get('value', 0)
|
||||
contract_addr = tx_data['contract']
|
||||
|
||||
logger.info(f"PROCESSING TX: {func} on {contract_addr} Val: {value}")
|
||||
|
||||
# 1. DEPOSIT (Wrap)
|
||||
if func == "deposit":
|
||||
# Wrap Native -> Wrapped
|
||||
# Assume contract_addr is the wrapped token
|
||||
# In mocks, we map address to symbol
|
||||
# But we don't have the instance here easily, so we guess.
|
||||
# If value > 0, it's a wrap.
|
||||
amount = Decimal(value) / Decimal(10**18)
|
||||
if self.wallet_balances.get("NATIVE", 0) >= amount:
|
||||
self.wallet_balances["NATIVE"] -= amount
|
||||
# Find which token this is.
|
||||
# If it's the WETH/WBNB address
|
||||
target_token = "WBNB" # Default assumption for this test profile
|
||||
if contract_addr == "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": target_token = "WETH"
|
||||
|
||||
self.wallet_balances[target_token] = self.wallet_balances.get(target_token, 0) + amount
|
||||
logger.info(f"Wrapped {amount} NATIVE to {target_token}")
|
||||
else:
|
||||
logger.error("Insufficient NATIVE balance for wrap")
|
||||
|
||||
# 2. MINT (New Position)
|
||||
elif func == "mint":
|
||||
# Params: (token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, ...)
|
||||
params = args[0]
|
||||
token0 = params[0]
|
||||
token1 = params[1]
|
||||
amount0 = Decimal(params[5]) / Decimal(10**18) # Approx decimals
|
||||
amount1 = Decimal(params[6]) / Decimal(10**18)
|
||||
|
||||
logger.info(f"Minting Position: {amount0} T0, {amount1} T1")
|
||||
|
||||
# Deduct Balances (Simplified: assuming we have enough)
|
||||
# In real mock we should check symbols
|
||||
self.wallet_balances["WBNB"] = max(0, self.wallet_balances.get("WBNB", 0) - amount0)
|
||||
self.wallet_balances["USDT"] = max(0, self.wallet_balances.get("USDT", 0) - amount1)
|
||||
|
||||
# Create Position
|
||||
token_id = self.next_token_id
|
||||
self.next_token_id += 1
|
||||
|
||||
self.uni_positions[token_id] = {
|
||||
"token0": token0,
|
||||
"token1": token1,
|
||||
"tickLower": params[3],
|
||||
"tickUpper": params[4],
|
||||
"liquidity": 1000000 # Dummy liquidity
|
||||
}
|
||||
logger.info(f"Minted TokenID: {token_id}")
|
||||
self.last_minted_token_id = token_id
|
||||
return token_id # Helper return
|
||||
|
||||
# 3. COLLECT (Fees)
|
||||
elif func == "collect":
|
||||
# Params: (params) -> (tokenId, recipient, amount0Max, amount1Max)
|
||||
params = args[0]
|
||||
token_id = params[0]
|
||||
|
||||
# Retrieve accumulated fees
|
||||
if token_id in self.uni_positions:
|
||||
pos = self.uni_positions[token_id]
|
||||
owed1 = Decimal(pos.get('tokensOwed1', 0)) / Decimal(10**18)
|
||||
owed0 = Decimal(pos.get('tokensOwed0', 0)) / Decimal(10**18)
|
||||
|
||||
# Reset
|
||||
pos['tokensOwed1'] = 0
|
||||
pos['tokensOwed0'] = 0
|
||||
|
||||
fee0 = owed0
|
||||
fee1 = owed1
|
||||
else:
|
||||
fee0 = Decimal("0")
|
||||
fee1 = Decimal("0")
|
||||
|
||||
self.wallet_balances["WBNB"] = self.wallet_balances.get("WBNB", 0) + fee0
|
||||
self.wallet_balances["USDT"] = self.wallet_balances.get("USDT", 0) + fee1
|
||||
|
||||
# Calculate USD Value of fees
|
||||
# T0 = USDT, T1 = WBNB
|
||||
# fee0 is USDT, fee1 is WBNB
|
||||
price = self.state.prices.get("BNB", Decimal("0"))
|
||||
usd_val = fee0 + (fee1 * price)
|
||||
|
||||
self.uni_fees_collected += usd_val
|
||||
logger.info(f"Collected Fees for {token_id}: {fee0:.4f} T0 + {fee1:.4f} T1 = ${usd_val:.2f}")
|
||||
|
||||
# 4. SWAP (ExactInputSingle)
|
||||
elif func == "exactInputSingle":
|
||||
# Params: (params) -> struct
|
||||
# struct ExactInputSingleParams {
|
||||
# address tokenIn; address tokenOut; fee; recipient; deadline; amountIn; amountOutMinimum; sqrtPriceLimitX96;
|
||||
# }
|
||||
# Since args[0] is the struct (tuple/list)
|
||||
# We need to guess indices or check ABI.
|
||||
# Standard: tokenIn(0), tokenOut(1), fee(2), recipient(3), deadline(4), amountIn(5), minOut(6)
|
||||
params = args[0]
|
||||
token_in_addr = params[0]
|
||||
token_out_addr = params[1]
|
||||
amount_in_wei = params[5]
|
||||
|
||||
# Map address to symbol
|
||||
# We can't access contract instance here easily, so use known map or iterate
|
||||
sym_map = {
|
||||
"0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": "WETH",
|
||||
"0xaf88d065e77c8cC2239327C5EDb3A432268e5831": "USDC",
|
||||
"0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c": "WBNB",
|
||||
"0x55d398326f99059fF775485246999027B3197955": "USDT"
|
||||
}
|
||||
|
||||
sym_in = sym_map.get(token_in_addr, "UNKNOWN")
|
||||
sym_out = sym_map.get(token_out_addr, "UNKNOWN")
|
||||
|
||||
amount_in = Decimal(amount_in_wei) / Decimal(10**18) # Approx
|
||||
if sym_in in ["USDC", "USDT"]: amount_in = Decimal(amount_in_wei) / Decimal(10**18) # Mock usually 18 dec for simplicity unless specified
|
||||
|
||||
# Price calculation
|
||||
# If swapping Base (WBNB) -> Quote (USDT), Price is ~300
|
||||
# If Quote -> Base, Price is 1/300
|
||||
price = self.prices.get("BNB", Decimal("300"))
|
||||
|
||||
amount_out = 0
|
||||
if sym_in == "WBNB" and sym_out == "USDT":
|
||||
amount_out = amount_in * price
|
||||
elif sym_in == "USDT" and sym_out == "WBNB":
|
||||
amount_out = amount_in / price
|
||||
else:
|
||||
amount_out = amount_in # 1:1 fallback
|
||||
|
||||
self.wallet_balances[sym_in] = max(0, self.wallet_balances.get(sym_in, 0) - amount_in)
|
||||
self.wallet_balances[sym_out] = self.wallet_balances.get(sym_out, 0) + amount_out
|
||||
|
||||
logger.info(f"SWAP: {amount_in:.4f} {sym_in} -> {amount_out:.4f} {sym_out}")
|
||||
|
||||
def match_orders(self):
|
||||
"""Simple order matching against current price."""
|
||||
# In a real backtest, we'd check High/Low of the candle or Orderbook depth.
|
||||
# Here we assume perfect liquidity at current price for simplicity,
|
||||
# or implement simple slippage.
|
||||
pass
|
||||
|
||||
# --- WEB3 MOCKS ---
|
||||
|
||||
class MockContractFunction:
|
||||
def __init__(self, name, parent_contract, state: MockExchangeState):
|
||||
self.name = name
|
||||
self.contract = parent_contract
|
||||
self.state = state
|
||||
self.args = []
|
||||
|
||||
def __call__(self, *args, **kwargs):
|
||||
self.args = args
|
||||
return self
|
||||
|
||||
def call(self, transaction=None):
|
||||
# SIMULATE READS
|
||||
if self.name == "slot0":
|
||||
# Determine Pair
|
||||
symbol = "BNB" if "BNB" in self.state.prices else "ETH"
|
||||
price = self.state.prices.get(symbol, Decimal("300"))
|
||||
|
||||
# For BNB Chain, T0 is USDT (0x55d), T1 is WBNB (0xbb4)
|
||||
# Price of T0 (USDT) in T1 (WBNB) is 1 / Price
|
||||
if symbol == "BNB":
|
||||
if price > 0:
|
||||
price = Decimal("1") / price
|
||||
else:
|
||||
price = Decimal("0")
|
||||
|
||||
sqrt_px = price.sqrt() * (2**96)
|
||||
|
||||
# Tick
|
||||
import math
|
||||
try:
|
||||
# price = 1.0001^tick
|
||||
tick = int(math.log(float(price)) / math.log(1.0001))
|
||||
except:
|
||||
tick = 0
|
||||
|
||||
return (int(sqrt_px), tick, 0, 0, 0, 0, True)
|
||||
|
||||
if self.name == "positions":
|
||||
token_id = self.args[0]
|
||||
if token_id in self.state.uni_positions:
|
||||
p = self.state.uni_positions[token_id]
|
||||
return (0, "", p['token0'], p['token1'], 500, p['tickLower'], p['tickUpper'], p['liquidity'],
|
||||
0, 0, p.get('tokensOwed0', 0), p.get('tokensOwed1', 0))
|
||||
else:
|
||||
raise Exception("Position not found")
|
||||
|
||||
if self.name == "balanceOf":
|
||||
addr = self.args[0]
|
||||
# Hacky: detect token by contract address
|
||||
symbol = self.contract.symbol_map.get(self.contract.address, "UNKNOWN")
|
||||
return int(self.state.wallet_balances.get(symbol, 0) * (10**self.contract.decimals_val))
|
||||
|
||||
if self.name == "decimals":
|
||||
return self.contract.decimals_val
|
||||
|
||||
if self.name == "symbol":
|
||||
return self.contract.symbol_val
|
||||
|
||||
if self.name == "allowance":
|
||||
return 10**50 # Infinite allowance
|
||||
|
||||
# Pool Methods
|
||||
if self.name == "tickSpacing":
|
||||
return 10
|
||||
if self.name == "token0":
|
||||
# Return USDT for BNB profile (0x55d < 0xbb4)
|
||||
if "BNB" in self.state.prices:
|
||||
return "0x55d398326f99059fF775485246999027B3197955"
|
||||
return "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1" # WETH
|
||||
|
||||
if self.name == "token1":
|
||||
# Return WBNB for BNB profile
|
||||
if "BNB" in self.state.prices:
|
||||
return "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
|
||||
return "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" # USDC
|
||||
|
||||
if self.name == "fee":
|
||||
return 500
|
||||
if self.name == "liquidity":
|
||||
return 1000000000000000000
|
||||
|
||||
return None
|
||||
|
||||
def build_transaction(self, tx_params):
|
||||
# Queue Transaction for Execution
|
||||
self.state.pending_txs.append({
|
||||
"func": self.name,
|
||||
"args": self.args,
|
||||
"contract": self.contract.address,
|
||||
"value": tx_params.get("value", 0)
|
||||
})
|
||||
|
||||
return {"data": "0xMOCK", "to": self.contract.address, "value": tx_params.get("value", 0)}
|
||||
|
||||
def estimate_gas(self, tx_params):
|
||||
return 100000
|
||||
|
||||
class MockContract:
|
||||
def __init__(self, address, abi, state: MockExchangeState):
|
||||
self.address = address
|
||||
self.abi = abi
|
||||
self.state = state
|
||||
self.functions = self
|
||||
|
||||
# Meta for simulation
|
||||
self.symbol_map = {
|
||||
"0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": "WETH",
|
||||
"0xaf88d065e77c8cC2239327C5EDb3A432268e5831": "USDC",
|
||||
# BNB Chain
|
||||
"0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c": "WBNB", # FIXED: Was BNB, but address is WBNB
|
||||
"0x55d398326f99059fF775485246999027B3197955": "USDT"
|
||||
}
|
||||
symbol = self.symbol_map.get(address, "MOCK")
|
||||
is_stable = symbol in ["USDC", "USDT"]
|
||||
self.decimals_val = 18 if not is_stable else 6
|
||||
if symbol == "USDT": self.decimals_val = 18 # BNB USDT is 18
|
||||
self.symbol_val = symbol
|
||||
|
||||
def __getattr__(self, name):
|
||||
return MockContractFunction(name, self, self.state)
|
||||
|
||||
class MockEth:
|
||||
def __init__(self, state: MockExchangeState):
|
||||
self.state = state
|
||||
self.chain_id = 42161
|
||||
self.max_priority_fee = 100000000
|
||||
|
||||
def contract(self, address, abi):
|
||||
return MockContract(address, abi, self.state)
|
||||
|
||||
def get_block(self, block_identifier):
|
||||
return {'baseFeePerGas': 100000000, 'timestamp': self.state.current_time_ms // 1000}
|
||||
|
||||
def get_balance(self, address):
|
||||
# Native balance
|
||||
return int(self.state.wallet_balances.get("NATIVE", 0) * 10**18)
|
||||
|
||||
def get_transaction_count(self, account, block_identifier=None):
|
||||
return 1
|
||||
|
||||
def send_raw_transaction(self, raw_tx):
|
||||
# EXECUTE PENDING TX
|
||||
if self.state.pending_txs:
|
||||
tx_data = self.state.pending_txs.pop(0)
|
||||
res = self.state.process_transaction(tx_data)
|
||||
|
||||
return b'\x00' * 32
|
||||
|
||||
def wait_for_transaction_receipt(self, tx_hash, timeout=120):
|
||||
# MOCK LOGS GENERATION
|
||||
# We assume every tx is a successful Mint for now to test the flow
|
||||
# In a real engine we'd inspect the tx data to determine the event
|
||||
|
||||
# Transfer Topic: 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
|
||||
transfer_topic = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
|
||||
# IncreaseLiquidity Topic: 0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde
|
||||
increase_topic = "0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde"
|
||||
|
||||
# Use the actual minted ID if available, else dummy
|
||||
real_token_id = getattr(self.state, 'last_minted_token_id', 123456)
|
||||
token_id_hex = hex(real_token_id)[2:].zfill(64)
|
||||
|
||||
# Liquidity + Amount0 + Amount1
|
||||
# 1000 Liquidity, 1 ETH (18 dec), 3000 USDC (6 dec)
|
||||
# 1 ETH = 1e18, 3000 USDC = 3e9
|
||||
data_liq = "00000000000000000000000000000000000000000000000000000000000003e8" # 1000
|
||||
data_amt0 = "0000000000000000000000000000000000000000000000000de0b6b3a7640000" # 1e18
|
||||
data_amt1 = "00000000000000000000000000000000000000000000000000000000b2d05e00" # 3e9
|
||||
|
||||
class Receipt:
|
||||
status = 1
|
||||
blockNumber = 12345
|
||||
logs = [
|
||||
{
|
||||
'topics': [
|
||||
HexBytes(transfer_topic),
|
||||
HexBytes("0x0000000000000000000000000000000000000000000000000000000000000000"), # From
|
||||
HexBytes("0x0000000000000000000000000000000000000000000000000000000000000000"), # To
|
||||
HexBytes("0x" + token_id_hex) # TokenID
|
||||
],
|
||||
'data': b''
|
||||
},
|
||||
{
|
||||
'topics': [
|
||||
HexBytes(increase_topic)
|
||||
],
|
||||
'data': bytes.fromhex(data_liq + data_amt0 + data_amt1)
|
||||
}
|
||||
]
|
||||
|
||||
return Receipt()
|
||||
|
||||
class MockWeb3:
|
||||
def __init__(self, state: MockExchangeState):
|
||||
self.eth = MockEth(state)
|
||||
self.middleware_onion = type('obj', (object,), {'inject': lambda *args, **kwargs: None})
|
||||
|
||||
def is_connected(self):
|
||||
return True
|
||||
def to_checksum_address(self, addr):
|
||||
return addr
|
||||
def is_address(self, addr):
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def to_wei(val, unit):
|
||||
if unit == 'gwei': return int(val * 10**9)
|
||||
if unit == 'ether': return int(val * 10**18)
|
||||
return int(val)
|
||||
|
||||
@staticmethod
|
||||
def from_wei(val, unit):
|
||||
if unit == 'gwei': return Decimal(val) / Decimal(10**9)
|
||||
if unit == 'ether': return Decimal(val) / Decimal(10**18)
|
||||
return Decimal(val)
|
||||
|
||||
@staticmethod
|
||||
def keccak(text=None):
|
||||
return b'\x00'*32 # Dummy
|
||||
|
||||
# --- HYPERLIQUID MOCKS ---
|
||||
|
||||
class MockInfo:
|
||||
def __init__(self, state: MockExchangeState):
|
||||
self.state = state
|
||||
|
||||
def all_mids(self):
|
||||
# Return string prices as per API
|
||||
return {k: str(v) for k, v in self.state.prices.items()}
|
||||
|
||||
def user_state(self, address):
|
||||
positions = []
|
||||
for sym, pos in self.state.hl_positions.items():
|
||||
positions.append({
|
||||
"position": {
|
||||
"coin": sym,
|
||||
"szi": str(pos['size']),
|
||||
"entryPx": str(pos['entry_px']),
|
||||
"unrealizedPnl": str(pos['unrealized_pnl'])
|
||||
}
|
||||
})
|
||||
|
||||
return {
|
||||
"marginSummary": {
|
||||
"accountValue": str(self.state.hl_balances.get("USDC", 0)),
|
||||
"totalMarginUsed": "0",
|
||||
"totalNtlPos": "0",
|
||||
"totalRawUsd": "0"
|
||||
},
|
||||
"assetPositions": positions
|
||||
}
|
||||
|
||||
def open_orders(self, address):
|
||||
return self.state.hl_orders
|
||||
|
||||
def user_fills(self, address):
|
||||
return [] # TODO: Store fills in state
|
||||
|
||||
def l2_snapshot(self, coin):
|
||||
# Generate artificial orderbook around mid price
|
||||
price = self.state.prices.get(coin, Decimal("0"))
|
||||
if price == 0: return {'levels': [[], []]}
|
||||
|
||||
# Spread 0.05%
|
||||
bid = price * Decimal("0.99975")
|
||||
ask = price * Decimal("1.00025")
|
||||
|
||||
return {
|
||||
"levels": [
|
||||
[{"px": str(bid), "sz": "100.0", "n": 1}], # Bids
|
||||
[{"px": str(ask), "sz": "100.0", "n": 1}] # Asks
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class MockExchangeAPI:
|
||||
def __init__(self, state: MockExchangeState):
|
||||
self.state = state
|
||||
|
||||
def order(self, coin, is_buy, sz, limit_px, order_type, reduce_only=False):
|
||||
# Execute immediately for IO/Market, or add to book
|
||||
# Simulating Fill
|
||||
price = Decimal(str(limit_px))
|
||||
size = Decimal(str(sz))
|
||||
cost = price * size
|
||||
|
||||
# Fee (Taker 0.035%)
|
||||
fee = cost * Decimal("0.00035")
|
||||
self.state.hl_fees_paid += fee
|
||||
|
||||
# Update Position
|
||||
if coin not in self.state.hl_positions:
|
||||
self.state.hl_positions[coin] = {'size': Decimal(0), 'entry_px': Decimal(0), 'unrealized_pnl': Decimal(0)}
|
||||
|
||||
pos = self.state.hl_positions[coin]
|
||||
current_size = pos['size']
|
||||
|
||||
# Update Entry Price (Weighted Average)
|
||||
# New Entry = (OldSize * OldEntry + NewSize * NewPrice) / (OldSize + NewSize)
|
||||
signed_size = size if is_buy else -size
|
||||
new_size = current_size + signed_size
|
||||
|
||||
if new_size == 0:
|
||||
pos['entry_px'] = 0
|
||||
elif (current_size > 0 and signed_size > 0) or (current_size < 0 and signed_size < 0):
|
||||
# Increasing position
|
||||
val_old = abs(current_size) * pos['entry_px']
|
||||
val_new = size * price
|
||||
pos['entry_px'] = (val_old + val_new) / abs(new_size)
|
||||
else:
|
||||
# Closing/Reducing - Entry Price doesn't change, PnL is realized
|
||||
# Fraction closed
|
||||
closed_ratio = min(abs(signed_size), abs(current_size)) / abs(current_size)
|
||||
# This logic is simplified, real PnL logic is complex
|
||||
|
||||
pos['size'] = new_size
|
||||
|
||||
logger.info(f"MOCK HL EXEC: {coin} {'BUY' if is_buy else 'SELL'} {size} @ {price}. New Size: {new_size}")
|
||||
|
||||
return {"status": "ok", "response": {"data": {"statuses": [{"filled": {"oid": 123}}]}}}
|
||||
|
||||
def cancel(self, coin, oid):
|
||||
self.state.hl_orders = [o for o in self.state.hl_orders if o['oid'] != oid]
|
||||
return {"status": "ok"}
|
||||
Reference in New Issue
Block a user