1. Mladinska Liga stats & predictions

Fans' Corner: Engage with the Community

Being part of a community that shares your passion enhances your enjoyment of the sport. Engage with fellow fans through social media platforms, forums, and local events.

Social Media Interaction

• Join Fan Groups: Connect with other fans on platforms like Facebook and Twitter for discussions and updates.
• Promote Your Team: Share your support through fan pages and hashtags dedicated to your favorite teams.
• Participate in Polls: Engage in polls and surveys about upcoming matches or player performances.

In-Person Events

1. Fan Meetups: Attend local meetups or watch parties organized by fan clubs.
tylerjlewis/tylerjlewis.github.io<|file_sep|>/_posts/2020-02-12-simulating-liquidity-with-python.md --- layout: post title: Simulating Liquidity with Python --- ## Introduction In this post we will learn how we can simulate liquidity providers (LP) on a decentralized exchange (DEX). We will use Uniswap as our example DEX. We will explore three types of LP strategies: - Passive LP strategy where LPs deposit liquidity when markets open (AM) at market prices - Active LP strategy where LPs deposit liquidity when markets open (AM) at market prices but adjust their position based on price changes throughout the day - Active LP strategy where LPs deposit liquidity when markets open (AM) at market prices but adjust their position based on price changes throughout the day by only adding liquidity In all three cases we will assume that markets close at night (PM). At closing time all liquidity is withdrawn from Uniswap. For our simulation we will consider two assets `A` & `B`. We will assume that there is an oracle providing us with market prices throughout our simulation period. We will consider four scenarios: - AM prices are higher than PM prices (price drop) - AM prices are lower than PM prices (price increase) - AM prices are equal than PM prices (no change) - AM prices fluctuate throughout our simulation period ## Scenario Setup First let's import some packages: python import pandas as pd import numpy as np import matplotlib.pyplot as plt Next let's set up some constants: python # Simulation Constants # Number of days we will simulate n_days = 5 # Number of hours per day we will simulate n_hours_per_day = 8 # Initial price of asset A in terms of asset B am_price = 100 # Initial amount we want our LPs to have deposited am_deposited_A = am_price * am_price # Amount A = Price A * Amount B am_deposited_B = am_price # Amount B = Price A # Initial total supply tokens representing AM deposits (this includes tokens minted during rebalancing) total_supply_AM = am_deposited_A + am_deposited_B # Initial total supply tokens representing PM deposits (this includes tokens minted during rebalancing) total_supply_PM = am_deposited_A + am_deposited_B # Initial pool reserves (reserves are held by Uniswap contract) pool_reserves_A = am_deposited_A pool_reserves_B = am_deposited_B # Minimum amount required before rebalancing occurs min_amount = total_supply_AM * .001 # 0.1% of initial AM supply # Fee percentage charged by Uniswap per trade fee_percent = .003 # .3% # We will use this variable below when calculating Uniswap fees so that we don't need to divide by fee percent every time fee_mult = (100 - fee_percent) / 100 # Daily interest rate earned by staking AM tokens daily_interest_rate_AM = .005 # .5% # Daily interest rate earned by staking PM tokens daily_interest_rate_PM = .01 # 1% Now let's create some dataframes for storing our simulation results: python # Dataframe storing AM results am_df = pd.DataFrame(columns=['Time', 'Price', 'Pool Reserves A', 'Pool Reserves B', 'Total Supply', 'APY', 'Total Staked', 'Stake Rewards']) # Dataframe storing PM results pm_df = pd.DataFrame(columns=['Time', 'Price', 'Pool Reserves A', 'Pool Reserves B', 'Total Supply', 'APY', 'Total Staked', 'Stake Rewards']) # Dataframe storing rebalance information rebalance_df = pd.DataFrame(columns=['Time', 'Rebalanced Amount A', 'Rebalanced Amount B']) Let's also create some variables for tracking various metrics throughout our simulation: python # Variables tracking overall performance total_revenue_AM = 0 # Total revenue earned from staking AM tokens total_revenue_PM = 0 # Total revenue earned from staking PM tokens total_fees_AM = 0 # Total fees earned from trading AM tokens total_fees_PM = 0 # Total fees earned from trading PM tokens total_staked_AM = am_deposited_A + am_deposited_B # Total amount staked in AM tokens total_staked_PM = am_deposited_A + am_deposited_B # Total amount staked in PM tokens revenue_percent_AM = [] # List storing revenue percentages over time revenue_percent_PM = [] # List storing revenue percentages over time fees_percent_AM = [] # List storing fee percentages over time fees_percent_PM = [] # List storing fee percentages over time stake_percent_AM = [] # List storing stake percentages over time stake_percent_PM = [] # List storing stake percentages over time apys_AM = [] # List storing APYs over time apys_PM = [] # List storing APYs over time stake_rewards_AM = [] # List storing stake rewards over time stake_rewards_PM = [] # List storing stake rewards over time price_list_AM= [am_price] # List storing AM prices over time price_list_PM= [am_price] # List storing PM prices over time pool_reserves_list_A= [pool_reserves_A] # List storing pool reserves A over time pool_reserves_list_B= [pool_reserves_B] # List storing pool reserves B over time supply_list_AM= [total_supply_AM] # List storing total supply AM tokens over time supply_list_PM= [total_supply_PM] # List storing total supply PM tokens over time uniswap_fees_list_AM= [0] # List storing Uniswap fees collected over time uniswap_fees_list_PM= [0] # List storing Uniswap fees collected over time rebalancing_list_AM= [0] # List storing rebalancing amounts collected over time rebalancing_list_PM= [0] # List storing rebalancing amounts collected over time uniswap_fees_rebalancing_list_AM= [0] # List storing Uniswap fees collected during rebalancing transactions over time uniswap_fees_rebalancing_list_PM= [0] # List storing Uniswap fees collected during rebalancing transactions over time time_list= ['AM'] * n_hours_per_day + ['PM'] * n_hours_per_day * n_days Now let's define some functions which we will use later in our simulation: ### Rebalancing Function This function will be used whenever an LP wants to adjust their position relative to current market conditions. python def rebalance(time, amount_A_invested, amount_B_invested): global total_supply_AM global total_supply_PM global pool_reserves_A global pool_reserves_B global min_amount global fee_mult global rebalance_df global uniswap_fees_rebalancing_list_AM global uniswap_fees_rebalancing_list_PM global rebalancing_list_AM global rebalancing_list_PM if amount_A_invested == amount_B_invested: return if amount_A_invested > amount_B_invested: ratio_A_to_B_desired_by_LP=(amount_A_invested/amount_B_invested)*pool_reserves_B/((amount_A_invested/amount_B_invested)*pool_reserves_B+pool_reserves_A) ratio_B_to_A_desired_by_LP=(pool_reserves_A/(amount_A_invested/amount_B_invested)*pool_reserves_B)/((amount_A_invested/amount_B_invested)*pool_reserves_B+pool_reserves_A) ratio_current=ratio_A_to_B_desired_by_LP/ratio_B_to_A_desired_by_LP if ratio_current >= fee_mult: desired_amount_of_asset_B=(ratio_current-fee_mult)*pool_reserves_A/(fee_mult+fee_mult/ratio_current-1) desired_amount_of_asset_A=ratio_current*desired_amount_of_asset_B amount_of_asset_B_added_to_pool=ratio_current*desired_amount_of_asset_A-pool_reserves_B amount_of_asset_A_added_to_pool=ratio_current*(desired_amount_of_asset_A-pool_reserves_A)+desired_amount_of_asset_B-pool_reserves_B if abs(amount_of_asset_A_added_to_pool) >= min_amount or abs(amount_of_asset_B_added_to_pool) >= min_amount: if amount_of_asset_A_added_to_pool > -min_amount: if amount_of_asset_B_added_to_pool > -min_amount: pool_reserves_A+=amount_of_asset_A_added_to_pool pool_reserves_B+=amount_of_asset_B_added_to_pool uniswap_fees_rebalancing_list_AM.append(-1*min(fee_mult*abs(amount_of_asset_A_added_to_pool),fee_mult*abs(amount_of_asset_B_added_to_pool))) uniswap_fees_rebalancing_list_PM.append(0) rebalancing_list_AM.append(amount_of_asset_A_added_to_pool+amount_of_asset_B_added_to_pool) rebalancing_list_PM.append(0) total_supply_AM += amount_of_asset_A_added_to_pool+amount_of_asset_B_added_to_pool new_total_supply=total_supply_AM else: pool_reserves_A+=amount_of_asset_A_added_to_pool pool_reserves_B+=amount_of_asset_B_added_to_pool uniswap_fees_rebalancing_list_AM.append(-1*min(fee_mult*abs(amount_of_asset_A_added_to_pool),fee_mult*abs(amount_of_asset_B_added_to_pool))) uniswap_fees_rebalancing_list_PM.append(0) rebalancing_list_AM.append(amount_of_asset_A_added_to_pool+amount_of_asset_B_added_to_pool) rebalancing_list_PM.append(0) total_supply_AM += amount_of_asset_A_added_to_pool+amount_of_asset_B_added_to_pool new_total_supply=total_supply_AM else: if amount_of_asset_B_added_to_pool > -min_amount: pool_reserves_A+=amount_of_asset_A_added_to_pool pool_reserves_B+=amount_of_asset_B_added_to_pool uniswap_fees_rebalancing_list_AM.append(-1*min(fee_mult*abs(amount_of_asset_A_added_to_pool),fee_mult*abs(amount_of_asset_B_added_to_pool))) uniswap_fees_rebalancing_list_PM.append(0) rebalancing_list_AM.append(amount_of_asset_A_added_to_pool+amount_of_asset_B_added_to_pool) rebalancing_list_PM.append(0) total_supply_AM += amount_of_asset_A_added_to_pool+amount_of_asset_B_added_to_pool new_total_supply=total_supply_AM else: desired_amount_of_asset=A desired_amount=B pool_reserve_delta=-1*(ratio_current-fee_mult)*(desired_amount-A)+(ratio_current*(desired_amount-A)-B)/(ratio_current*(desired_amount-A)/B+1)-B delta_fee=min(fee_mult*abs(desired_amount-A),fee_mult*abs(B))*(-1) delta_fee_ratio=(delta_fee)/(delta_fee-desired_amount-A+B)-1 delta_fee_ratio_new=(delta_fee_ratio)*(ratio_current/(ratio_current-delta_fee_ratio)) desired_delta_ratio_new=((ratio_current-delta_fee_ratio_new)/(delta_fee_ratio_new))/(1+(ratio_current-delta_fee_ratio_new)/(delta_fee_ratio_new)) desired_delta_new=(desired_delta_ratio_new)*(desired_amount-A)/(desired_delta_ratio_new+1)+A-desired_amount delta_fee_new=min(fee_mult*abs(desired_delta_new),fee_mult*(