be-components 3.0.3 → 3.0.5

package/src/MarketComponents/components/MyOrderList/api/index.ts

@@ -0,0 +1,406 @@
+import moment from "moment-mini";
+import type { EventProps, HedgedPositionProps, HedgeProps, MarketProps, MatchProps, OrderProps, OrderStatsProps, PositionProps, TournamentProps } from "../../../../types";
+import { MarketComponentHelpers } from "../../../api";
+
+
+export const MyOrdersHelpers = {
+    getContestsFromOrders: (orders:OrderProps[]) => {
+        let event_ids = [ ...new Set(orders.filter(o => o.event_type == 'team').map(o => o.event_id))]
+        let tournament_ids = [ ...new Set(orders.filter(o => o.event_type == 'tournament').map(o => o.event_id))]
+        let match_ids = [ ...new Set(orders.filter(o => o.event_type == 'match').map(o => o.event_id))]
+        return { event_ids, tournament_ids, match_ids }
+    },
+    getHedgesFromPositions: (orders:OrderProps[], markets:MarketProps[]):HedgeProps[] => {
+        //1) Set up arrays to store hedges
+        let hedges:HedgeProps[] = []
+        let hedgeable_positions:Array<OrderProps[]> = []
+        //Only allow real money orders for hedging
+        orders = orders.filter(o => o.market_type === 'FOR_MONEY' && o.resolution_status !== 'closed')
+    
+        //2) Get the unique markets (and common var_1s) that are eligible to be hedged 
+        let orders_with_positions = orders.filter(o => o.positions[0])
+        let unique_markets = [ ...new Set(orders_with_positions.map(o => `${o.event_id}:${o.event_type}:${o.market_id}:${Math.abs(o.var_1)}`)) ]
+       
+        //3) For each unique market and var_1 combo, determin if there are positions on the opposite side of each other
+        //If so, then store them into an array of orders
+        unique_markets.map(id => {
+            //1) Get orders that are associated with the market
+            let market_orders = orders_with_positions.filter(o => `${o.event_id}:${o.event_type}:${o.market_id}:${Math.abs(o.var_1)}` == id)
+            if(market_orders.length < 2){ return } //Impossible to hedge with less than 2 orders
+            let unique_sides = [ ...new Set(market_orders.map(o => o.side)) ]
+            if(unique_sides.length < 0){ return } //Must have more than 1 side
+    
+            hedgeable_positions.push(market_orders)
+        })
+    
+        //Return nothing if there are no hedgeable positions
+        if(hedgeable_positions.length === 0){ return [] }
+    
+        //Awesome! We have some hedgeable positions
+        hedgeable_positions.map(hp => {
+            //Get an empty hedge object to store our hedges
+            let hedge = MyOrdersHelpers.getEmptyHedge()
+            let market = markets.find(m => m.market_id == hp[0]?.market_id)
+            if(!market){ return } //Error out if there is no market
+            if(market.level !== 'event'){ return } //Dont if level is not event
+    
+            let trade_side_orders = hp.filter(o => o.side == market?.trade_side)
+            let o_side_orders = hp.filter(o => o.side != market?.trade_side)
+            
+            //New
+            if(market.type == 'Spread'){
+                let this_order = trade_side_orders[0]
+                if(!this_order){ return } //Make sure there is at least 1 trade side order
+                o_side_orders = o_side_orders.filter(o => o.var_1 == this_order.var_1 * -1)
+            }
+    
+            if(trade_side_orders.length === 0 || o_side_orders.length === 0){ return }
+    
+            if(!hp[0]){ return }
+    
+    
+            hedge.market_id = market.market_id
+            hedge.market_type = hp[0].market_type
+            hedge.var_1 = Math.abs(hp[0].var_1)
+            hedge.player_id = hp[0].player_id
+            hedge.event_id = hp[0].event_id
+            hedge.event_type = hp[0].event_type
+            hedge.market_id = hp[0].market_id
+           
+    
+    
+            //Set up arrays to store the positions on each side of the hedge
+            let trade_side_positions:PositionProps[] = []
+            let o_side_positions:PositionProps[] = [] 
+            trade_side_orders.map(o => {
+                trade_side_positions = trade_side_positions.concat(o.positions)
+            })
+            o_side_orders.map(o => {
+                o_side_positions = o_side_positions.concat(o.positions)
+            })
+    
+            //Calculate the winnings from each outcome (side a wins, side b wins, or draw)
+            let trade_side_pot_winnings = trade_side_positions.reduce((a,b) => a + b.potential_winnings, 0)
+            let o_side_pot_winnings = o_side_positions.reduce((a,b) => a + b.potential_winnings, 0)
+            let draw_winnings = trade_side_positions.concat(o_side_positions).reduce((a,b) => a + b.stake, 0)
+    
+            //Get the minimum payout possible of the 3 outcomes which is the hedged amount
+            let hedged_amt = Math.min(trade_side_pot_winnings, o_side_pot_winnings)
+            if(isNaN(hedged_amt)){ return }
+            hedge.hedged_amt = hedged_amt
+    
+            //Now lets cals out hedged positions
+            let hedged_positions:HedgedPositionProps[] = []
+            
+            trade_side_positions.map(p => {
+                //Need to determine the weight of the position on the total potential winnings and reduce the stake proportionately
+                let pct = p.potential_winnings / trade_side_pot_winnings
+                //console.log(hedged_amt, pct, p.probability)
+                let stake_from_hedge = hedged_amt * pct * p.probability
+                hedge.stake_reduction += stake_from_hedge 
+                let new_stake = p.stake - stake_from_hedge
+                hedged_positions.push({
+                    hedge_id:'',
+                    hedged_position_id: '',
+                    position_id: p.position_id,
+                    original_stake: p.stake,
+                    new_stake,
+                    delayed_cash_draw: 0,
+                    delayed_cash_no_draw: 0,
+                    original_potential_winnings: p.potential_winnings,
+                    new_potential_winnings: new_stake / p.probability,
+                    status: 'pending',
+                    create_datetime:'',
+                    last_update_datetime:''
+                })
+            })
+    
+            o_side_positions.map(p => {
+                let pct = p.potential_winnings / o_side_pot_winnings
+                let stake_from_hedge = hedged_amt * pct * p.probability
+                hedge.stake_reduction += stake_from_hedge 
+                let new_stake = p.stake - stake_from_hedge
+                hedged_positions.push({
+                    hedge_id:'',
+                    hedged_position_id: '',
+                    position_id: p.position_id,
+                    original_stake: p.stake,
+                    new_stake,
+                    delayed_cash_draw: 0,
+                    delayed_cash_no_draw: 0,
+                    original_potential_winnings: p.potential_winnings,
+                    new_potential_winnings: new_stake / p.probability,
+                    status: 'pending',
+                    create_datetime:'',
+                    last_update_datetime:''
+                })
+            })
+    
+    
+            //Cash rcvd will be the lower of the hedged amount or the reduction in stake
+            let cash_rcvd = Math.min(hedge.stake_reduction, hedged_amt, draw_winnings)
+            if(isNaN(cash_rcvd) || cash_rcvd < 0.01){ return }
+            hedge.cash_rcvd = cash_rcvd
+            let delayed_cash = hedged_amt - hedge.stake_reduction
+            let total_og_stake = hedged_positions.reduce((a,b) => a + b.original_stake, 0)
+            let delayed_cash_draw = 0, delayed_cash_no_draw = 0;
+            if(delayed_cash < 0){
+                delayed_cash_draw = delayed_cash * -1
+                //hedge.delayed_cash_draw = delayed_cash * -1 //Need to make positive
+            } else {
+                delayed_cash_no_draw = delayed_cash
+                //hedge.delayed_cash_no_draw = delayed_cash
+            }
+            hedge.delayed_cash_draw = delayed_cash_draw
+            hedge.delayed_cash_no_draw = delayed_cash_no_draw
+    
+            hedged_positions.map(hp => {
+                let pct_of_total = hp.original_stake / total_og_stake
+                hp.delayed_cash_draw = pct_of_total * delayed_cash_draw
+                hp.delayed_cash_no_draw = pct_of_total * delayed_cash_no_draw
+                return hp
+            })
+    
+            hedges.push({ ...hedge, hedged_positions:hedged_positions })
+        })
+    
+        return hedges
+    },
+    getEmptyHedge: ():HedgeProps => {
+        let uuid = Math.floor(Math.random() * 100000000)
+        return {
+            hedge_id: uuid.toString(),
+            hedged_amt: 0,
+            event_id: '',
+            event_type: '',
+            market_id: '',
+            var_1: 0,
+            delayed_cash_draw: 0,
+            delayed_cash_no_draw: 0,
+            cash_rcvd: 0,
+            stake_reduction: 0,
+            market_type: 'FOR_MONEY',
+            create_datetime: '',
+            last_udpate_datetime:'',
+            player_id: '',
+            status: 'pending'
+        }
+    },
+    getDetailsForStat: (order_stat:OrderStatsProps, events:EventProps[], tournaments:TournamentProps[], matches:MatchProps[]):{ contest_title:string, contest_time_detail:string, league_id:string } => {
+        let fail_response = { contest_title: 'TBD', contest_time_detail: 'TBD', league_id:'' }
+        switch(order_stat.event_type){
+            case 'team':
+                let event = events.find(e => e.event_id == order_stat.event_id);
+                if(!event){ return fail_response }
+                return {
+                    league_id: event.league_id,
+                    contest_title: `${event.away?.abbr} ${event.away_team_score} - ${event.home?.abbr} ${event.home_team_score}`,
+                    contest_time_detail: event.time_detail && event.time_detail != 'scheduled' ? event.time_detail : moment(event.scheduled_datetime).format('MM/DD @ hh:mm a')
+                }
+            case 'tournament':
+                let tournament = tournaments.find(t => t.tournament_id == order_stat.event_id)
+                if(!tournament) { return fail_response }
+                return {
+                    league_id: tournament.league_id,
+                    contest_title: tournament.tournament_name,
+                    contest_time_detail: moment(tournament.scheduled_datetime).format('MM/DD/YYYY')
+                }
+            case 'match':
+                let match = matches.find(m => m.match_id == order_stat.event_id)
+                if(!match){ return fail_response }
+                let match_tournament = tournaments.find(t => t.tournament_id == match.tournament_id);
+                return {
+                    league_id: match_tournament?.league_id ?? '',
+                    contest_title: match.match_title,
+                    contest_time_detail: match.time_detail && match.time_detail != 'scheduled' ? match.time_detail : moment(match.scheduled_datetime).format('MM/DD @ hh:mm a')
+                }
+            default:
+                return fail_response
+        }
+    },
+   calcOrderStats: (orders:OrderProps[], player_id:string):OrderStatsProps[] => {
+    let order_stats:OrderStatsProps[] = []
+    let unique_headers = [ ...new Set(orders.map(o => `${o.event_id}:${o.event_type}`)) ]
+    let wins = 0, losses = 0, draws = 0;
+    unique_headers.map(h => {
+        let contest_id = h.split(':')[0]
+        let contest_type = h.split(':')[1]
+        if(!contest_id || !contest_type){ return }
+        let found_orders = orders.filter(o => `${o.event_id}:${o.event_type}` === h)
+        if(found_orders.length === 0){ return; }
+        let max_last_update = found_orders.filter(o => o.status == 'approved').find(o => Math.min(moment(o.expire_datetime).unix()))?.expire_datetime
+        if(!max_last_update){ max_last_update = moment().add(1, 'year') }
+        let unique_order_titles = [ ...new Set(found_orders.map(o => o.title)) ]
+        let open_order_count = 0, open_amt = 0, potential_winnings = 0, called_amt = 0, commission = 0;
+        let resolved_stake = 0, original_stake = 0, delayed_cash = 0, winnings = 0, net_winnings = 0, unresolved_stake = 0, resolved_potential_winnings = 0, unresolved_potential_net_winnings = 0, unresolved_potential_winnings = 0, num_trades = 0, cash_rcvd = 0; 
+        let result_ind:string|undefined = undefined
+        let order_ids:string[] = []
+        let open_orders:string[] = []
+        found_orders.map(o => {
+            let commission_pct = 0
+            if(o.commission_pct){ commission_pct = o.commission_pct }
+            order_ids.push(o.order_id)
+            if(o.status === 'approved'){
+                open_orders.push(o.order_id)
+                open_amt += o.open_amt
+                open_order_count += 1
+                potential_winnings += o.potential_winnings
+                called_amt += o.called_amt
+            }
+            if(!o.positions){ return }
+            o.positions.map(p => {
+                if(!p){ return }
+                num_trades += 1
+                cash_rcvd += p.cash_rcvd
+                if(!p.result_ind){
+                    delayed_cash += p.delayed_cash
+                    unresolved_stake += p.stake
+                    unresolved_potential_winnings += p.potential_winnings
+                    unresolved_potential_net_winnings += (p.potential_winnings - ((p.potential_winnings - p.stake) * commission_pct))
+                } else {
+                    resolved_stake += p.stake
+                    original_stake += p.original_stake
+                    winnings += p.winnings
+                    net_winnings += p.net_winnings
+                    result_ind = p.result_ind
+                    commission += p.commission
+                    resolved_potential_winnings += p.potential_winnings
+                }
+            })
+        })
+        if(result_ind == 'win'){ wins += 1 }
+        if(result_ind == 'lose'){ losses += 1 }
+        if(result_ind == 'draw'){ draws += 1 }
+        let unresolved_position_probability = unresolved_stake / unresolved_potential_winnings
+        let resolved_position_probability = resolved_stake / resolved_potential_winnings
+        let unresolved_position_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(unresolved_position_probability)
+        let resolved_position_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(resolved_position_probability)
+
+        let offer_probability = open_amt / potential_winnings
+        let offer_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(offer_probability)
+        let earnings = winnings + cash_rcvd - original_stake
+        let roi = earnings / original_stake
+        return order_stats.push({
+            stat_id: h,
+            unresolved_stake,
+            earnings,
+            resolved_stake,
+            unique_order_titles,
+            original_stake,
+            roi,
+            wins,
+            net_winnings,
+            commission,
+            unresolved_potential_net_winnings,
+            losses,
+            draws,
+            unresolved_position_odds,
+            resolved_position_odds,
+            result_ind,
+            delayed_cash,
+            unresolved_potential_winnings,
+            resolved_potential_winnings,
+            resolved_position_probability,
+            unresolved_position_probability,
+            num_trades,
+            cash_rcvd,
+            winnings,
+            player_id,
+            event_id: contest_id,
+            event_type: contest_type,
+            open_amt, potential_winnings, called_amt, offer_odds, offer_probability,
+            orders: order_ids,
+            open_orders,
+            last_update_datetime: max_last_update
+        })
+    })
+    return order_stats
+   },
+   calcAllOrderStats: (orders:OrderProps[]):OrderStatsProps => {
+    let open_order_count = 0, open_amt = 0, potential_winnings = 0, called_amt = 0, commission = 0;
+    let resolved_stake = 0, original_stake = 0, delayed_cash = 0, winnings = 0, net_winnings = 0, unresolved_stake = 0, resolved_potential_winnings = 0, unresolved_potential_winnings = 0, unresolved_potential_net_winnings = 0, num_trades = 0, cash_rcvd = 0; 
+    let unique_order_titles = [ ...new Set(orders.map(o => o.title)) ]
+    let result_ind:string|undefined = undefined
+    let order_ids:string[] = []
+    let open_orders:string[] = []
+    let wins = 0, losses = 0, draws = 0;
+    orders.map(o => {
+        let commission_pct = 0
+        if(o.commission_pct){ commission_pct = o.commission_pct }
+        order_ids.push(o.order_id)
+        if(o.status === 'approved'){
+            open_orders.push(o.order_id)
+            open_amt += o.open_amt
+            open_order_count += 1
+            potential_winnings += o.potential_winnings
+            called_amt += o.called_amt
+        }
+        if(!o.positions){ return }
+        o.positions.map(p => {
+            if(!p){ return }
+            num_trades += 1
+            cash_rcvd += p.cash_rcvd
+            if(!p.result_ind){
+                delayed_cash += p.delayed_cash
+                unresolved_stake += p.stake
+                unresolved_potential_winnings += p.potential_winnings
+                unresolved_potential_net_winnings += (p.potential_winnings - ((p.potential_winnings - p.stake) * commission_pct))
+
+            } else {
+                resolved_stake += p.stake
+                original_stake += p.original_stake
+                winnings += p.winnings
+                net_winnings += p.net_winnings
+                result_ind = p.result_ind
+                commission += p.commission
+                resolved_potential_winnings += p.potential_winnings
+            }
+        })
+        if(result_ind == 'win'){ wins += 1 }
+        if(result_ind == 'lose'){ losses += 1 }
+        if(result_ind == 'draw'){ draws += 1 }
+    })
+   
+    let unresolved_position_probability = unresolved_stake / unresolved_potential_winnings
+    let resolved_position_probability = resolved_stake / resolved_potential_winnings
+    let unresolved_position_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(unresolved_position_probability)
+    let resolved_position_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(resolved_position_probability)
+
+    let offer_probability = open_amt / potential_winnings
+    let offer_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(offer_probability)
+    let earnings = winnings + cash_rcvd - original_stake
+    let roi = earnings / resolved_stake
+    return {
+        stat_id: 'ALL',
+        unresolved_stake,
+        earnings,
+        resolved_stake,
+        original_stake,
+        roi,
+        wins,
+        losses,
+        commission,
+        net_winnings,
+        unresolved_potential_net_winnings,
+        unique_order_titles,
+        draws,
+        unresolved_position_odds,
+        resolved_position_odds,
+        result_ind,
+        delayed_cash,
+        unresolved_potential_winnings,
+        resolved_potential_winnings,
+        resolved_position_probability,
+        unresolved_position_probability,
+        num_trades,
+        cash_rcvd,
+        winnings,
+        player_id: orders[0]?.player_id??'0',
+        event_id: 'ALL',
+        event_type: 'ALL',
+        open_amt, potential_winnings, called_amt, offer_odds, offer_probability,
+        orders: order_ids,
+        open_orders
+    }
+}
+}

