be-components 2.4.7 → 2.4.9

package/src/MarketMaker/index.tsx

@@ -0,0 +1,378 @@
+import React, { useEffect, useState } from 'react';
+import { View } from 'react-native';
+import { MarketMakerApi, MarketMaketHelpers } from './api';
+import type { BestAvailableResponseProps, EventProps, ExternalPriceProps, FundingRequestProps, FundOrderProps, FundOwnershipProps, FundProps, LeagueProps, MarketProps, MatchProps, OrderProps, PublicPlayerProps, TournamentProps, TradeProps } from '../types';
+//import { view_styles } from '../constants/styles';
+import Colors from '../constants/colors';
+import ContestSelector from './components/ContestSelector';
+import Dashboard from './components/Dashboard';
+import MarketSelector from './components/MarketSelector';
+import SetMarketForm from './components/SetMarketForm';
+import FundSelector from './components/FundSelector';
+import { usePlayerLocation } from '../LocationTracker/LocationStatus';
+import ManageFundForm from './components/ManageFundForm';
+import FundingRequestList from './components/FundingRequestList';
+import FundOwnershipList from './components/FundOwnershipList';
+
+type MarketMakerProps = {
+    player_id:string
+}
+
+const MarketMaker = ({ player_id }:MarketMakerProps) => {
+    const [ module_data, setModuleData ] = useState<{
+        loaded:boolean,
+        loading:boolean,
+        funds:FundProps[],
+        markets:MarketProps[],
+        leagues:LeagueProps[],
+        events:EventProps[],
+        tournaments:TournamentProps[],
+        matches:MatchProps[],
+    }>({
+        loaded: false,
+        loading:false,
+        funds:[],
+        leagues:[],
+        markets:[],
+        events:[],
+        tournaments:[],
+        matches:[]
+    });
+    const { loaded, leagues, events, markets, funds } = module_data;
+
+    const [ editing_fund, setEditingFund ] = useState<FundProps | undefined>(undefined);
+
+    const [ set_market_form_data, setMarketFormData ] = useState<{
+        set_market_form_key:string,
+        set_market_orders:OrderProps[],
+        set_market_market?:MarketProps,
+        set_market_form_visible:boolean,
+        set_market_prices: ExternalPriceProps[]
+    }>({
+        set_market_form_key: '',
+        set_market_form_visible: false,
+        set_market_orders:[],
+        set_market_prices:[]
+    });
+    const { set_market_form_key, set_market_orders, set_market_form_visible, set_market_market, set_market_prices } = set_market_form_data;
+
+    const [ dash_data, setDashData ] = useState<{
+        fund?:FundProps,
+        loaded:boolean,
+        loading:boolean,
+        external_name?:string,
+        players:PublicPlayerProps[],
+        best_available:BestAvailableResponseProps,
+        funding_requests:FundingRequestProps[],
+        fund_ownerships:FundOwnershipProps[],
+        selected_markets:MarketProps[],
+        orders:OrderProps[],
+        fund_orders:FundOrderProps[],
+        selected_events:EventProps[],
+        trades:TradeProps[],
+        external_prices:ExternalPriceProps[],
+        selected_tournaments:TournamentProps[],
+        selected_matches:MatchProps[]
+    }>({
+        loaded:false,
+        loading:false,
+        external_name: 'Consensus',
+        players:[],
+        funding_requests:[],
+        fund_ownerships:[],
+        fund_orders:[],
+        selected_markets:[],
+        best_available: { events: [], tournaments: [], matches: [] },
+        orders:[],
+        trades:[],
+        external_prices: [],
+        selected_events:[],
+        selected_matches:[],
+        selected_tournaments:[]
+    });
+    const { fund, selected_events, players, fund_orders, fund_ownerships, funding_requests, external_name, selected_matches, selected_tournaments, selected_markets, trades, external_prices, best_available, orders } = dash_data;
+    const { available_orders } = MarketMaketHelpers.getMarketDataFromBestAvailable(best_available);
+    const selectable_markets = MarketMaketHelpers.getSelectableMarkets(selected_events, selected_tournaments, selected_matches, markets);
+
+    const { location, getLocation } = usePlayerLocation({ player_id });
+    useEffect(() => {
+        MarketMakerApi.setEnvironment();
+        if(!player_id){ return }
+        loadModule();
+        getLocation()
+    },[player_id]);
+
+    useEffect(() => {
+        if(!fund?.fund_id || !loaded){ return }
+        getDashData(fund.fund_id);
+    },[fund]);
+
+    const loadModule = async() => {
+        setModuleData({ ...module_data, loading:true });
+        setDashData({ ...dash_data, loading:true });
+        const bulk_funds = await MarketMakerApi.getMyActiveFunds(0);
+        const evs = await MarketMakerApi.getActiveEvents();
+        const mks = await MarketMakerApi.getMarkets();
+        const ls = await MarketMakerApi.getLeagues();
+        setModuleData({
+            ...module_data,
+            events:evs,
+            funds:bulk_funds,
+            loaded:true,
+            loading:false,
+            markets:mks,
+            leagues:ls,
+        });
+        if(bulk_funds[0]){ setDashData({ ...dash_data, fund: bulk_funds[0] }) }
+    }
+
+    const getDashData = async(fund_id:string) => {
+        //Now load Dash data
+        const ba = await MarketMakerApi.getBestAvailableOrders();
+        const fund_response = await MarketMakerApi.getFundById(fund_id);
+        if(!fund_response){
+            alert('Failed to get details for selected fund');
+            return setDashData({ ...dash_data, loading:false });
+        }
+        const fr_requests = await MarketMakerApi.getFundingRequestsByFundId(fund_id);
+        const my_action_data = await getDataForMyAction(fund_response.orders, markets);
+        //Based on my action -- lets auto select events and grab all that data!!
+        let ep = await MarketMakerApi.getPricesByEvents('team', my_action_data.events.map(e => e.event_id))
+        let player_ids = [ ...new Set(fr_requests.map(r => r.player_id).concat(fund_response.fund_ownerships.map(o => o.player_id)).map(id => id))]
+        let plays = await MarketMakerApi.getPlayersByIds(player_ids)
+
+        setDashData({
+            ...dash_data,
+            loaded:true,
+            loading:false,
+            best_available: ba,
+            funding_requests:fr_requests,
+            players:plays,
+            fund_ownerships: fund_response.fund_ownerships,
+            orders:fund_response.orders,
+            fund_orders: fund_response.fund_orders,
+            selected_events: my_action_data.events,
+            trades: my_action_data.trades,
+            external_prices: ep,
+            selected_markets: my_action_data.markets
+        })
+    }
+
+    const getDataForMyAction = async(orders:OrderProps[], markets:MarketProps[]) => {
+        const ev_ids = orders.filter(o => o.event_type == 'team').map(o => o.event_id);
+        const mks = markets.filter(m => orders.map(o => o.market_id.toString()).includes(m.market_id.toString()))
+        const evs = await MarketMakerApi.getEventsByEventIds(ev_ids);
+        const ts = await MarketMakerApi.getLatestTradesByEvents('team', ev_ids)
+        return { events:evs, trades:ts, markets:mks }
+    }
+
+    const handleSelectEvent = async(e:EventProps) => {
+        if(dash_data.loading){ return }//No mashy
+        setDashData({ ...dash_data, loading: true });
+        const prices = await MarketMakerApi.getPricesByEvent(e.event_id, 'team');
+        const tds = await MarketMakerApi.getLatestTradesByEvents('team', [e.event_id]);
+        setDashData({
+            ...dash_data,
+            loading:false,
+            selected_events: selected_events.concat(e),
+            trades: trades.filter(t => t.event_id != e.event_id).concat(tds),
+            external_prices: external_prices.filter(p => p.event_id != e.event_id).concat(prices)
+        })
+    }
+
+    const handleDeselectEvent = (e:EventProps) => {
+        if(dash_data.loading){ return }//No mashy
+        setDashData({
+            ...dash_data,
+            loading:false,
+            selected_events: selected_events.filter(se => se.event_id != e.event_id),
+            trades: trades.filter(t => t.event_id != e.event_id)
+        })
+    }
+
+
+    return (
+        <View style={{ flex:1, backgroundColor:Colors.shades.white }}>
+            <View style={{ flexDirection:'row' }}>
+                <View>
+                    <FundSelector
+                        funds={funds}
+                        maxHeight={300}
+                        selected_fund_id={dash_data.fund?.fund_id}
+                        onEditFund={(f) => {
+                            setEditingFund(f)
+                        }}
+                        onCreateFund={(f) => {
+                            setDashData({
+                                ...dash_data,
+                                fund:f
+                            })
+                            setEditingFund(f);
+                        }}
+                        onSelectFund={(f) => {
+                            setDashData({
+                                ...dash_data,
+                                fund:f
+                            })
+                        }}
+                    />
+                    {fund ?
+                    <FundOwnershipList
+                        fund_ownerships={fund_ownerships}
+                        players={players}
+                    />
+                    :<></>}
+                    {fund?
+                    <FundingRequestList
+                        funding_requests={funding_requests}
+                        players={players}
+                        onApproveRequest={async(fr_id) => {
+                            const app_response = await MarketMakerApi.approveRequest(fr_id)
+                            if(!app_response){ return alert('Unable to process') }
+                            setDashData({
+                                ...dash_data,
+                                fund: app_response.fund,
+                                fund_ownerships: app_response.fund_ownerships,
+                                funding_requests: funding_requests.filter(fr => fr.funding_request_id != fr_id)
+                            })
+                        }}
+                        onDeclineRequest={async(fr_id) => {
+                            const app_response = await MarketMakerApi.declineRequest(fr_id)
+                            if(!app_response){ return alert('Unable to process') }
+                            setDashData({
+                                ...dash_data,
+                                funding_requests: funding_requests.filter(fr => fr.funding_request_id != fr_id)
+                            })
+                        }}
+                    />
+                    :<></>}
+                    <ContestSelector 
+                        maxHeight={300}
+                        leagues={leagues.filter(l => l.status == 'active')}
+                        events={events}
+                        onSelectEvent={(e) => handleSelectEvent(e)}
+                        onDeselectEvent={(e) => handleDeselectEvent(e)}
+                        onSelectMatch={(m) => console.log(m)}
+                        onSelectTournament={(t) => console.log(t)}
+                        tournaments={[]}
+                        matches={[]}
+                        selected_events={selected_events.map(e => e.event_id)}
+                        selected_matches={[]}
+                        selected_tournaments={[]}
+                    />
+                    <MarketSelector
+                        maxHeight={300}
+                        markets={selectable_markets.sort((a,b) => parseInt(a.market_id) - parseInt(b.market_id))}
+                        onSelectMarket={(m) => setDashData({ ...dash_data, selected_markets: dash_data.selected_markets.concat(m) })}
+                        onDeselectMarket={(m) => setDashData({ ...dash_data, selected_markets: dash_data.selected_markets.filter(se => se.market_id != m.market_id) })}
+                        selected_markets={selected_markets.map(m => m.market_id)}
+                    />
+                </View>
+                <View style={{ flexGrow:1 }}>
+                    <Dashboard
+                        loaded={dash_data.loaded}
+                        leagues={leagues}
+                        fund={fund}
+                        events={selected_events}
+                        tournaments={selected_tournaments}
+                        matches={selected_matches}
+                        markets={selected_markets}
+                        best_available_orders={available_orders}
+                        trades={trades}
+                        prices={external_prices}
+                        external_name={external_name}
+                        orders={orders}
+                        fund_orders={fund_orders}
+                        onDepositFund={async(amount) => {
+                            if(!fund){ return alert('Unable to process') }
+                            const dep_resp = await MarketMakerApi.depositRequest(fund.fund_id, amount);
+                            console.log(dep_resp)
+                        }}
+                        onLayoffCapital={async(amount) => {
+                            if(!fund){ return alert('Unable to process') }
+                            const layoff_resp = await MarketMakerApi.layoffCapital(fund.fund_id, amount);
+                            if(!layoff_resp){ return alert('Unable to process') }
+                            setDashData({
+                                ...dash_data,
+                                fund: layoff_resp.fund,
+                                orders: layoff_resp.orders
+                            })
+                        }}
+                        onWorkCapital={async(amount) => {
+                            if(!fund){ return alert('Unable to process') }
+                            const work_response = await MarketMakerApi.workCapital(fund.fund_id, amount);
+                            if(!work_response){ return alert('Unable to process') }
+                            setDashData({
+                                ...dash_data,
+                                fund: work_response.fund,
+                                orders: work_response.orders
+                            })
+                        }}
+                        onClearMarket={async(order_ids) => {
+                            const new_orders = await MarketMakerApi.cancelOrders(order_ids)
+                            setDashData({
+                                ...dash_data,
+                                orders: orders.filter(o => !new_orders.find(no => no.order_id == o.order_id))
+                            })
+                        }}
+                        onSetMarket={(orders, market, prices) => {
+                            if(!location.region || !location.coordinates){ return alert('Location could not be verified to process orders') }
+                            orders = orders.map(o => {
+                                return { ...o, location: location.coordinates, region: location.region }
+                            })
+                            setMarketFormData({ 
+                                ...set_market_form_data,
+                                set_market_form_visible:true,
+                                set_market_market:market,
+                                set_market_orders: orders,
+                                set_market_form_key: `${Math.random()}`,
+                                set_market_prices: prices
+                            })
+                        }}
+                    />
+                    {fund && set_market_form_visible && set_market_market ?
+                    <View style={{ position:'absolute', bottom:0, left:0, right:0, top:0, backgroundColor:Colors.shades.black_faded, justifyContent:'center', alignItems:'center' }}>
+                        <SetMarketForm
+                            fund={fund}
+                            form_key={set_market_form_key}
+                            market={set_market_market}
+                            orders={set_market_orders}
+                            prices={set_market_prices}
+                            spread_pct='5'
+                            onSetMarket={async(fund_orders) => {
+                                if(!fund){ return alert('Unable to process') }
+                                const new_os = await MarketMakerApi.addOrdersToFund(fund.fund_id, fund_orders)
+                                console.log(new_os)
+                                if(new_os.length == 0){ return alert('Unable to process') }
+                                setDashData({
+                                    ...dash_data,
+                                    orders: orders.concat(new_os)
+                                })
+                                setMarketFormData({ set_market_form_visible: false, set_market_orders:[], set_market_form_key:'', set_market_prices:[] })
+                            }}
+                            onClose={() => setMarketFormData({ set_market_form_visible: false, set_market_orders:[], set_market_form_key:'', set_market_prices:[] })}
+                        />
+                    </View>
+                    :<></>}
+                    {editing_fund ?
+                    <View style={{ position:'absolute', bottom:0, left:0, right:0, top:0, backgroundColor:Colors.shades.black_faded, justifyContent:'center', alignItems:'center' }}>
+                        <ManageFundForm
+                            fund={editing_fund}
+                            onClose={() => setEditingFund(undefined)}
+                            onFundUpdate={(f) => {
+                                setEditingFund(undefined);
+                                setDashData({
+                                    ...dash_data,
+                                    fund: f
+                                })
+                            }}
+                        />
+                    </View>
+                    :<></>}
+                </View>
+            </View>
+        </View>
+    )
+}
+
+export default MarketMaker

