be-components 7.5.2 → 7.5.4

package/lib/typescript/src/MarketComponents/index.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    TeamEventMarket: import("react").MemoExoticComponent<({ event, show_help, help_location, parlays, hide_non_primary, disabled_markets, flash_markets, league, float, style, init_expanded, hot_markets_direction, show_id, hide_liquidity, show_podcasts, activate_loading, competitions, squares_competitions, show_grades, markets, latest_trades, best_available_orders, event_order_stats, default_price_view, onHelpToggle, onSetMarket, onTeamSelect, onFlashSelect, onParlaySelect, onSquaresSelect, onCompetitionSelect, onExpand, onOrder, onViewMarketStats, onView, onViewAdditionalMarkets, onTradeLongPress, onTVSelect, onActivate, onEvent, onShare, onPodcastSelect }: {
+    TeamEventMarket: import("react").MemoExoticComponent<({ event, show_help, highlight_router_orders, help_location, parlays, hide_non_primary, disabled_markets, flash_markets, league, float, style, init_expanded, hot_markets_direction, show_id, hide_liquidity, show_podcasts, activate_loading, competitions, squares_competitions, show_grades, markets, latest_trades, best_available_orders, event_order_stats, default_price_view, onHelpToggle, onSetMarket, onTeamSelect, onFlashSelect, onParlaySelect, onSquaresSelect, onCompetitionSelect, onExpand, onOrder, onViewMarketStats, onView, onViewAdditionalMarkets, onTradeLongPress, onTVSelect, onActivate, onEvent, onShare, onPodcastSelect }: {
         event: import("../types").EventProps;
         markets: import("../types").MarketProps[];
         parlays?: import("../types").ParlayProps[];
@@ -41,6 +41,7 @@ declare const _default: {
         onShare?: (event: import("../types").EventProps) => void;
         onPodcastSelect?: (podcast: import("../types").PodcastProps) => void;
         show_grades?: boolean;
+        highlight_router_orders?: boolean;
         hide_non_primary?: boolean;
         onCompetitionSelect: (competition_id: string) => void;
         onSquaresSelect: (sq_comp_id: string) => void;
@@ -49,7 +50,7 @@ declare const _default: {
         onActivate?: (event_id: string, event_type: string) => void;
         activate_loading?: boolean;
     }) => import("react").JSX.Element>;
-    TeamTournamentMarket: import("react").MemoExoticComponent<({ tournament, image_size, disabled_markets, float, direction, show_event, hide_liquidity, hide_stat_banner, style, team, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress }: {
+    TeamTournamentMarket: import("react").MemoExoticComponent<({ tournament, image_size, highlight_router_orders, disabled_markets, float, direction, show_event, hide_liquidity, hide_stat_banner, style, team, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress }: {
         tournament: import("../types").TournamentProps;
         event_type: "team" | "tournament" | "match";
         team: import("../types").TeamProps;
@@ -63,6 +64,7 @@ declare const _default: {
         show_event?: boolean;
         hide_liquidity?: boolean;
         style?: any;
+        highlight_router_orders?: boolean;
         latest_trades: import("../types").TradeProps[];
         best_available_orders: import("../types").BestAvailableOrderProps[];
         event_order_stats: import("../types").EventOrderStatProps[];
@@ -78,7 +80,7 @@ declare const _default: {
         }) => void;
         onTradeLongPress: (trade: import("../types").TradeProps) => void;
     }) => import("react").JSX.Element>;
-    AthleteMarket: import("react").MemoExoticComponent<({ event, show_event, disabled_markets, float, image_size, hide_image, direction, league, hide_liquidity, style, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress, onSetMarket }: {
+    AthleteMarket: import("react").MemoExoticComponent<({ event, show_event, disabled_markets, highlight_router_orders, float, image_size, hide_image, direction, league, hide_liquidity, style, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress, onSetMarket }: {
         event: import("../types").EventProps;
         event_type: "team" | "tournament" | "match";
         athlete: import("../types").AthleteProps;
@@ -90,6 +92,7 @@ declare const _default: {
         float?: boolean;
         direction?: "horizontal" | "vertical";
         style?: any;
+        highlight_router_orders?: boolean;
         image_size?: number;
         league?: import("../types").LeagueProps;
         hide_image?: boolean;
@@ -120,7 +123,7 @@ declare const _default: {
         onBuyNow?: (order: import("../types").OrderProps) => void;
         onCancelOrder?: (order_id: string) => void;
     }) => import("react").JSX.Element;
-    EventMarket: import("react").MemoExoticComponent<({ event, float, style, disabled_markets, direction, hide_liquidity, market, latest_trades, best_available_orders, hide_market_banner, event_order_stats, show_grades, default_price_view, onOrder, onView, onTradeLongPress }: {
+    EventMarket: import("react").MemoExoticComponent<({ event, float, style, highlight_router_orders, disabled_markets, direction, hide_liquidity, market, latest_trades, best_available_orders, hide_market_banner, event_order_stats, show_grades, default_price_view, onOrder, onView, onTradeLongPress }: {
         event: import("../types").EventProps;
         width?: number;
         market: import("../types").MarketProps;
@@ -130,6 +133,7 @@ declare const _default: {
         latest_trades: import("../types").TradeProps[];
         hide_liquidity?: boolean;
         style?: any;
+        highlight_router_orders?: boolean;
         direction?: "horizontal" | "vertical";
         best_available_orders: import("../types").BestAvailableOrderProps[];
         event_order_stats: import("../types").EventOrderStatProps[];
@@ -143,13 +147,17 @@ declare const _default: {
         }) => void;
         onTradeLongPress: (trade: import("../types").TradeProps) => void;
     }) => import("react").JSX.Element>;
-    OrderBookCard: ({ player_id, orders, market, show_orders, show_grades, onBuy }: {
+    OrderBookCard: ({ player_id, orders, market, var_1, show_orders, show_grades, onBuy, router_orders, contest_type, contest_id }: {
         player_id?: string;
         orders: import("../types").OrderProps[];
         market: import("../types").MarketProps;
+        var_1: number;
         show_grades?: boolean;
         show_orders?: boolean;
         onBuy: (order: import("../types").OrderProps) => void;
+        router_orders?: import("../types").BestAvailableOrderProps[];
+        contest_type?: string | number;
+        contest_id?: string | number;
     }) => import("react").JSX.Element;
     CreateMarketForm: ({ float, action_loading, unit_size, location, coordinates, style, my_orders, best_available_orders, contest_type, contest_id, market_id, side_id, side_type, onCancel, onSubmitOrders }: {
         float?: boolean;
@@ -195,8 +203,9 @@ declare const _default: {
         onViewOrder: (order_id: string) => void;
         onClose: () => void;
     }) => import("react").JSX.Element;
-    OrderBookChart: ({ order_book, market, active_var_1, onSelectVar1, away_label, home_label, side_id }: {
+    OrderBookChart: ({ order_book, market, active_var_1, onSelectVar1, away_label, home_label, side_id, router_orders }: {
         order_book: import("../types").OrderBookProps;
+        router_orders?: import("../types").BestAvailableOrderProps[];
         onSelectVar1: (var_1: number) => void;
         active_var_1: number;
         market: import("../types").MarketProps;
@@ -206,7 +215,7 @@ declare const _default: {
         away_label?: string;
         home_label?: string;
     }) => import("react").JSX.Element;
-    AthleteTournamentMarket: import("react").MemoExoticComponent<({ tournament, disabled_markets, league, float, style, hide_image, direction, show_event, hide_liquidity, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress }: {
+    AthleteTournamentMarket: import("react").MemoExoticComponent<({ tournament, highlight_router_orders, disabled_markets, league, float, style, hide_image, direction, show_event, hide_liquidity, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress }: {
         tournament: import("../types").TournamentProps;
         event_type: "team" | "tournament" | "match";
         athlete: import("../types").AthleteProps;
@@ -215,6 +224,7 @@ declare const _default: {
         float?: boolean;
         disabled_markets?: string[];
         market: import("../types").MarketProps;
+        highlight_router_orders?: boolean;
         hide_image?: boolean;
         style?: any;
         show_event?: boolean;
@@ -266,7 +276,7 @@ declare const _default: {
         view_type: "card" | "book" | "market";
         onSelectGrade?: () => void;
     }) => import("react").JSX.Element;
-    ExternalPriceComparison: ({ price_key, float, contest_id, style, contest_type, market_id, participant_id, participant_type, external_name, init_side, onClose }: {
+    ExternalPriceComparison: ({ price_key, float, contest_id, style, contest_type, market_id, participant_id, participant_type, external_name, init_side, onClose, onSeePriceHistory }: {
         price_key: string;
         contest_id: string;
         style?: any;
@@ -279,13 +289,23 @@ declare const _default: {
         participant_id?: string;
         init_side?: string;
         onClose: () => void;
+        onSeePriceHistory?: (props: {
+            contest_id: string;
+            contest_type: string;
+            market_id: string;
+            participant_id?: string;
+            participant_type?: string;
+            selected_side: string;
+            var_1?: number;
+        }) => void;
     }) => import("react").JSX.Element;
-    TournamentMarket: ({ tournament, default_price_view, float, disabled_markets, wrap_markets, width, style, market_selector_location, flash_markets, hide_match_liquidity, show_grades, hide_participant_liquidity, league, markets, latest_trades, hide_liquidity, best_available_orders, event_order_stats, match_available_orders, match_latest_trades, match_order_stats, activate_loading, onView, onTradeLongPress, onViewAdditionalMarkets, onViewMarketStats, onFlashSelect, onOrder, onActivate, onShare }: {
+    TournamentMarket: ({ tournament, default_price_view, highlight_router_orders, float, disabled_markets, wrap_markets, width, style, market_selector_location, flash_markets, hide_match_liquidity, show_grades, hide_participant_liquidity, league, markets, latest_trades, hide_liquidity, best_available_orders, event_order_stats, match_available_orders, match_latest_trades, match_order_stats, activate_loading, onView, onTradeLongPress, onViewAdditionalMarkets, onViewMarketStats, onFlashSelect, onOrder, onActivate, onShare }: {
         tournament: import("../types").TournamentProps;
         league?: import("../types").LeagueProps;
         markets: import("../types").MarketProps[];
         hide_liquidity?: boolean;
         width?: number;
+        highlight_router_orders?: boolean;
         style?: any;
         hide_match_liquidity?: boolean;
         show_grades?: boolean;
@@ -318,7 +338,7 @@ declare const _default: {
         onViewAdditionalMarkets: (event_id: string, event_type: string) => void;
         onOrder: (order: import("../types").OrderProps) => void;
     }) => import("react").JSX.Element;
-    MatchMarket: import("react").MemoExoticComponent<({ league, match, tournament, disabled_markets, float, flash_markets, show_event, hide_image, image_size_override, direction, style, hide_liquidity, hide_stat_banner, width, away_athlete, home_athlete, away_team, home_team, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onFlashSelect, onOrder, onView, onTradeLongPress }: {
+    MatchMarket: import("react").MemoExoticComponent<({ league, match, tournament, disabled_markets, highlight_router_orders, float, flash_markets, show_event, hide_image, image_size_override, direction, style, hide_liquidity, hide_stat_banner, width, away_athlete, home_athlete, away_team, home_team, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onFlashSelect, onOrder, onView, onTradeLongPress }: {
         league?: import("../types").LeagueProps;
         tournament?: import("../types").TournamentProps;
         match: import("../types").MatchProps;
@@ -331,6 +351,7 @@ declare const _default: {
         float?: boolean;
         home_team?: import("../types").TeamProps;
         image_size_override?: number;
+        highlight_router_orders?: boolean;
         hide_stat_banner?: boolean;
         flash_markets?: import("../types").PollProps[];
         width?: number;

package/lib/typescript/src/MarketComponents/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/MarketComponents/index.tsx"],"names":[],"mappings":";;;;;;;;;;mDAsCgT,CAAC,iBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;qBAAwqB,CAAC;mBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAvBj9B,CAAC,iBACxC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAD8B,CAAC;qBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuBwS,CAAC;mBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAhB7W,CAAA;qBACA,CAAA;;;;;;;;;;;;;AAJJ,wBAmBC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/MarketComponents/index.tsx"],"names":[],"mappings":";;;;;;;;;;mDAsCgT,CAAC,iBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;qBAAwqB,CAAC;mBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAvBj9B,CAAC,iBACxC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAD8B,CAAC;qBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAEtD,CAAC;4BAAkC,CAAC;;iBAGrB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBoX,CAAC;mBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAhBnZ,CAAA;qBACA,CAAA;;;;;;;;;;;;;AAJJ,wBAmBC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "be-components",
-  "version": "7.5.2",
+  "version": "7.5.4",
   "description": "Components for BettorEdge Apps",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/ApiOverrides/index.ts

@@ -50,7 +50,7 @@ const ENVIRONMENT_ENDPOINTS = {
         VOUCHED_SANDBOX: false,
         BOT_SVC_API: 'https://api.bot.bettoredge.com',
         EVENT_SVC_API: 'https://api.events.bettoredge.com',
-        BR_SVC_API: 'https://bet-router-a021faa960bb.herokuapp.com',
+        BR_SVC_API: 'http://localhost:5001',
         MK_SVC_API: 'https://api.markets.bettoredge.com',
         TP_SVC_API: 'https://be-tp-svc.herokuapp.com',
         SOCIAL_SVC_API: 'https://api.social.bettoredge.com',
@@ -63,7 +63,7 @@ const ENVIRONMENT_ENDPOINTS = {
     PRODUCTION_PROXY: {
         AUTH_SVC_API: 'https://proxy.bettoredge.com/players',
         CLIENT_API_KEY: 'mlOfTJPp4TdmppP9ajBmMVo2bO50O2G9',
-        BR_SVC_API: 'https://bet-router-a021faa960bb.herokuapp.com',
+        BR_SVC_API: 'http://localhost:5001',
         VOUCH_ID: 'Q3tmJ3r9FnkN*n-MqS-!j0NS*k!mdo',
         VOUCHED_CALLBACK_URL: 'https://be-auth-svc.herokuapp.com/v1/players/vouch/hook',
         VOUCHED_SANDBOX: false,

package/src/BetRouter/index.tsx

@@ -19,6 +19,7 @@ import MobileLayout from './layouts/MobileLayout';
 
 type BetRouterProps = {
     me: MyPlayerProps;
+    onRequestAuthenticate:() => void,
     insets: { top: number; bottom: number; left: number; right: number };
 };
 
@@ -73,7 +74,7 @@ type MarketState = {
     loading: boolean;
 };
 
-const BetRouter = ({ me, insets }: BetRouterProps) => {
+const BetRouter = ({ me, insets, onRequestAuthenticate }: BetRouterProps) => {
     // ========== Consolidated State ==========
     const [uiState, setUIState] = useState<UIState>({
         size: { width: 0, height: 0 },
@@ -130,7 +131,7 @@ const BetRouter = ({ me, insets }: BetRouterProps) => {
     // ========== Initialization ==========
     useEffect(() => {
         BetRouterApi.setEnvironment();
-        if (!me?.player_id) return;
+        if (!me?.player_id) return onRequestAuthenticate();
 
         // Load all initial data in parallel
         Promise.all([
@@ -366,7 +367,7 @@ const BetRouter = ({ me, insets }: BetRouterProps) => {
             console.error('Error reloading opportunities:', error);
         }
     };
-
+    if(!me){ return <></> }
     // ========== Render ==========
     return (
         <View

package/src/GolfScoreboard/api/index.tsx

@@ -195,7 +195,7 @@ export const GolfHelpers = {
             probability: trade.probability,
             side: trade.side,
             side_id: trade.side_id,
-            side_type: trade.side_type,
+            side_type: trade.side_type as OrderProps['side_type'],
             market_id: trade.market_id,
             player_id: '',
             rejections:0,

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

@@ -21,6 +21,7 @@ type AthleteMarketProps = {
     float?:boolean,
     direction?:'horizontal'|'vertical',
     style?:any,
+    highlight_router_orders?:boolean
     image_size?:number,
     league?:LeagueProps,
     hide_image?:boolean,
@@ -36,7 +37,7 @@ type AthleteMarketProps = {
     onTradeLongPress:(trade:TradeProps) => void
 }
 
-const AthleteMarket = ({ event, show_event, disabled_markets, float, image_size, hide_image, direction, league, hide_liquidity, style, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress, onSetMarket }:AthleteMarketProps) => {
+const AthleteMarket = ({ event, show_event, disabled_markets, highlight_router_orders, float, image_size, hide_image, direction, league, hide_liquidity, style, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress, onSetMarket }:AthleteMarketProps) => {
     const C = useColors();
 
     const { liquidity, open_order_count } = useMemo(() => MarketComponentHelpers.getLiqudity(event_order_stats), [JSON.stringify(event_order_stats)])
@@ -60,6 +61,7 @@ const AthleteMarket = ({ event, show_event, disabled_markets, float, image_size,
                     trade={trade}
                     show_grades={show_grades}
                     order={ba_order}
+                    highlight_router_orders={highlight_router_orders}
                     locked={is_locked || disabled}
                     onLongPress={onTradeLongPress}
                     onPress={(order) => {

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

@@ -17,6 +17,7 @@ type AthleteTournamentMarketProps = {
     float?:boolean,
     disabled_markets?:string[],
     market:MarketProps,
+    highlight_router_orders?:boolean,
     hide_image?:boolean,
     style?:any,
     show_event?:boolean,
@@ -33,7 +34,7 @@ type AthleteTournamentMarketProps = {
     onTradeLongPress:(trade:TradeProps) => void
 }
 
-const AthleteTournamentMarket = ({ tournament, disabled_markets, league, float, style, hide_image, direction, show_event, hide_liquidity, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress }:AthleteTournamentMarketProps) => {
+const AthleteTournamentMarket = ({ tournament, highlight_router_orders, disabled_markets, league, float, style, hide_image, direction, show_event, hide_liquidity, hide_stat_banner, athlete, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onOrder, onView, onTradeLongPress }:AthleteTournamentMarketProps) => {
     const C = useColors();
     const { liquidity, open_order_count } = useMemo(() => MarketComponentHelpers.getLiqudity(event_order_stats),[JSON.stringify(event_order_stats)]);
     const is_locked = useMemo(() => MarketComponentHelpers.isTournamentMarketLocked(tournament, market.market_id),[JSON.stringify(tournament.supported_markets)])
@@ -55,6 +56,7 @@ const AthleteTournamentMarket = ({ tournament, disabled_markets, league, float,
                     market={data.market}
                     trade={trade}
                     show_grades={show_grades}
+                    highlight_router_orders={highlight_router_orders}
                     locked={is_locked || disabled}
                     order={ba_order}
                     onLongPress={onTradeLongPress}

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

@@ -19,6 +19,7 @@ type EventMarketProps = {
     latest_trades:TradeProps[],
     hide_liquidity?:boolean,
     style?:any,
+    highlight_router_orders?:boolean,
     direction?:'horizontal'|'vertical',
     best_available_orders:BestAvailableOrderProps[],
     event_order_stats:EventOrderStatProps[],
@@ -29,7 +30,7 @@ type EventMarketProps = {
     onTradeLongPress:(trade:TradeProps) => void
 }
 
-const EventMarket = ({ event, float, style, disabled_markets, direction, hide_liquidity, market, latest_trades, best_available_orders, hide_market_banner, event_order_stats, show_grades, default_price_view, onOrder, onView, onTradeLongPress }:EventMarketProps) => {
+const EventMarket = ({ event, float, style, highlight_router_orders, disabled_markets, direction, hide_liquidity, market, latest_trades, best_available_orders, hide_market_banner, event_order_stats, show_grades, default_price_view, onOrder, onView, onTradeLongPress }:EventMarketProps) => {
     const C = useColors();
     const { liquidity, open_order_count } = useMemo(() => MarketComponentHelpers.getLiqudity(event_order_stats),[JSON.stringify(event_order_stats)]);
 
@@ -55,6 +56,7 @@ const EventMarket = ({ event, float, style, disabled_markets, direction, hide_li
                     market={data.market}
                     side_label={side_label}
                     show_grades={show_grades}
+                    highlight_router_orders={highlight_router_orders}
                     locked={is_locked || disabled}
                     order={ba_order}
                     onLongPress={onTradeLongPress}

package/src/MarketComponents/components/ExternalPriceComparison.tsx

@@ -20,11 +20,20 @@ type ExternalPriceComparisonProps = {
     external_name?:string,
     participant_id?:string,
     init_side?:string,
-    onClose:() => void
+    onClose:() => void,
+    onSeePriceHistory?:(props: {
+        contest_id: string,
+        contest_type: string,
+        market_id: string,
+        participant_id?: string,
+        participant_type?: string,
+        selected_side: string,
+        var_1?: number
+    }) => void
 }
 
 
-const ExternalPriceComparison = ({ price_key, float, contest_id, style, contest_type, market_id, participant_id, participant_type, external_name, init_side, onClose }:ExternalPriceComparisonProps) => {
+const ExternalPriceComparison = ({ price_key, float, contest_id, style, contest_type, market_id, participant_id, participant_type, external_name, init_side, onClose, onSeePriceHistory }:ExternalPriceComparisonProps) => {
     const [ module_data, setModuleData ] = useState<{
         loading:boolean,
         market?:MarketProps,
@@ -136,9 +145,28 @@ const ExternalPriceComparison = ({ price_key, float, contest_id, style, contest_
                     <Text theme='description' style={{ marginTop:3 }}>{athlete?`${athlete.abbr_name} `:team?`${team.abbr} `:''}{market.type == 'Stat' ? market.stat_label : market.type}</Text>
                     :<></>}
                 </View>
-                <View transparent style={{ flexDirection:'row' }}>
+                <View transparent style={{ flexDirection:'row', gap: 10 }}>
+                    {onSeePriceHistory && (
+                        <Button
+                            title='See Price History'
+                            type='success'
+                            style={{ padding:10 }}
+                            onPress={() => {
+                                onSeePriceHistory({
+                                    contest_id,
+                                    contest_type,
+                                    market_id,
+                                    participant_id,
+                                    participant_type,
+                                    selected_side,
+                                    var_1: latest_trade?.var_1
+                                });
+                            }}
+                        />
+                    )}
                     <Button
                         title='X'
+                        style={{ padding:10 }}
                         type='close'
                         onPress={() => onClose()}
                     />
@@ -191,17 +219,6 @@ const ExternalPriceComparison = ({ price_key, float, contest_id, style, contest_
                     />
                 </View>
             </View>
-            <View type='footer' transparent style={{ flexDirection:'row', padding:20 }}>
-                <Button
-                    title='CLOSE'
-                    backgroundColor={Colors.shades.white}
-                    style={{ flex:1 }}
-                    type='close'
-                    onPress={() => onClose()}
-                    
-                />
-            </View>
-
         </View>
     )
 }

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

@@ -12,13 +12,14 @@ type MarketButtonProps = {
     side_option:MarketSideOptionProps,
     side_label?:string,
     locked?:boolean,
+    highlight_router_orders?:boolean,
     order?:BestAvailableOrderProps,
     trade:TradeProps,
     show_grades?:boolean,
     onPress: (order:OrderProps) => void,
     onLongPress:(trade:TradeProps) => void
 }
-const MarketCard = ({ side_option, locked, show_grades, market, trade, order, side_label, onPress, onLongPress }:MarketButtonProps) => {
+const MarketCard = ({ side_option, locked, show_grades, market, trade, highlight_router_orders, order, side_label, onPress, onLongPress }:MarketButtonProps) => {
     const C = useColors();
     const [ updated, setUpdated ] = useState<{
         iteration: number,
@@ -46,7 +47,7 @@ const MarketCard = ({ side_option, locked, show_grades, market, trade, order, si
     },[trade])
     return (
         <Button
-            style={{ flexGrow:1, padding:0, backgroundColor:color, borderRadius:4}}
+            style={{ flexGrow:1, padding:0, backgroundColor:color, borderRadius:4, borderColor:C.text.warning, borderTopWidth:highlight_router_orders?1:0}}
             onPress={() => handlePress()}
             disabled={loading || locked ? true : false}
             onLongPress={() => onLongPress({ ...trade, market:market })}

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

@@ -23,6 +23,7 @@ type MatchMarketProps = {
     float?:boolean,
     home_team?:TeamProps,
     image_size_override?:number,
+    highlight_router_orders?:boolean,
     hide_stat_banner?:boolean,
     flash_markets?:PollProps[],
     width?:number,
@@ -41,7 +42,7 @@ type MatchMarketProps = {
     onTradeLongPress:(trade:TradeProps) => void
 }
 
-const MatchMarket = ({ league, match, tournament, disabled_markets, float, flash_markets, show_event, hide_image, image_size_override, direction, style, hide_liquidity, hide_stat_banner, width, away_athlete, home_athlete, away_team, home_team, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onFlashSelect, onOrder, onView, onTradeLongPress }:MatchMarketProps) => {
+const MatchMarket = ({ league, match, tournament, disabled_markets, highlight_router_orders, float, flash_markets, show_event, hide_image, image_size_override, direction, style, hide_liquidity, hide_stat_banner, width, away_athlete, home_athlete, away_team, home_team, market, event_order_stats, default_price_view, latest_trades, show_grades, best_available_orders, onFlashSelect, onOrder, onView, onTradeLongPress }:MatchMarketProps) => {
     const C = useColors();
     const { liquidity, open_order_count } = useMemo(() => MarketComponentHelpers.getLiqudity(event_order_stats), [JSON.stringify(event_order_stats)])
     const is_locked = useMemo(() => MarketComponentHelpers.isMatchMarketLocked(match, market.market_id),[JSON.stringify(match.supported_markets)])
@@ -83,6 +84,7 @@ const MatchMarket = ({ league, match, tournament, disabled_markets, float, flash
                     side_option={data.item}
                     market={data.market}
                     side_label={side_label}
+                    highlight_router_orders={highlight_router_orders}
                     trade={trade}
                     show_grades={show_grades}
                     order={ba_order}

package/src/MarketComponents/components/OrderBook.tsx

@@ -1,6 +1,6 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import { FlatList } from "react-native"
-import type { MarketProps, OrderProps } from '../../types';
+import type { BestAvailableOrderProps, MarketProps, OrderProps } from '../../types';
 import OrderGradeBar from './OrderGradeBar';
 import { Icons } from '../../Components';
 import { MarketComponentHelpers } from '../api';
@@ -12,15 +12,71 @@ type OrderBookCardProps = {
     player_id?:string,
     orders: OrderProps[],
     market: MarketProps,
+    var_1: number,
     show_grades?:boolean,
     show_orders?:boolean,
-    onBuy: (order:OrderProps) => void
+    onBuy: (order:OrderProps) => void,
+    router_orders?: BestAvailableOrderProps[],
+    contest_type?: string | number,
+    contest_id?: string | number
 }
 
-const OrderBookCard = ({ player_id, orders, market, show_orders, show_grades, onBuy }:OrderBookCardProps) => {    
+const OrderBookCard = ({ player_id, orders, market, var_1, show_orders, show_grades, onBuy, router_orders, contest_type, contest_id }:OrderBookCardProps) => {
     const Colors = useColors();
-    const trade_side_orders = orders.filter(o => o.side === market.trade_side).sort((a,b) => a.probability - b.probability).splice(0, 9)
-    const o_side_orders = orders.filter(o => o.side !== market.trade_side).sort((a,b) => a.probability - b.probability).splice(0,9)
+    orders.map(o => console.log(`order ${o.side} ${o.var_1}`))
+    // Merge router_orders into orders
+    const mergedOrders = useMemo(() => {
+        if (!router_orders || router_orders.length === 0) {
+            return orders;
+        }
+
+        // Filter router_orders by contest_type, contest_id, and market_id
+        const filteredRouterOrders = router_orders.filter(order => {
+            const matchesType = order.event_type == contest_type;
+            const matchesId = order.event_id == contest_id;
+            const matchesMarket = order.market_id == market.market_id;
+            return matchesType && matchesId && matchesMarket;
+        });
+        // Convert BestAvailableOrderProps to OrderProps
+        const convertedRouterOrders: OrderProps[] = filteredRouterOrders.map(routerOrder => ({
+            ...routerOrder,
+            order_type: 'limit',
+            collar_pct: 0,
+            be_type: 'market',
+            position_ids: [],
+            h2h: false,
+            market_type:'FOR_MONEY',
+            positions: [],
+            available_for_parlays: false,
+            status: 'approved',
+            resolution_status: 'inprogress',
+            commission_pct: 0
+        }));
+
+        // Merge with existing orders
+        return [...orders, ...convertedRouterOrders];
+    }, [orders, router_orders, contest_type, contest_id, market.market_id]);
+
+    //mergedOrders.map(o => console.log(`${o.var_1} ${o.side}`))
+    // Filter trade side orders to exact var_1
+    const trade_side_orders = mergedOrders
+        .filter(o => o.side == market.trade_side && o.var_1 == var_1)
+        .sort((a,b) => a.probability - b.probability)
+        .splice(0, 9);
+
+    // Filter opposing side orders with spread flip logic
+    const o_side_orders = mergedOrders
+        .filter(o => {
+            if (o.side === market.trade_side) return false;
+            // For spreads, flip the var_1 sign for opposing side
+            if (market.type === 'Spread') {
+                return o.var_1 == (var_1 * -1);
+            }
+            // For non-spreads (totals, etc), use same var_1
+            return o.var_1 == var_1;
+        })
+        .sort((a,b) => a.probability - b.probability)
+        .splice(0, 9)
 
     const handleOrderPress = async(order:OrderProps) => {
         return onBuy({