be-components 7.4.7 → 7.5.1

package/src/BetRouter/types/config.ts

@@ -0,0 +1,12 @@
+/**
+ * Configuration types for API contracts
+ */
+
+export interface ConfigProps {
+  config_id: string;
+  config: string; // Config key (e.g., 'MAX_BET_AMOUNT', 'MAX_FILL_AMOUNT')
+  value: string; // String representation of the value
+  config_format: 'string' | 'number' | 'boolean' | 'json'; // Format type
+  create_datetime: any; // Datetime when config was created
+  last_update_datetime: any; // Datetime when config was last updated
+}

package/src/BetRouter/types/contests.ts

@@ -0,0 +1,37 @@
+// Contest Types
+
+export interface RouterContestProps {
+    router_contest_id: string
+    router_league_id: string // FK
+    contest_id: string // BettorEdge Source
+    contest_label: string // Human readable label
+    contest_type: 'team' | 'tournament' | 'match' // BettorEdge Source
+    scheduled_datetime: any
+    status: 'open' | 'closed' | 'settled'
+    auto_fill?: boolean // Enable/disable auto-fill liquidity for this contest
+    tags?: Record<string, any> // JSONB metadata for auto-linking (away_team, home_team, etc.)
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface PartnerContestProps {
+    partner_contest_id: string
+    raw_contest_id: string // FK → raw_contest
+    router_contest_id: string // FK → router_contest
+    partner_id: string // FK → router_partner (denormalized from raw_contest for convenience)
+    external_id: string // Denormalized from raw_contest for convenience
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface RawContestProps {
+    raw_contest_id: string
+    partner_id: string // FK
+    router_league_id: string // FK
+    pretty_title: string
+    scheduled_datetime: string
+    external_id: string
+    status: 'active' | 'closed'
+    create_datetime: any
+    last_update_datetime: any
+}

package/src/BetRouter/types/credentials.ts

@@ -0,0 +1,99 @@
+// Partner Credential Types
+// These define what inputs are needed for each partner
+
+export interface KalshiCredentialProps {
+    api_key: string
+    private_key_pem: string
+}
+
+export interface BettorEdgeCredentialProps {
+    username: string
+    password: string
+    access_token?: string // We will store the bearer token here
+    refresh_token?: string // Store the refresh token here
+    expire_datetime?: any // timestamp with timezone
+}
+
+export interface BetOpenlyCredentialProps {
+    user_id: string
+    username: string
+    password: string
+}
+
+// Union type of all possible credentials
+export type PartnerCredentialProps = KalshiCredentialProps | BettorEdgeCredentialProps | BetOpenlyCredentialProps
+
+// Type guard helpers for client to determine which credential type is needed
+export const isKalshiCredentials = (creds: any): creds is KalshiCredentialProps => {
+    return 'api_key' in creds && 'private_key_pem' in creds
+}
+
+export const isBettorEdgeCredentials = (creds: any): creds is BettorEdgeCredentialProps => {
+    return 'username' in creds && 'password' in creds && 'device_id' in creds
+}
+
+export const isBetOpenlyCredentials = (creds: any): creds is BetOpenlyCredentialProps => {
+    return 'username' in creds && 'password' in creds && !('device_id' in creds)
+}
+
+// Helper to get required fields for a partner by name
+export const getRequiredCredentialFields = (partnerName: string): string[] => {
+    switch (partnerName) {
+        case 'Kalshi':
+            return ['api_key', 'private_key_pem']
+        case 'BettorEdge':
+            return ['username', 'password']
+        case 'BetOpenly':
+            return ['user_id','username', 'password']
+        default:
+            return []
+    }
+}
+
+// Helper to get credential field labels for UI
+export const getCredentialFieldLabels = (partnerName: string): Record<string, string> => {
+    switch (partnerName) {
+        case 'Kalshi':
+            return {
+                api_key: 'API Key',
+                private_key_pem: 'Private Key (PEM format)'
+            }
+        case 'BettorEdge':
+            return {
+                username: 'Username',
+                password: 'Password'
+            }
+        case 'BetOpenly':
+            return {
+                username: 'Username',
+                password: 'Password',
+                user_id: 'User Id'
+            }
+        default:
+            return {}
+    }
+}
+
+// Helper to get credential field types for UI
+export const getCredentialFieldTypes = (partnerName: string): Record<string, 'text' | 'password' | 'textarea'> => {
+    switch (partnerName) {
+        case 'Kalshi':
+            return {
+                api_key: 'text',
+                private_key_pem: 'textarea'
+            }
+        case 'BettorEdge':
+            return {
+                username: 'text',
+                password: 'password',
+            }
+        case 'BetOpenly':
+            return {
+                user_id: 'text',
+                username: 'text',
+                password: 'password'
+            }
+        default:
+            return {}
+    }
+}

package/src/BetRouter/types/index.ts

@@ -0,0 +1,16 @@
+// Main exports - Single source of truth for all types
+// Copy this entire folder to your client project
+
+export * from './opportunities';
+export * from './orders';
+export * from './accounts';
+export * from './partners';
+export * from './leagues';
+export * from './contests';
+export * from './participants';
+export * from './markets';
+export * from './liquidity';
+export * from './credentials';
+export * from './config';
+export * from './jobs';
+export * from './api-contracts';

package/src/BetRouter/types/jobs.ts

@@ -0,0 +1,37 @@
+/**
+ * The betrouter system will have a series of the jobs that need to be run to keep everything up to date.
+ */
+export interface RouterJobProps {
+    router_job_id:string //PK
+    job_key:string, //Unique key for the job - this will be unique per job
+    name: string//Pretty label of the job
+    description: string //Description for the admin to understand the job they are kicking off
+    frequency: number //Frequency number depending on the frequency type.  For example a frequency of 1 and frequency type of day.  Then this should run once every day
+    frequency_type: 'seconds'|'minutes'|'hours'|'days'
+    status: 'active'|'inactive' //Whether the job should be run by the worker. Defaults to 'inactive'
+    last_success_datetime:any //timestamp with timezone of the last time it was run successfully
+    create_datetime:any //timestamp with timezone
+    last_update_datetime: any //timestamp with timezone
+}
+
+export interface ParentJobPriorityProps {
+    parent_job_priority_id:string //PK
+    parent_job_key: string //Job key of the parent job
+    priority: number //This is used to synchornize child jobs in a specific order
+    child_job_key:string //Child job to be run at that priority
+    create_datetime:any //timestampt with timezone
+    last_update_datetime:any //timestamp with timezone
+}
+
+export interface RouterJobStatusProps {
+    job_status_id:string, //Primary Key
+    router_job_id:string, //FK to the router_job
+
+    scheduled_datetime?:any //If scheduled for the future, timestamp with timezone of when it will kick off
+    start_datetime:any //timestamp with timezone when the job kicks off
+    end_datetime:any //timestamp with timezone when the job ends
+    create_datetime:any //timestamp with timezone - creation of the record
+    last_update_datetime:any //timestamp with timezone - update record
+    parent_job_id?:string //FK to itself.  So we may have an overall job that runs a series of child jobs.  If this is a child job - it will reference the parent router_job_id
+    status: 'scheduled'|'inprogress'|'failed'|'success' //Status of the job.  If a parent job - if any child job fails, this will be failed.  All child jobs succeed - then success
+}

package/src/BetRouter/types/leagues.ts

@@ -0,0 +1,29 @@
+// League Types
+
+export interface RouterLeagueProps {
+    router_league_id: string // PK
+    name: string // e.g., MLB, NBA, NFL
+    status: 'active' | 'inactive'
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface PartnerLeagueProps {
+    partner_league_id: string // PK
+    raw_league_id: string // FK → raw_league
+    router_league_id: string // FK → router_league
+    partner_id: string // FK → router_partner (denormalized from raw_league for convenience)
+    external_id: string // Denormalized from raw_league for convenience
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface RawLeagueProps {
+    raw_league_id: string
+    partner_id: string
+    name: string
+    external_id: string
+    status: 'active' | 'inactive'
+    create_datetime: any
+    last_update_datetime: any
+}

package/src/BetRouter/types/liquidity.ts

@@ -0,0 +1,15 @@
+// Liquidity Types
+
+export interface RouterLiquidityProps {
+    router_liquidity_id: string // PK
+    liquidity_hash: string // Hash identifier: partner_id:router_contest_id:router_market_id:market_side_id:market_variable_id:participant_id:timeframe_id
+    router_contest_id: string // FK -contest
+    title:string,
+    partner_market_id: string // FK - market id -- can eventually crawl this all the way up to the partner
+    price: number // This is the cheapest probability of the bet
+    available: number // This is the amount of liquidity available at that price
+    expire_datetime: any // Moment
+    create_datetime: any // MOMENT
+    buy_id?: string
+    last_update_datetime: any // MOMENT
+}

package/src/BetRouter/types/markets.ts

@@ -0,0 +1,94 @@
+// Market Types
+
+export interface RouterMarketOptions {
+    auto_support_team_contests?: boolean // If true, automatically create market_contests for team-type contests
+}
+
+export interface RouterMarketProps {
+    router_market_id: string // PK
+    market_key: string // Unique key: "moneyline", "spread", "player_points", "team_total"
+    market_label: string // Human readable: "Moneyline", "Spread", "Player Points"
+    market_description: string // Longer description
+    category: 'game_result' | 'team_stat' | 'player_stat' | 'game_stat' // What category
+    variable_required: boolean // Does it need a line/spread/total?
+    default_variable_type: 'total' | 'spread' // Default type for variables in this market
+    allow_multiple_participants: boolean // Can multiple participants be linked to this market? (e.g., props)
+    participant_type: 'team' | 'player' | 'event' // What type of participant (always required)
+    options?: RouterMarketOptions // Configuration options for this market
+    status: 'active' | 'inactive'
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface RawMarketProps {
+    raw_market_id: string // PK
+    partner_id: string // FK
+    partner_contest_id: string // FK to partner contest
+    external_id: string // Partner's market ID
+    pretty_title: string // Human readable title
+    status: 'active' | 'closed'
+    create_datetime: any
+    last_update_datetime: any
+}
+
+/**
+ * Defines which router_markets are ALLOWED/SUPPORTED for a given router_contest
+ *
+ * This is NOT a link between abstract market types and specific games,
+ * but rather a whitelist of which market types can be mapped for a contest.
+ *
+ * Purpose: Not all markets make sense for all contests/sports
+ *
+ * Examples:
+ * - Baseball contests allow: Winner, Spread, Total Runs
+ * - Baseball contests DON'T allow: Total Rebounds (that's a basketball market!)
+ * - Basketball contests allow: Winner, Spread, Total Points, Total Rebounds
+ * - Basketball contests DON'T allow: Total Goals (that's a hockey market!)
+ *
+ * Usage: Before creating a partner_market, check if that router_market
+ * is allowed for the router_contest via this table.
+ */
+export interface MarketContestProps {
+    market_contest_id: string // PK
+    router_contest_id: string // FK - Which contest
+    router_market_id: string  // FK - Which market TYPE is allowed for this contest
+    status: 'open' | 'closed' // Is this market currently accepting bets for this contest?
+    auto_fill?: boolean // Enable/disable auto-fill liquidity for this market in this contest
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface RouterMarketVariableProps {
+    router_market_variable_id: string
+    router_market_id: string // FK
+    variable: number // I.e., if this is a spread it might by -4 or 5. If total it is 35 or 54.5, etc
+    variable_type: 'total' | 'spread' // Total or spread
+    create_datetime: any
+    last_update_datetime: any // All dates will be MOMENT objects eventually
+}
+
+export interface RouterMarketSideProps {
+    market_side_id: string
+    router_market_id: string
+    side_type: string // team | athlete | side
+    side_key: string // Over under, home, away, etc
+    renderer: string // Template for rendering titles: "{participant.name} to win {timeframe.label}"
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface PartnerMarketProps {
+    partner_market_id: string
+    raw_market_id: string // FK - Links to the event-specific raw market
+    router_contest_id: string // FK - Denormalized link to router contest (for performance)
+    router_market_variable_id: string // FK - RouterMarketVariable_id
+    partner_id: string // Foreign key - BettorEdge Company_id
+    router_market_id: string // Foreign Key - routermarketprops
+    market_side_id: string // Foreign key to the side of a market (i.e., option)
+    partner_participant_id: string // FK - Links to PartnerParticipantProps (which links to router participant)
+    timeframe_id: string // FK - Links to RouterTimeframeProps (full event, quarter, half, etc.)
+    external_id: string
+    price_key?: string // For Kalshi: 'yes' or 'no' to indicate which price to use
+    create_datetime: any
+    last_update_datetime: any
+}

package/src/BetRouter/types/opportunities.ts

@@ -0,0 +1,107 @@
+// Opportunity Types
+
+import type { PartnerMarketProps } from './markets'
+import type { RouterLiquidityProps } from './liquidity'
+
+export interface OpportunityLeg {
+    leg_number: number
+    partner_id: string
+    partner_market: PartnerMarketProps
+    market_side_id: string
+    liquidity: RouterLiquidityProps
+    liquidity_hash: string
+    buy_id?: string
+    title: string // Pretty title from liquidity (e.g., "Baltimore Ravens -7.5")
+    price: number
+    bet_amount: number
+    potential_payout: number
+    fee: number
+    router_market_variable_id: string
+    line?: number // The variable value (e.g., -3.5) for middles
+}
+
+export interface BuyOpportunity {
+    opportunity_id: string
+    opportunity_type: 'arbitrage' | 'middle' | 'reverse_middle' | 'auto_arbitrage'
+    router_contest_id: string
+    router_market_id: string
+
+    // Legs array instead of _1, _2 suffixes
+    legs: OpportunityLeg[]
+
+    // Overall opportunity metrics
+    total_price: number
+    price_difference: number // How much below 1.0 (e.g., 0.05 means 5% arbitrage)
+    guaranteed_profit: number // Minimum profit across both outcomes
+    roi: number // Return on investment as percentage
+    opportunity_with_fee: boolean // Whether opportunity still profitable after fees
+
+    // Common fields for all opportunity types
+    investment: number // Total money put down (sum of all leg bet_amounts)
+    total_potential_winnings: number // Maximum amount we could win (payout when we win)
+    at_risk: number // Absolute amount we could lose
+    win_probability: number // Probability of winning the total_potential_winnings
+    loss_probability: number // Probability that at_risk is lost
+    total_fees: number // Sum of all fees
+    expected_profit: number // Expected profit BEFORE fees
+    expected_value: number // Expected profit AFTER fees
+
+    // Middle-specific fields
+    middle_range_start?: number // Start of double-win window
+    middle_range_end?: number // End of double-win window
+
+    // Consensus data (when available)
+    consensus_home_spread?: number // e.g., -7
+    consensus_away_spread?: number // e.g., +7
+
+    // Human-readable description
+    human_readable_description?: string // User-friendly explanation of the opportunity
+}
+
+export interface OpportunityProps {
+    opportunity_id: string // PK - From BuyOpportunity - for grouping related attempts
+    router_account_id: string // FK - Which account is taking this opportunity
+    opportunity_type: BuyOpportunity['opportunity_type'] // arbitrage | middle | reverse_middle
+    router_contest_id: string // FK
+    expected_profit: number
+    expected_roi: number
+    total_bet_amount: number
+    total_winnings: number // Sum of all order winnings
+    total_net_winnings: number // Sum of all order net_winnings
+    total_fees: number // Sum of all order fees
+    actual_profit?: number // Actual profit once opportunity is closed
+    actual_roi: number // Actual ROI once opportunity is closed
+    fill_status: 'pending' | 'all_filled' | 'partially_filled' | 'failed' // Status of order placement
+    status: 'open' | 'closed' // Overall status: open while any order is open, closed when all orders closed or fill failed
+    create_datetime: any
+    completed_datetime?: any
+}
+
+//Summary of multiple opportunities
+export interface OpportunitySummaryProps {
+    opportunity_type: OpportunityProps['opportunity_type'],
+    total_bet_amount: number,
+    total_winnings: number,
+    opportunity_count: number //Count of opportunities included in this
+    total_net_winnings: number,
+    total_fees: number,
+    actual_profit: number,
+    to: number, //UNIX timestamp
+    from: number //UNIX timestamp
+}
+
+export interface OpportunityStatusLegProps {
+    opportunity_status_leg_id: string // PK
+    opportunity_id: string // FK - references opportunities table
+    leg_number: number // 1, 2, 3, etc.
+    liquidity_hash: string
+    partner_id: string
+    partner_market_id: string
+    expected_amount: number
+    expected_price: number
+    status: 'pending' | 'success' | 'failed'
+    router_order_id?: string // FK - null until order placed
+    error_message?: string
+    create_datetime: any
+    last_update_datetime: any
+}

package/src/BetRouter/types/orders.ts

@@ -0,0 +1,51 @@
+// Order Types
+
+export interface RouterOrderProps {
+    router_order_id: string // Primary key
+    router_account_id: string // FK - Which account placed this order
+    account_partner_id: string // FK - Associated with the partner_id
+    partner_id: string // FK - Denormalized for easier queries
+
+    // Contest/Market References
+    router_contest_id: string // FK - Which contest
+    router_market_id: string // FK - Which market
+    partner_market_id: string // FK - Partner's market
+
+    // Order Details
+    title: string // Pretty title (i.e., "Minnesota to win", "Los Angeles to win")
+    external_id: string // Partner platform order ID - used to get status from partner
+    side: string // Which side/outcome (e.g., "home", "away", "yes", "no")
+
+    // Opportunity Tracking
+    liquidity_hash: string // Hash of liquidity - can recalculate opportunity to test performance
+    opportunity_type: 'arbitrage' | 'middle' | 'reverse_middle' | 'auto_arbitrage'
+    opportunity_id: string // The generated opportunity_id that this order is part of
+    leg_number: number // Which leg of the opportunity (1 or 2)
+    model_id?: string // FK - For model performance tracking in the future
+
+    // Financial
+    amount: number // Bet amount
+    amount_with_fee: number // Bet amount plus fee (total cost)
+    price: number // Price/odds at placement (e.g., 0.55)
+    fee: number // Fee charged by partner
+    winnings: number // Gross winnings before fees
+    potential_payout: number //Potential payout using amount and price
+    net_winnings: number // Net profit/loss after fees
+    roi: number // Return on investment percentage
+
+    // Status & Results
+    status: 'open' | 'closed' // Simple status: open when active, closed when settled/cancelled/failed
+    partner_order_status?: string // Raw status from partner API for granular tracking
+    result?: 'win' | 'lose' | 'push' | 'cancelled' // Final result after settlement
+
+    // Partner Data
+    payload?: any // Raw partner order object for debugging and investigation
+
+    // Settlement
+    settled_datetime?: any // Timestamp when the order was settled
+
+    // Timestamps
+    create_datetime: any // When order record was created
+    placed_datetime?: any // When order was actually placed with partner
+    last_update_datetime: any // Last updated
+}

package/src/BetRouter/types/participants.ts

@@ -0,0 +1,34 @@
+export interface RouterParticipantProps {
+    participant_id: string // PK
+    router_league_id: string // FK - which league/sport this participant belongs to (e.g., Washington in NFL vs NBA)
+    participant_type: 'team' | 'athlete' | 'event'
+    bettoredge_id: string // BettorEdge ID - athlete_id or team_id (source of truth)
+    name: string // Canonical name (i.e., LeBron James, LA Lakers, Event Total)
+    tags: string[] // All name variations for matching (LeBron James, Lebron, LBJ, etc.)
+    status: 'active' | 'inactive'
+    create_datetime: any // Moment - timestamp with timezone in pg
+    last_update_datetime: any // Moment - timestamp with timezone in pg
+}
+
+export interface RawParticipantProps {
+    raw_participant_id: string // PK
+    partner_id: string // FK - which partner this came from
+    router_league_id: string // FK - which league/sport this participant belongs to
+    external_id: string // Partner's participant ID (e.g., BettorEdge player ID, Kalshi team ID)
+    name: string // As named by partner
+    participant_type: 'team' | 'athlete' | 'event'
+    metadata?: Record<string, any> // Partner-specific data (stats, IDs, etc.)
+    status: 'active' | 'inactive'
+    create_datetime: any
+    last_update_datetime: any
+}
+
+export interface PartnerParticipantProps {
+    partner_participant_id: string // PK
+    partner_id: string // FK - denormalized for queries
+    raw_participant_id: string // FK - links to raw participant
+    router_participant_id: string // FK - links to router participant (canonical)
+    external_id: string // Partner's participant ID (denormalized)
+    create_datetime: any
+    last_update_datetime: any
+}

package/src/BetRouter/types/partners.ts

@@ -0,0 +1,10 @@
+// Partner Types
+
+export interface RouterPartnerProps {
+    partner_id: string
+    name: string
+    status: 'active' | 'inactive'
+    options: { [key: string]: any }
+    create_datetime: any
+    last_update_datetime: any
+}