# Virtual Sports Suite for Mobile Integration ## General information The Sportradar Virtual Sports Mobile Suite is the ready-to-use solution for offering our product portfolio in a mobile environment. Our Virtual Sports Mobile Suite includes the video area with the live scores, market offer for the upcoming two match days and the possibility to switch between the available matches. Additionally it includes the separator bars for the odds area, in order to show the information for the upcoming 2 match days.

## Host page HTML requirements Sportradar’s Virtual Sports Mobile Suite is a framework for a mobile web application, which integrates into an existing mobile-optimized website as a JavaScript plugin. In order to integrate the plugin, the following steps must be implemented in the host webpage: ### Include the vsmobile JavaScript plugin ```javascript ``` The JavaScript plugin is hosted on Sportradar's servers. `{domain}` will be provided by your assigned integration manager during integration. Configurable parts in the URL are the customer name (``), language code (``, e.g. en) and time zone (``, e.g. Europe:Berlin). The time zone parameter is optional. The UI customization is based on the client name URL parameter, therefore each client is assigned a unique client name. Language should follow the localization of the host page. The following is an example script URL: ```javascript ``` ### Provide container DOM elements in which the UI will be injected A container element is typically a `div` tag or some other block element with `id` attribute set. Example\ is shown below: ```html

``` If you want to use optional features like the match day title components, you need to provide\ container elements for those as well: ```html