package/src/MarketComponents/components/MyOrderList/index.tsx

@@ -0,0 +1,192 @@
+import React, { useState } from 'react';
+import { useEffect } from "react"
+import { ActivityIndicator, FlatList, useWindowDimensions, View } from "react-native";
+import type { EventProps, LeagueProps, MarketProps, MatchProps, OrderProps, OrderStatsProps, TournamentProps } from '../../../types';
+import { MarketComponentApi } from '../../api';
+import Colors from '../../../constants/colors';
+import { MyOrdersHelpers } from './api';
+import ContestOrderStatsCard from '../ContestOrderStatsCard';
+import SocketManager from '../../../Socket';
+import { Text } from '../../../Components';
+
+type MyOrderListProps = {
+    player_id:string,
+    access_token?:string,
+    distinct_id?:string,
+    market_type:'FOR_MONEY'|'FREE',
+}
+
+const MyOrderList = ({ player_id, market_type, access_token, distinct_id }:MyOrderListProps) => {
+    const [ needs_reload, setNeedsReload ] = useState(false);
+    const [ socket_order, setSocketOrder ] = useState<OrderProps|undefined>(undefined);
+    const [ module_data, setModuleData ] = useState<{
+        loading:boolean,
+        leagues:LeagueProps[],
+        orders:OrderProps[],
+        markets:MarketProps[],
+        events:EventProps[],
+        tournaments:TournamentProps[],
+        matches:MatchProps[]
+    }>({
+        loading:false,
+        leagues:[],
+        orders:[],
+        markets: [],
+        tournaments:[],
+        matches: [],
+        events: []
+    });
+
+    const { loading, orders, leagues, tournaments, matches, events, markets } = module_data;
+    const { width } = useWindowDimensions();
+    const hedges = MyOrdersHelpers.getHedgesFromPositions(orders, markets)
+
+    useEffect(() => {
+        MarketComponentApi.setEnvironment();
+        getDataFromServer();
+    },[]);
+
+    //Everytime an order is added to socket order - we update the local data
+    useEffect(() => {
+        if(!socket_order){ return }
+        updateFromSocket(socket_order)
+    },[socket_order])
+
+    const updateFromSocket = async(order:OrderProps) => {
+        const { event_ids, tournament_ids, match_ids } = MyOrdersHelpers.getContestsFromOrders([order]);
+        let es = await MarketComponentApi.getEventsByEventIds(event_ids);
+        let tourneys = await MarketComponentApi.getTournamentsByTournamentIds(tournament_ids);
+        let mtchs = await MarketComponentApi.getMatchesByMatchIds(match_ids);
+        setModuleData({
+            ...module_data,
+            orders: orders.filter(o => o.order_id != order.order_id).concat(order),
+            events: events.filter(e => !es.find(ne => ne.event_id == e.event_id)).concat(es),
+            tournaments: tournaments.filter(t => !tourneys.find(nt => nt.tournament_id == t.tournament_id)).concat(tourneys),
+            matches: matches.filter(m => !mtchs.find(nm => nm.match_id == m.match_id)).concat(mtchs)
+        });
+    }
+
+    const getDataFromServer = async() => {
+        setModuleData({ ...module_data, loading:true });
+        let my_orders = await MarketComponentApi.getMyAction()
+        const lgs = await MarketComponentApi.getLeagues();
+        const mks = await MarketComponentApi.getMarkets();
+        const { event_ids, tournament_ids, match_ids } = MyOrdersHelpers.getContestsFromOrders(my_orders);
+        let es = await MarketComponentApi.getEventsByEventIds(event_ids);
+        let tourneys = await MarketComponentApi.getTournamentsByTournamentIds(tournament_ids);
+        let mtchs = await MarketComponentApi.getMatchesByMatchIds(match_ids);
+
+        setModuleData({ 
+            ...module_data,
+            orders: my_orders,
+            events: es,
+            tournaments: tourneys,
+            leagues:lgs,
+            markets: mks,
+            matches:mtchs,
+            loading:false
+        })
+    }
+
+    const renderOrderStats = (data: { item:OrderStatsProps, index:number }) => {
+        const { contest_title, contest_time_detail, league_id } = MyOrdersHelpers.getDetailsForStat(data.item, events, tournaments, matches);
+        const league = leagues.find(l => l.league_id == league_id);
+        const event_hedges = hedges.filter(h => h.event_id == data.item.event_id && h.event_type == data.item.event_type)
+
+        return (
+            <ContestOrderStatsCard
+                league={league}
+                hedges={event_hedges}
+                player_order_stat={data.item}
+                contest_title={contest_title}
+                contest_time_detail={contest_time_detail}
+                onPress={(pos) => console.log(pos)}
+                market_type={market_type}
+                onOrdersUpdate={(os) => console.log(os)}
+            />
+        )
+    }
+
+
+    const event_order_stats = MyOrdersHelpers.calcOrderStats(orders, player_id).sort((a,b) => {
+        let a_open = a.open_amt
+        let b_open = b.open_amt
+        return b_open - a_open
+    });
+
+    const order_stats = MyOrdersHelpers.calcAllOrderStats(orders);
+    const cl = market_type == 'FREE' ? 'E' : '$'
+    return (
+        <View>
+            <View nativeID="order_stats" style={{ flexDirection:'row', justifyContent:'center', flexWrap:'wrap' }}>
+                {order_stats.open_amt > 0 ?
+                <View style={{ justifyContent:'space-between', width: (width/2) - 20, borderRadius:12, backgroundColor:Colors.shades.shade200, padding:20, margin:8}}>
+                    <Text size={14} color={Colors.brand.cobalt}>Unfulfilled Order Amount</Text>
+                    <Text size={16} weight='semibold' color={Colors.brand.cyan} style={{ marginTop:3 }}>{cl}{order_stats.open_amt.toFixed(2)}</Text>
+                </View>
+                :<></>}
+                {order_stats.unresolved_stake > 0 ?
+                <View style={{ justifyContent:'space-between', width: (width/2) - 20, borderRadius:12, backgroundColor:Colors.shades.shade200, padding:20, margin:8}}>
+                    <Text size={14} color={Colors.brand.cobalt}>Unsettled Positions</Text>
+                    <Text size={16} weight='semibold' color={Colors.brand.midnight} style={{ marginTop:3 }}>{order_stats.unresolved_stake.toFixed(2)} to win {cl}{order_stats.unresolved_potential_winnings.toFixed(2)}</Text>
+                </View>
+                :<></>}
+                {order_stats.resolved_stake > 0 ?
+                <View style={{ justifyContent:'space-between', width: (width/2) - 20, borderRadius:12, backgroundColor:Colors.shades.shade200, padding:20, margin:8}}>
+                    <Text size={14} color={Colors.brand.cobalt}>Settled Positions</Text>
+                    <Text size={16} weight='semibold' color={Colors.brand.midnight} style={{ marginTop:3 }}>{cl}{order_stats.resolved_stake.toFixed(2)}</Text>
+                </View>
+                :<></>}
+                {order_stats.resolved_stake > 0 ?
+                <View style={{ justifyContent:'space-between', width: (width/2) - 20, borderRadius:12, backgroundColor:Colors.shades.shade200, padding:20, margin:8}}>
+                    <Text size={14} color={Colors.brand.cobalt}>Earnings</Text>
+                    <Text size={16} weight='semibold' color={Colors.brand.midnight} style={{ marginTop:3 }}>{cl}{order_stats.earnings.toFixed(2)} ({(order_stats.roi * 100).toFixed(2)}%)</Text>
+                </View>
+                :<></>}
+                {order_stats.delayed_cash > 0 ?
+                <View style={{ justifyContent:'space-between', width: (width/2) - 20, borderRadius:12, backgroundColor:Colors.shades.shade200, padding:20, margin:8}}>
+                    <Text size={14} color={Colors.brand.cobalt}>Delayed Cash Out</Text>
+                    <Text size={16} weight='semibold' color={Colors.brand.midnight} style={{ marginTop:3 }}>{cl}{order_stats.delayed_cash.toFixed(2)}</Text>
+                </View>
+                :<></>}
+            </View>
+            <FlatList
+                key={`${player_id}_order_stats`}
+                data={event_order_stats}
+                renderItem={renderOrderStats}
+                keyExtractor={(item) => item.event_id.toString()}
+            />
+            <SocketManager
+                subscribed_events={['V1_UPDATE_PLAYER_ORDER']}
+                access_token={access_token}
+                distinct_id={distinct_id}
+                onConnect={() => {
+                    if(needs_reload){ 
+                        getDataFromServer() 
+                        setNeedsReload(false);
+                    }
+                }}
+                onDisconnect={() => setNeedsReload(true)}
+                onSocketEvent={(ev) => {
+                    switch(ev.type){
+                        case 'V1_UPDATE_PLAYER_ORDER':
+                            if(ev.player_id != player_id){ return }
+                            return setSocketOrder(ev.data)
+                        default: return
+                    }
+                }}
+            />
+            {loading ?
+            <View style={{ position:'absolute', top:0, left:0, right:0, bottom:0, backgroundColor:Colors.shades.black_faded, justifyContent:'center', alignItems:'center' }}>
+                <ActivityIndicator
+                    size='large'
+                    color={Colors.brand.midnight}
+                />
+            </View>
+            :<></>}
+        </View>
+    )
+
+}
+
+export default MyOrderList