package/src/SocialComponents/api/index.ts

@@ -134,7 +134,6 @@ const SocialComponentApi = {
     startPodcastEpisode: async(podcast_episode_id:string):Promise<undefined | { player_podcast:PlayerPodcastProps, player_podcast_episode:PlayerPodcastEpisodeProps }> => {
         try {
             const resp = await axios.post(`${SOCIAL_SVC_API}/v1/podcasts/episode/start`, { podcast_episode_id });
-            console.log(resp.data)
             return resp.data
         } catch (e) {
             console.log(e)

package/src/index.tsx

@@ -29,7 +29,7 @@ import MarketComponents from './MarketComponents';
 import EventComponents from './EventComponents';
 import Share from './Share';
 import LocationTracker from "./LocationTracker";
-
+import MarketMaker from "./MarketMaker";
 
 export {
   Authenticator,
@@ -54,6 +54,7 @@ export {
   PollCampaign,
   PollCampaignApi,
   PollApi,
+  MarketMaker,
   CompetitionModule,
   SeasonManager,
   CreateCompetitionForm,

package/src/types.d.ts

@@ -1,3 +1,5 @@
+import type { Moment } from "moment-mini";
+
 export interface PublicPlayerProps {
     player_id:string,
     username:string,
@@ -163,6 +165,16 @@ export interface PlayerPodcastProps {
     last_update_datetime:any
 }
 
+export interface SortedContestProps { 
+    league_id?:string, 
+    contest_type: 'team'|'tournament'|'match', 
+    id:string, 
+    title:string, 
+    markets:MarketProps[],
+    time_detail:string, 
+    scheduled_datetime:Moment
+}
+
 export interface PlayerPodcastEpisodeProps {
     player_podcast_episode_id:string,
     player_id:string,
@@ -1854,6 +1866,33 @@ export interface GeneratedLinkProps {
     last_update_datetime?:any
 }
 
+
+export interface PositionProps {
+    position_id:string; //Primary key of the order
+    order_id: string //Id of the order in which the position was created from
+    stake: number; //Amount still available to be matched
+    winnings: number; //Amount already fulfilled
+    net_winnings:number; //Winnings minus commission charged,
+    potential_winnings: number //Potential winnings calculated by open_amt and odds / prob
+    in_sale_order:number //The amount that is currently active in a sale order
+    delayed_cash: number //Amount of cash that is awaiting the result.  If the result is a draw, this money is not sent back
+    cash_rcvd: number; //Amount of cash received from sales
+    routing_premium?:number; //If we charged for routing this order
+    original_stake: number; //Original amount of stake when the position was created
+    create_datetime?: any; //Create time of the order
+    last_update_datetime?: any; //Last update time of te order
+    odds: number; //American odds of the order
+    result_ind?:'win'|'lose'|'draw';
+    probability: number; //Implied probability of the order
+    parlay_id?:string; //If the positions is created as the other side of a parlay, then this is the associated parlay id that needs to be reviewed for a win / loss
+    status: 'inprogress' | 'closed'; //Current status of the order,
+    legacy_id?:string,
+    resolution_datetime?:any,
+    purchased_grade?:number,
+    commission:number,
+    hedged_positions?:HedgedPositionProps[]
+}
+
 export interface OrderProps {
     order_id:string; //Primary key of the order
     player_id:string; //Id of the player creating the order
@@ -1873,6 +1912,8 @@ export interface OrderProps {
     market_id: string; //Id of the market that this order is (i.e., Spread, Total, stat, etc)
     market?: MarketProps; //Market object of the ID
     title: string; //Title of the order
+    working_pct?:number;
+    fulfill_action?:'replenish'|'drain',
     event_id: string; //Id of the event associated with the order
     event_type: 'team' | 'tournament'|'match'; //Is the event a team event or individual (i.e., golf tournament / UFC)
     position_ids: string[]; //Array of positions that were created due to trades
@@ -1917,8 +1958,102 @@ export interface OrderProps {
     no_bet_reason?:string
 }
 
+export interface HedgeProps {
+    hedge_id:string,
+    hedged_amt:number,
+    player_id:string,
+    event_id:string,
+    event_type:string,
+    market_id:string,
+    var_1:number,
+    stake_reduction:number,
+    cash_rcvd:number,
+    market_type:string,
+    delayed_cash_no_draw:number,
+    hedged_positions?:HedgedPositionProps[],
+    delayed_cash_draw:number,
+    status:string, 
+    create_datetime:any, 
+    last_udpate_datetime: any
+}
+
+export interface HedgedPositionProps {
+    hedged_position_id:string,
+    hedge_id:string,
+    position_id:string,
+    original_stake:number,
+    new_stake:number,
+    delayed_cash_draw:number,
+    delayed_cash_no_draw:number,
+    original_potential_winnings:number,
+    new_potential_winnings:number,
+    status:string,
+    create_datetime:any,
+    last_update_datetime:any
+}
 
 
+export interface FundProps {
+    fund_id:string,
+    player_id:string,
+    status: 'active'|'inactive'|'archived',
+    name: string,
+    invested_capital:number,
+    minimum_investment:number,
+    available_capital:number,
+    working_capital: number, //Fulfilled amount
+    deployed_capital: number,
+    market_type: 'FOR_MONEY'|'FREE'
+    create_datetime: any,
+    last_update_datetime:any
+}
+
+export interface FundTransactionProps {
+    fund_transaction_id:string,
+    fund_id:string,
+    sender_id:string,
+    sender_type:string,
+    receiver_id:string,
+    receiver_type:string,
+    transaction_datetime:any,
+    description:string,
+    amount:number,
+    amount_type:any,
+    create_datetime:any,
+    last_update_datetime:any
+}
+
+export interface FundingRequestProps {
+    funding_request_id:string,
+    fund_id:string,
+    player_id:string,
+    status:'requested'|'declined'|'approved'|'withdrawn',
+    amount:number,
+    create_datetime:any,
+    last_update_datetime:any
+}
+
+export interface FundOwnershipProps {
+    fund_ownership_id:string,
+    fund_id:string,
+    player_id:string,
+    total_invested:number,
+    ownership_pct:number,
+    status:'active'|'inactive',
+    create_datetime:any,
+    last_update_datetime:any
+}
+
+export interface FundOrderProps {
+    fund_order_id:string,
+    fund_id:string,
+    order_id:string,
+    working_pct:number,
+    fulfill_action: 'replenish'|'drain'
+    create_datetime:any,
+    last_update_datetime:any
+}
+
 //SOCIAL COMPONENTS
 
 export interface PlayerLinkProps {