``` ### Add `meta` tags to the `` section Sportradar’s Virtual Sports Mobile Suite is a web page optimized for mobile browsing. For optimal mobile experience the following meta tags should be added to a section in the host\ HTML page. ```html ``` The first `` tag is needed for setting the `viewport` to a size of the display on the device and for\ disabling zoom. It also instructs the browser to minimize the address bar and toolbars on some\ devices. The second and third lines enable the use of full-screen mode in iOS devices under certain\ circumstances. It is also recommended to add ``, `` tags to the head of the document in order to customize the application icon if the user adds the page to their home screen. ## Application initialization The application is initialized using the `vsmobile.init()` method. The first parameter is the value of the ID property (and a prepended #) of the container element specified above and the second parameter contains initialization options. Sample code of the initialization call is shown below. Note that only one application instance may be initialized on the host page at any given time. ```javascript var vsm = vsmobile.init('#vsm_app_container', options); ``` ## Initialization options The options are added as a second parameter in the `init` method. Below is an example options object that contains all possible available options.initialization. Please note that this is just an example and usually only a fraction of these options are needed for production (i.e. a working application). ```javascript var options = { sport: sport, onLoad: onLoad, betsChanged: betsChanged, showSlip: showSlip, loginRequired: loginRequired, setEvents: setEvents, roundOddsOverride: roundOddsOverride, topHeaderHeight: 0, bottomFooterHeight: 0, betSelectionMode: 'all', outrightSelectionMode: 'market', useBrowserHistoryAPI: true, displayMode: 'fixed', showBetButton: true, persistSelections: false, showUnsupportedDeviceWarning: true, referrer: 'referrerId', clientId: , enableMenuShortcuts: true, maintenanceCallback: maintenanceCallback, oddType: 'dec' }; ``` The initialization options are documented in the table below. Callback functions are described in detail below the table.

Option	Required	Type	Default	Comment
`sport`	yes	`string`	`null`	The sport to display on this page. The only supported options are: `vflm` `vfnc` `vfwc` `vfas` `vfc` `vfcc` `vbl`
`onLoad`	no	`function`	/	Callback function which is called when application is loaded.
`betChanged`	no	`function`	/	Callback function which is called each time betting selections in the application user interface changed. For example, if a user selects a bet, deselects a previously selected bet, or if bets are automatically deselected because the time to confirm such bets has expired.
`showSlip`	yes	`function`	/	Callback function which is called when a user clicks on the 'Confirm bets' button. This callback function should usually be implemented by the customer. Alternatively, the customer may implement `betsChanged` and render their own button or UI control for bringing up the bet slip.
`roundOddsOverride`	no	`function`	/	Implement this callback to override all odds for a given round, i.e. a match day (vflm).
`topHeaderHeight`	no	`numeric`	`0`	Height of client's top header (e.g. navigation, banner). Inserted top header element must have a fixed height and fixed positioning.
`bottomFooterHeight`	no	`numeric`	`0`	Height of client's bottom footer. Inserted footer element must have a fixed height and fixed positioning.
`betSelectionMode`	no	`string`	`match`	Bet selection mode. Valid modes are: `all` - all bets can be selected; `market` - for each market only one bet can be selected per match; `match` - for each match only one bet can be selected;
`outrightSelectionMode`	no	`string`	`market`	Outright bet selection mode. Valid modes are: `all` - all bets can be selected; `market` - for each market only one bet can be selected;
`useBrowserHistoryAPI`	no	`boolean`	`true`	When set to `false`, the application will not store page transitions into the browser history. Recommendation: set to `false` if your host application is using the Browser History API library.
`displayMode`	no	`string`	`fixed`	Display mode. Valid modes are: `fixed` - popup windows are displayed in full screen mode with content centered inside; `inline` - popup windows are displayed inline (use this option if you use inline footer and you don't want popups to display over it);
`showBetButton`	no	`boolean`	`true`	If set to `false`, the bet confirmation button will not be shown when the user selects bets. This is typically used if there is an existing button on the host web page which links to the betting slip.
`persistSelect` `ions`	no	`boolean`	`false`	If set to `true`, odds selected by the user will be persisted to local storage and reconstructed upon reload.
`showUnsupportedDeviceWarning`	no	`boolean`	`true`	Set to false to disable warning for unsupported devices (this warning is shown once on the first load).
`clientId`	no	`numeric`	implicit	The numeric client identifier (Sportradar S4 client ID). Primarily used for internal testing purposes.
`loginRequired`	no	`function`	/	Callback function which is called when a user tries to conduct an action that requires an established RGS user session (user should be authenticated). Used for RGS integrations only.
`referrer`	no	`string`	/	This is the referrer ID to use with RGS when different endpoints are needed. Used for RGS integrations only.
`setEvents`	no	`function`	/	Callback function which is called every betstop phase. Returns information regarding the current sport (including event_ids).
`enableMenuShortcuts`	no	`boolean`	`false`	Show icons in the navigation bar for menu items.
`maintenanceCallback`	no	`function`	undefined	Will be called when a product is in `maintenance` or `pause` mode or when that mode is not active anymore. Returns information about the sport, current server time, and which mode is active.
`oddType`	no	`string`	`dec`	Format of the odds in the odds area. Valid values are `dec`, `us`, `hk`, `indo`, `my`, `frac`

## Callbacks With callbacks, you can respond to events in the `VSM` application. There are several callbacks that can be implemented on client side. The first parameter to all callbacks is the `VSM` instance that triggered the callback. ### `onLoad` This callback function is called when the application is loaded. API methods may safely be called only after the application is loaded, as signaled by this callback. Callback example: ```javascript function onLoad(vsmInstance) { console.log('vsm loaded'); }; ``` ### `betsChanged` This callback function is called every time the betting selections in the user interface change. The typical use of this method is to display or update a bet slip on the host page. An array of all current selections is passed in the `currentBets` parameter. Furthermore, bets that have been added and bets that have been removed since the previous change are passed for convenience in the `betsAdded` and `betsRemoved` parameters. Callback example: ```javascript function betsChanged(vsmInstance, currentBets, betsAdded, betsRemoved, betsChangedReason) { console.log("Bets currently selected in the VSM interface:"); for (var i = 0; i < currentBets.length; ++i) { var bet = currentBets[i]; console.log(" --------"); console.log(" Selection unique key: " + bet.selectionKey); console.log(" Sport: " + bet.sport); console.log(" Tournament id: " + bet.tournamentId); console.log(" Tournament name: " + bet.tournamentName); console.log(" Tournament number: " + bet.tournamentNumber); console.log(" Tournament stage: " + bet.tournamentStage); console.log(" Round number: " + bet.roundNumber); console.log(" Match id: " + bet.matchId); console.log(" Fixture: " + bet.fixture); console.log(" Bet id: " + bet.xmlBetId); console.log(" Bet type id: " + bet.xmlTypeId); console.log(" Bet subtype id: " + bet.xmlSubtypeId); console.log(" Special odds value: " + bet.xmlSpecialOddsValue); console.log(" Bet outcome id: " + bet.betOutcomeId); console.log(" Market name: " + bet.marketName); console.log(" Market status: " + bet.status); console.log(" Outcome name: " + bet.outcomeName); console.log(" Odds: " + bet.odds); console.log(" Is outright market: " + bet.isOutrightMarket); } console.log(" --------"); console.log("Total number of unconfirmed bets: " + currentBets.length); }; ``` The following properties are provided for each bet:

Property	Comment
`asianOutcome`	When `asianSpreads` are enabled and available for the selected market, this object will contain the asian spreads. It has 4 fields: `marketName`, `outcomeName`, `prefix`, `value`.
`selectionKey`	The unique key to be used to reference this selection in API calls. Does not exist on outrights.
`selectionDescription`	For non asian market this field will simply contain the `outcomeName`. For asian markets this field will contain the `asianOutcome` name.
`selfDestruct`	For VTI this field contains a function which will remove the bet from the betslip if it's not valid anymore.
`sportForUrl`	The sport product name. For example each vf (vflm, vfwc, vfnc, vfas) product will contain vfc as a string on this field.
`outRightSelectionKey`	The unique key to be used to reference this selection in API calls. Only exists on outrights.
`sport`	Virtual sport, e.g. `vflm`.
`tournamentId`	Tournament/competition identifier.
`tournamentName`	The human-readable name of the tournamant, e.g. "Virtual Football League".
`tournamentNumber`	The consecutive iteration of the competition/tournament (season number).
`tournamentStage`	Tournaments which consist of multiple stages will have this parameter set. Only used by `vfnc` and `vfwc` with one of the two following values: `group` or `knockout`.
`roundNumber`	The sequential number of the match day or round within an iteration of the competition. For `vfnc` and `vfwc` the round number depends on the tournament stage. In the `group` stage the `roundNumber` will be the sequential number of the match day. In the `knockout` stage, round number will have on of the following values: 4 (round 16), 3 (quarterfinals), 2 (semifinals), 1 (finals).
`matchId`	Match unique identifier. Undefined on outrights.
`matchStartTime`	A timestamp when the match the bet is for starts. Undefined on outrights.
`meta`	When an palAvv id exists, for example for italian markets, the meta object will contain a field with the palAvv id.
`fixture`	Display name for the fixture, e.g. "VFL Bern - VFL London".
`marketName`	Localized display name for the selected market, e.g. "Total Goals - Over/Under 2.5".
`status`	Contains the current market status as available in the unified odds feed, e.g. 1 for an active market.
`outcomeName`	Localized display name for the selected outcome, e.g. "Over", "Under".
`odds`	Odds as string, depending on client setup, e.g. "5.0", "4/1".
`isOutrightMarket`	true - if the selected bet is from an outright market, false - if the selected bet is from a match market.
`unified`	Contains values used to identify odds from the unified odds feed. It has two fields, `marketId` and `outcomeId`. In case of season outrights the unified object will contain one field, `teamid:{teamid}`, e.g. `teamid:8982005`. The field will contain the unified object with the two fields, `marketId` and `outcomeId`, where `outcomeId` will contain the competitor `sr:competitor:{competitorId}`, e.g. `sr:competitor:276505`.
`validity`	Contains the validity of the bet in ms.

Examples for unified objects: ```json unified: { marketId: 799, outcomeId: "13" } ``` Example for season outright unified objects: ```json unified: { teamid:8982016: { marketId: 806, outcomeId: "sr:competitor:276516" } } ``` {% hint style="danger" %} Before accepting a bet, the user's betting selections must be validated on the server-side against markets/odds data sent via Unified Feed. {% endhint %} The `betsChanged` callback may be triggered due to several different reasons. The `betsChangedReason` `string` parameter provides context information on the reason why the callback was triggered. It is usually not necessary to use this additional information in typical integration scenarios.

betsChangedReason	Description
`selectionsClicked`	The user selected or deselected a bet by clicking on a selection.
`selectionsRestored`	Selections were restored from local storage at initial load (see also `persistSelections` option).
`selectionsExpired`	Selections were automatically removed due to the corresponding betting period expiring, therefore bets on these selections would no longer be accepted.
`selectionsDismissedViaAPI`	Selections were removed due to a call to the `deselectBet()` API method (see also `deselectBet` method description).
`selectionsConfirmedViaAPI`	Selections were removed due to a call to the `confirmBet()` API method (see also `confirmBet` method description).
`selectionsDismissedInBetslip`	Selections were removed by the user using the embedded betting slip. Used for RGS integrations only.
`selectionsConfirmedInBetslip`	Selections were removed after the user successfully placed a ticket through the embedded betting slip. Used for RGS integrations only.
`selectionsSuspended`	Selections were automatically removed due to the corresponding betting period suspending, therefore bets on these selections would not be accepted until unsuspending.
`selectionsUnsuspended`	Selections were automatically added due to the corresponding betting period unsuspending, therefore bets on these selections would be accepted again.

### `showSlip` This callback function is called when a user clicks on the 'Confirm bets' button. The customer should hide the `VSM` user interface and show the betting slip. If the user removes bets from the betting slip or confirms the bets in the betting slip, the customer should call `deselectBet` or `confirmBet` on the respective bets, identified by `bet.selectionKey`, so that the state of the bets in the `VSM` user interface reflects the users' actions in the betting slip. Callback example: ```javascript function showSlip(vsmInstance, bets) { vsmInstance.hide(); for (var i = 0; i < bets.length; ++i) { if (window.confirm("Do you accept the bet (" + bets[i].fixture + " : " + bets[i].marketName + " : " + bets[i].outcomeName + ")?")) { vsmInstance.confirmBet(bets[i].selectionKey); } else { vsmInstance.deselectBet(bets[i].selectionKey); } } vsmInstance.show(); }; ``` ### `roundOddsOverride` This optional callback function is called when the application is about to display odds for a given round. The callback provides the client with the ability to override the odds values. The client may choose not to override the default odds and not implement this callback function. If the callback function is\ implemented, new odds must be passed to the callback function that is supplied as a parameter to `roundOddsOverride()`. {% hint style="danger" %} Overridden odds must be in the same format as they are received in the function's parameter `oddsSuggestions`. Only the odds values may be changed. {% endhint %} In the callback example below, an `ajax` request is made. After receiving a response, the odds can be changed, but in the example below the default odds are simply passed back to the application, and therefore no change to the odds values is made. ```javascript function roundOddsOverride(vsmInstance, roundInfo, oddsSuggestions, callback) { jQuery.ajax({ url: 'http://www.test.com/newRoundOddsJson', type: 'GET', contentType: 'application/json; charset=utf-8', data: { sport: roundInfo.sport, tournamentId: roundInfo.tournamentId, roundNumber: roundInfo.roundNumber }, dataType: 'json', error: function(error) { console.error(error); }, success: function(data) { // implement logic for overriding oddsSuggestion using received data here, e.g. for (var i = 0; i < oddsSuggestions.length; ++i) { marketId = oddsSuggestions[i].xmlBetId; outcomeId = oddsSuggestions[i].betOutcomeId; oddsSuggestions[i].odds = data.markets[marketId].outcomes[betOutcomeId]; } // after change is made the provided callback is used to pass new odds callback(oddsSuggestions); } }); } ``` This method can also, for example, be used to convert decimal odds to fractional odds. Here is an example: ```javascript roundOddsOverride: function(vsmInstance, roundInfo, oddsSuggestions, callback) { for (var i = 0; i < oddsSuggestions.length; ++i) { if (oddsSuggestions[i].odds < 1) { continue; } var numerator = Math.round(100 * oddsSuggestions[i].odds); var denominator = 100; for (var j = denominator; j >= 1; --j) { if ((numerator % j) == 0 && (denominator % j) == 0) { numerator /= j; denominator /= j; break; } } oddsSuggestions[i].odds = numerator.toString() + "/" + denominator.toString(); } callback(oddsSuggestions); } ``` ### `setEvents` This callback function is called once every betstop phase. Returns information regarding the current sport. Callback example: ```javascript function setEvents(vsmInstance, data) { console.log(data); }; ``` The data object has the following properties: | Property | Description | | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `screen_name` | E.g. `mobile-cup` (for VFNC, VFWC, ...) or `mobile-league` (for VFLM, ...). | | `sport` | VFWC, VFNC, ... | | `unique_tournament_id` | The unique tournament id. | | `chunks` | Array containing chunk objects. This first chunk contains the next events that can be bet on, the second chunk contains the events after that, and so on. Usually 2 entries, but can only 1 during a knockout stage. | A chunk object has the following properties: | Property | Description | | ------------------------ | ----------------------------------------------------------------------------------------------------------- | | `competition_nr` | Continuous number of the competition which this event belongs to, as displayed on-screen. Positive integer. | | `competition_stage_type` | Type of the stage this event belongs to. 'league' (group stage or league mode) or 'cup' (knockout stage). | | `eventset_nr` | Number of the event set (round or match day). Between 1 and 30. | | `event_ids` | Array containing the event\_ids (matches) that occur at the same time. Positive integer. | ### `maintenanceCallback` This callback is called when the product is in either `maintenance` or `pause` mode or when that mode is not active anymore. Returns the current instance and an object. Callback example:

function maintenanceCallback(vsmInstance, data) {
    console.log(data);
};

The object 'data' has the following properties: | Property | Type | Description | | ------------------ | ----------------- | ------------------------------------------------------------------------------------ | | `application` | `string` | Type of the application. Currently only 'mobile'. | | `sport` | `string` | The sport in `maintenance` or `pause` (e.g. vflm, vfwc, vbl, ...) | | `server_timestamp` | `integer \| null` | The current server timestamp of the response. `null` if no server time is available. | | `is_maintenance` | `boolean` | `true` if the sport is in `maintenance` mode. | | `is_pause` | `boolean` | `true` if the sport is in `pause` mode. | If both `is_maintenance` and `is_pause` are `false`, then the previous mode (`maintenance` or `pause` ) is not active anymore. ## Plugin instance methods Instance methods provided by the `VSM` object that is returned at initialization are as follows: ### `getSelector`() Returns the CSS selector of the container DOM element, where the application is located. It was set in the `init` function as the first parameter. ### `getOptions`() Returns all effective plugin options that were set on initialization. ### `getLanguage`() Returns the effective language code. ### `destroy`() Used to remove the current instance of the application (e.g. when changing language). It stops polling data, removes all UI elements from the DOM, and unloads all JavaScript and CSS assets from the page. ### `show`() Show application. ### `hide`() Hide application. This is useful, for example, if you need to show an overlay above the `VSM` application and wish to temporarily hide the application below. ### `isShown`() Returns `true` if the application is shown. ### `isHidden`() Returns `true` if the application is hidden. ### `confirmBets`(`selectionKey`) Used for confirming a betting selection. The selection is identified using the `selectionKey` property of the bet object passed to `showSlip()` and `betsChanged()` callbacks. You may also enumerate all currently selected and still unconfirmed bets using the `getAllSelectedBets()` API function. ### `deselectBet`(`selectionKey`) Used for deselecting a betting selection in the user interface. The specified selection becomes unselected and will no longer be returned from `getAllSelectedBets()`. ### `getAllSelectedBets`() Used to retrieve all currently selected (and still unconfirmed) bets. ### `getStatus()` Returns the current state of the `VSM` instance, as one of the following string values: `INITIALIZING`, `INITIALIZED`, `DESTROYED`. ## RGS integration The Virtual Sports Suite for Mobile API includes certain options and methods that are specific for customers integrating via Sportradar's Remote Game Server (RGS). These RGS specific parts of the API are described in this section. ### Callbacks #### `loginRequired` This callback function is called when user tries to conduct an action that requires an established RGS user session (for example, placing a bet). When this callback occurs you can use the `setUserToken` method to re-authenticate user, same as in the example below. The callback implementation should be\ passed in the `loginRequired` attribute in the widget initialization options. Callback example: ```javascript function loginRequired(vsmInstance) { console.log('Login required...'); vsmInstance.setUserToken('USER_TOKEN'); }; ``` ### Methods #### `setUserToken`(`userToken`) Sets the user token which can be used to authenticate with the RGS server. #### `setCurrency`(`currencyCode, currencyLabel, decimalPlaces, defaultStake`) Sets the currency configuration to be used in the application (specified currency must be supported and configured on the RGS server side).

Property	Description
`currencyCode`	3 digit currency code (eur, usd).
`currencyLabel`	Currency label string (€, Eur, $, Usd).
`decimalPlaces`	Number of decimal places for the entered stakes.
`defaultStake`	Default stake automatically entered when user clicks on the stake field.

### Implementing a custom betting slip with RGS This section describes methods that may be used in order to implement your own betting slip when integrating through the RGS. In this scenario, your betting slip implementation should use the API methods described in this section in order to validate and place bets with the RGS. #### `getUserAccountInfo`(`callback`) Retrieves the RGS user account info from the RGS server. You need to supply a callback function which will be executed after the request is processed. A response, with the following object structure, will be served in the callback function: ```json { success: true, errors: [], data: { balance: 500000131609.15, // user account balance currency: "eur", // default user currency language: "en", // default user language username: "sportradar1" // username } } ``` Example usage: ```javascript instance.getUserAccountInfo(function(response) { if (response.success) { console.log(response.data); } }); ``` #### `getLimits`(`callback`) Retrieves the bookmaker limits configured by the RGS server. You need to supply a callback function which will be executed after the request is processed. A response, with the following object structure, will be served in the callback function: ```json { success: true, errors: [], data: { defaultCurrency: "eur", // default bookmaker currency defaultLanguage: "en", // default bookmaker language maxLinesPerTicket: 9, // maximum number of lines allowed per bet ticket minLinesPerTicket: 1, // minimum number of lines allowed per bet ticket perCurrencyLimits: { // currency specific settings eur: { maxPerBetStake: 1000, // maximum stake per bet maxWinMulti: 9999999, // maximum winning amount for 'multibet' system maxWinSingle: 9999999, // maximum winning amount for signle system minPerBetStake: 1 // minimum stake per bet }, usd: { maxPerBetStake: 1000, maxWinMulti: 9999999, maxWinSingle: 9999999, minPerBetStake: 1 } }, supportedCurrencies: { // the list of bookmakers supported currencies 0: 'eur', 1: 'usd' } } } ``` Example usage: ```javascript instance.getLimits(function(response) { if (response.success) { console.log(response.data); } }); ``` #### `getSystems`(`callback`) Retrieves the list of RGS supported bet types for the currently selected bets. You need to supply a callback function which will be executed after the request is processed. A response, with the following object structure, will be served in the callback function: ```json { success: true, errors: [], data: { systems: { 0: { betType: "single" // bet type 'signle' - individual bet for each ticket line (bet selection) noOfBets: 4, // number of bets to be placed by this type of bet systemType: undefined }, 1: { betType: "multibet" // bet type 'multibet' - single bet for the whole ticket noOfBets: 1, // number of bets to be placed by this type of bet systemType: undefined }, 2: { betType: "system" // bet type 'system' - combination of bets pet ticket (in this case 2 of 4) noOfBets: 6 // number of bets to be placed by this type of bet systemType: 2 // type of the system bet (in this case 2 of 4) }, 3: { betType: "system" // bet type 'system' - combination of bets pet ticket (in this case 3 of 4) noOfBets: 4 // number of bets to be placed by this type of bet systemType: 3 // type of the system bet (in this case 3 of 4) }, ... } } } ``` Example usage: ```javascript instance.getSystems(function(response) { if (response.success) { console.log(response.data); } }); ``` Systems can contain one or more of the following betting options:

Bet Type	Bet System	Description
`single`	undefined	A bet on an individual selection or outcome.
`multibet`	undefined	A linked series of win singles where the return from the first selection is automatically staked on the second selection as a win single and so on until all selections have won, thus giving a return, or until one selection loses in which case the whole bet is lost.
`system`	-4	Full cover bet with singles. A wager consisting of all possible singles, doubles, trebles, and accumulators across a given number of selections.
`system`	-3	Full cover bet. A wager consisting of all possible doubles, trebles, and accumulators across a given number of selections.
`system`	2	A bet on two selections; both of which must win to gain a return.
`system`	3	A bet on three selections; all three of which must win to gain a return.
`system`	4 or higher	Accumulator. A bet on four or more selections; all of which must win to gain a return. Accumulators are often named after the number of selections they contain - thus we can get a fourfold, fivefold or sixfold accumulator (or even higher).

#### `validateTickets`(`tickets, calback`) Validates the requested tickets (selected bet types) with the RGS and returns odds and possible winnings for the currently selected bets. You need to pass in betting options and a callback function which will be executed after the request is processed. The `tickets` parameter must be an object prepared as specified in this example: ```json { currencyCode: 'eur', // currency code to be used by RGS to prepare the ticket validation / calculations bets: [{ // array of selected bet types betType: 'single', // bet type - one of the betting options returned by getSystems function stake: 1.00 // stake for this bet type }, { // array of selected bet types betType: 'multibet', stake: 1.50 }, { betType: 'system', systemType: 3, // system type must be provided if the bet type is set to 'system' stake: 2.00 }] } ``` Here you can see, that we are setting stakes for three bet types. You can use any of the betting options returned by the `getSystems` method. A response, with the following object structure, will be served in the callback function: ```json { success: true, errors: [], data: { balance: 500000131573.65, // user account balance before the transaction currency: "eur", // betslip currency totalPossibleWinning: 388.13453875000005, // total possible winning totalStake: 47.5, // total stake bets: [{ betType: "single", // bet type systemType: undefined, // system type currency: "eur", // bet currency perBetStake: 0, // per bet stake possibleWinning: 11.2, // possible winning for this bet type possibleWinningTax: Object, // additional tax info if needed stakeTax: Object, // additional tax info if needed ticketStake: 6, // ticket stake for this bet type ticketStakeType: "per_line" // ticket stake type for this bet type }, { betType: "multibet", currency: "eur", perBetStake: 0, possibleWinning: 55.84, possibleWinningTax: Object, stakeTax: Object, ticketStake: 1.5, ticketStakeType: "total" }, { betType: "system", systemType: 3, currency: "eur", perBetStake: 2, possibleWinning: 254.05, possibleWinningTax: Object, stakeTax: Object, ticketStake: 40, ticketStakeType: "per_bet" }] } } ``` Example usage: ```javascript var tickets = { currencyCode: 'eur', bets: [{ betType: 'single', stake: 1.00 }, { betType: 'multibet', stake: 1.50 }, { betType: 'system', systemType: 3, stake: 2.00 }] }; instance.validateTickets(tickets, function(response) { if (response.success) { console.log('Validation OK', response.data); } }); ``` #### `placeTickets`(`tickets, callback`) Places the requested tickets (selected bet types) for the currently selected bets. You need to pass in betting options and a callback function which will be executed after the request is processed. The `tickets` parameter must be an object prepared as specified in this example (the same object as in the\ `validateTickets` example): ```json { currencyCode: 'eur', // currency code to be used by RGS to prepare the ticket validation / calculations bets: [{ // array of selected bet types betType: 'single', // bet type - one of the betting options returned by getSystems function stake: 1.00 // stake for this bet type }, { // array of selected bet types betType: 'multibet', stake: 1.50 }, { betType: 'system', systemType: 3, // system type must be provided if the bet type is set to 'system' stake: 2.00 }] } ``` Here you can see, that we are setting stakes for three bet types. You can use any of the betting options returned by the `getSystems` method. A response, with the following object structure, will be served in the callback function: ```json { success: true, errors: [], data: { bets: [{ ticketId: '56e7ffcc60b2d65423c933e5', // id of the betting ticket betType: "single" // bet type systemType: undefined // system type status: "placed" // ticket status }, { ticketId: '56e7ffcc60b2d65423c933e5', // id of the betting ticket betType: "multibet" systemType: undefined status: "placed" }, { ticketId: '56e7ffcc60b2d65423c933e5', // id of the betting ticket betType: "system" systemType: 3 status: "placed" }] } } ``` Example usage: ```javascript var tickets = { currencyCode: 'eur', bets: [{ betType: 'single', stake: 1.00 }, { betType: 'multibet', stake: 1.50 }, { betType: 'system', systemType: 3, stake: 2.00 }] }; instance.placeTickets(tickets, function(response) { if (response.success) { for (var i = 0; i < response.data.bets.length; i++) { var bet = response.data.bets[i]; console.log(bet.status === 'placed' ? 'Bet placed' : 'Bet place failed', bet); } console.log('Ticket placed.', response.data); } }); ``` {% hint style="warning" %} **IMPORTANT**: In the placement phase, it can happen, that two of the total three bets get successfully placed and the third one fails due to, for example, insufficient funds. It is important to always check the status of all bets in the placement response. {% endhint %} Here is the list of possible statuses:

Status	Description
placed	Ticket placed.
rejected_basic_validation	Ticket rejected - e.g. invalid #lines, missing fields, bet stake limits, etc.
rejected_calc_validation	Ticket rejected - single / multi / system calculation failed.
rejected_risk_validation	Ticket rejected - risk / liability threshold breached.
rejected_market_validation	Ticket rejected - e.g. markets closed, prices changed.
rejected_insufficient_funds	Ticket rejected - stake failed.
rejected_user_is_disabled	User account is disabled.
rejected_user_not_authenticated	User is not authenticated.
rejected_user_not_authorized	User is not authorized.
rejected_user_session_expired	User session has expired.
rejected_user_blocked	User is blocked.
rejected_risk_user_identified	Risk user identified.
internal_error	Internal system error while processing a ticket.
external_error	External / Integrations system error while processing a ticket.

### RGS errors The requests that communicate with the RGS server for ticket validation and placement will always have the response structured in the following way: ```json { success: true, // wether the response was executed without errors errors: [], // the list of errors data: {} // data object } ``` Possible requests are: * `getUserAccountInfo` * `getLimits` * `getSystems` * `validateTickets` * `placeTickets` If the `success` property is set to `false`, the list of errors will be written in the `errors` property. Each error contains an error code, an error message and a `selectionId` if the error is related to a specific betting selection. Example: ```json { success: true, errors: [{ errorCode: 1001, // error code errorMessage: "Authentication failed.", // error description selectionId: undefined // selection id if the error is related to the particular line in the betslip }], data: {} } ``` Possible error codes are:

Code	Description
1001	User is not authenticated.
1002	No bets were selected.
1003	No bets were provided to the validate or place bets function.
1004	Unknown bet type sent to validate or place bets function.
10001	Missing currency code.
10002	Invalid or unsupported currency.
10003	Bet stake is too low.
10004	Bet stake is too high.
10005	The win for the single bet type is too high.
10006	The win for the system bet type is too high.
10007	Insufficient balance.
10008	Too few lines in the betting ticket.
10009	Too many lines per betting ticket.

--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.sportradar.com/games/virtual-sports/virtual-sports-via-unified-odds-feed-uof/frontend-integration/mobile-integration/virtual-sports-suite-for-mobile-integration.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.