BRINOVS blocks: Execution and purchasing (1 to 9)

What are BRINOVS blocks?

BRINOVS blocks are extra blocks that sit on top of Deriv's own Bot Builder. You find them in the Blocks menu, in one folder called BRINOVS. That folder has 12 sub-folders and 51 blocks in all. Together they add safer buying, several contracts at once, stake plans, trading limits, entry filters, analysis tools and licensing to the blocks Deriv already gives you. Every BRINOVS folder has its own soft colour, so you can tell them from Deriv's pale grey blocks. On a BRINOVS block you can also use the menu (right-click on a computer, long press on a phone) to Disable Block or Enable Block.

Under the blocks there is a working part called the BRINOVS execution layer. Every purchase made by the normal Purchase block, by Multi purchase or by Hedge purchase passes through it. Before anything is sent to Deriv, the layer checks your safety rules: the connection is ready, your limits, your balance and your price ceiling. The blocks only set the numbers for these rules. The last numbers a block saved stay in force even if you later delete that block, and a rule that is set up but cannot decide says no. A pretend purchase (see Dry run mode) skips the money rules, because no money moves. No BRINOVS block makes a win more likely, and none of them promises profit.

Some words used in this guide. A contract is one bet on a market: you pick a type, a length of time and a stake. The stake is the money you put on one contract. The payout is the total Deriv gives back if the contract wins. A tick is one price update from the market. A barrier is the digit or price level a contract is measured against, for example the 1 in "Over 1". A proposal (also called an offer or a quote) is the live price Deriv shows before you buy. The journal is the message panel where the bot writes what it does.

Execution and purchasing (blocks 1 to 9)

These blocks are about the moment of buying. You find them in the Blocks menu under BRINOVS, in the sub-folder "Execution and purchasing" (soft teal). In a bot they work in this order. Three switch blocks (Dry run mode, Hedge toggle, Buy price ceiling) go in "Run once at start" of "1. Trade parameters". Then, in "2. Purchase conditions", the check blocks (Minimum payout gate, Quote freshness gate, Contract compatibility gate) decide if the bot may buy, and Multi purchase or Hedge purchase does the buying. After the contracts finish, Batch result lets you read what happened.

The blocks

Multi purchase

• Kind: BRINOVS custom, block #1
• Type id: bnv_multi_purchase
• Shape: Action block (it ends the stack, like Purchase: no block can go under it)
• Where it goes: Inside "2. Purchase conditions", usually under an if. One per stack, in place of the Purchase block.
• What it does: Buys 2 to 10 contracts of the same type in one go, one after the other, with a pause you choose. It uses the market, duration, stake and prediction from your Trade options. Every contract is checked by your safety rules first and tracked on its own.
• Inputs:
  • Contract type: a dropdown filled from your Trade parameters, like Purchase.
  • contracts: a whole number from 2 to 10 (toolbox starts at 2).
  • stagger ms: a pause between contracts, 0 to 1000 (starts at 0).
  • max total stake: the most the whole batch may cost (starts at 10).
  • on failure: "stop the batch" (first choice) or "continue".
• How it works: The bot waits up to 30 seconds until it is connected and ready, then sends the contracts through the execution layer. The first contract bought becomes the one the normal bot flow follows. The bot moves on to the sell and restart steps only when every contract of the batch has finished. Each result is added to the totals.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ if  < Balance is at least (2) x the next stake >           │
│ then  Multi purchase [ Over ▾ ]                            │
│         contracts (3)  stagger (200) ms                    │
│         max total stake (10)                               │
│         on failure [ stop the batch ▾ ]                    │
└────────────────────────────────────────────────────────────┘

If the balance check is true, the bot buys 3 Over contracts, 200 ms apart. The total (3 x the stake) must be 10 or less.

• Good to know:
  • It refuses and stops the bot (nothing is bought) if contracts x stake is above the max total stake, a box is empty or out of range, the Trade options use Payout instead of Stake, the contract has no duration, or a safety rule says no.
  • "stop the batch" holds back the later contracts only when the stagger is above 0. With stagger 0 all contracts are sent together.
  • If no contract at all can be bought, the bot stops with the reason and does not retry. Known limit: the Transactions panel lists only the first contract (every contract has a journal line), and Sell at market sells only the first.
  • More contracts do not make winning more likely: they multiply the money at risk.

Hedge purchase

• Kind: BRINOVS custom, block #2
• Type id: bnv_hedge_purchase
• Shape: Action block (it ends the stack, like Purchase)
• Where it goes: Inside "2. Purchase conditions", usually under an if. One per stack.
• What it does: Buys 2 to 10 different contracts at the same moment (leg A, leg B, and more with the + button). Each leg has its own contract type, barrier and stake. Before buying, the journal shows the net result of every outcome, worked out from the real payouts.
• Inputs:
  • Leg A, Leg B (and up to Leg J): the contract type for each leg, filled from Trade parameters. A new leg starts with the next choice in the list.
  • barrier (each leg): the digit or price level. Empty means the prediction of your Trade options. Even and Odd take no barrier.
  • stake (each leg): a number (toolbox starts both legs at 1). From leg B on, a dropdown picks "amount" or "ratio of A" (a multiple of leg A's stake).
  • if a leg is not bought: "keep the bought legs" (first choice) or "sell the bought legs".
  • + and - buttons: add or remove the last leg (2 to 10 legs).
• How it works: All legs are sent at once through the execution layer, which checks all the stakes together. First the bot asks Deriv for one live price per leg and prints the outcome table. If only some legs are bought you are UNHEDGED: the journal warns you and, if you chose "sell", the bot tries to sell the bought legs (many contracts cannot be sold early).
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ then  Hedge purchase                                       │
│   Leg A [ Over ▾ ]  barrier (1)  stake (1)                 │
│   Leg B [ Under ▾ ] barrier (8)  stake (1) [ amount ▾ ]    │
│   if a leg is not bought [ keep the bought legs ▾ ]        │
└────────────────────────────────────────────────────────────┘

The bot buys Over 1 and Under 8 together, 1 each. The journal first shows what each last digit would net.

• Good to know:
  • A hedge is not a safe bet. A win pays back less than the stake, so a round where only some legs win can still lose money.
  • It refuses and stops the bot if a stake is not above 0, a digit is out of range (Over 0 to 8, Under 1 to 9, Matches and Differs 0 to 9), a type is not picked, the Trade options use Payout, or a safety rule says no.
  • The outcome table only applies the contract rules. It does not say which outcome is likely. If a price cannot be read, no numbers are shown but the hedge is still placed.

Hedge toggle

• Kind: BRINOVS custom, block #3
• Type id: bnv_hedge_toggle
• Shape: Action block (it can have blocks above and below)
• Where it goes: In "Run once at start" of "1. Trade parameters". One is enough.
• What it does: One switch that turns every Purchase block into a hedge. While it is ON, each Purchase buys the contract and also its opposite, with the same stake, duration and prediction from your Trade options. This doubles the money you put in.
• Inputs:
  • mode: "ON (buy the opposite too)" (first choice) or "OFF (one contract)".
• How it works: The bot looks up the opposite of the contract in a fixed list: Even/Odd, Over/Under, Match/Differ, Rise/Fall, Higher/Lower, Only Ups/Only Downs, Touch/No Touch, Ends Between/Ends Outside, Stays Between/Goes Outside. It then buys both through the same path as Hedge purchase, with the same price preview and UNHEDGED warning (the bought leg is kept).
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Hedge toggle [ ON (buy the opposite too) ▾ ]             │
└────────────────────────────────────────────────────────────┘

Now a Purchase [ Even ▾ ] buys Even and Odd together, each with your stake.

• Good to know:
  • If the contract has no opposite in the list, the bot stops with a message instead of guessing. Switch the toggle OFF to buy it alone.
  • Some pairs can lose on both sides: Over and Under on the same digit both lose when that digit comes up, and Rise and Fall both lose on an unchanged price. The preview table shows this.
  • A hedge is not a safe bet: buying both sides costs money on average.
  • It needs the execution layer. If the layer is off, the block stops the bot instead of buying one side only.

Batch result

• Kind: BRINOVS custom, block #4
• Type id: bnv_batch_result
• Shape: Value block (gives a number, text or list)
• Where it goes: Anywhere a value is wanted. It is made for "3. Sell conditions" and "4. Restart trading conditions". It can be used many times.
• What it does: Reads one number or word about the latest Multi purchase or Hedge purchase. It lets your after-purchase logic see the combined result of all the contracts, which the normal single-contract blocks cannot do.
• Inputs:
  • field: requested (first choice), confirmed, failed, stake committed, net profit, status, contract id list.
• Gives back: requested, confirmed, failed and stake committed are numbers. net profit is a number, but not a number until every contract has finished. status is one of none, complete, partial, failed, denied or unknown. contract id list is a list. With no batch yet you get 0, none or an empty list.
• How it works: The execution layer keeps the result of the latest batch. This block only reads it. "failed" counts contracts that Deriv or the bot refused; contracts that were never sent because the batch stopped are not counted as failed.
• Example:

┌─ 4. Restart trading conditions ────────────────────────────┐
│ if  < ( Batch result [ confirmed ▾ ] ) < ( 3 ) >           │
│ then  Trade again                                          │
└────────────────────────────────────────────────────────────┘

If fewer than 3 contracts of the last batch were bought, the bot starts a new round.

• Good to know:
  • It describes what already happened. It does not predict the next result.
  • Partial results are normal: some contracts of a batch can fail while others are bought. Check "status" for "partial".
  • Compare net profit only after the contracts finish; before that it is not a number and every comparison with it is false.

Dry run mode

• Kind: BRINOVS custom, block #5
• Type id: bnv_dry_run_mode
• Shape: Action block (it can have blocks above and below)
• Where it goes: In "Run once at start" of "1. Trade parameters". One is enough.
• What it does: A free practice switch. While it is ON, every purchase of the bot (Purchase, Multi purchase, Hedge purchase) is only pretended. Nothing is bought and no money moves. Prices and payouts are real, and each pretend contract is settled from the real ticks.
• Inputs:
  • mode: "ON (nothing is bought)" (first choice) or "OFF (real purchases)".
• How it works: The bot still asks Deriv for the real price, so a closed market or a bad contract fails just like a real buy. The pretend contract then ends on the real ticks, so restart conditions, stake plans and totals behave as in a real run. Pretend contracts have a negative number in the journal.
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Dry run [ ON (nothing is bought) ▾ ]                     │
└────────────────────────────────────────────────────────────┘

The bot trades as normal, but nothing is bought and your balance does not change. The journal says DRY-RUN is ON.

• Good to know:
  • Only digit contracts (Even, Odd, Over, Under, Matches, Differs) and Rise/Fall (including the "or equal" types) can be pretended. Anything else stops the bot with a plain message.
  • Without this block, or with OFF, purchases are real. Check the first journal lines: they say whether dry run is ON or OFF.
  • Pretend results are not real money and are not a promise of real results. It needs the execution layer; without it the bot stops instead of buying for real.

Minimum payout gate

• Kind: BRINOVS custom, block #6
• Type id: bnv_min_payout_gate (its helper block "Return ratio" is bnv_min_payout_gate_ratio)
• Shape: True/false block
• Where it goes: Anywhere a true/false block is wanted, usually in an if in "2. Purchase conditions".
• What it does: Says true when the live offer for the contract pays at least the minimum you set. Use it to skip offers that pay too little.
• Inputs:
  • Contract type: a dropdown filled from Trade parameters.
  • returns at least: a number (toolbox starts at 0.8). 0.8 means a win returns 80% of the stake as profit.
• Gives back: True when (payout - stake) / stake of the live offer is at least your number. False when it pays less, or when there is no readable offer.
• How it works: It looks at the offer the bot already holds for this purchase cycle and makes no new request. The companion value block "Return ratio" gives the same calculated number itself (not a number when there is no offer). A bot that uses either block asks Deriv for live offers.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ if  < Payout of [ Over ▾ ] returns at least (0.8) >        │
│ then  Purchase [ Over ▾ ]                                  │
└────────────────────────────────────────────────────────────┘

The bot buys Over only when the live offer returns at least 80% of the stake as profit.

• Good to know:
  • An empty or non-number box stops the bot with a message.
  • A higher payout does not mean a higher chance to win. Do not treat it as a quality signal.
  • Unknown means false: with no readable offer the gate blocks.

Quote freshness gate

• Kind: BRINOVS custom, block #7
• Type id: bnv_quote_freshness_gate
• Shape: True/false block
• Where it goes: Anywhere a true/false block is wanted, usually in an if in "2. Purchase conditions".
• What it does: Says true when the last tick and the live offer are recent enough. It stops the bot from buying on old data after a lag or a lost connection.
• Inputs:
  • tick not older than ... ms: a number (toolbox starts at 3000).
  • offer not older than ... ms: a number (toolbox starts at 5000).
  • if unknown: "block" (first choice) or "allow".
• Gives back: True when both are fresh. False when either is too old, or when an age cannot be known (for example right after the start), unless you chose "allow".
• How it works: For ticks the bot checks when the tick arrived and also how late it was compared with its own time, against the usual delay. For the offer it checks the time since its last update from Deriv.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ if  < Quotes are fresh                                     │
│       tick not older than (3000) ms                        │
│       offer not older than (5000) ms                       │
│       if unknown [ block ▾ ] >                             │
│ then  Purchase [ Over ▾ ]                                  │
└────────────────────────────────────────────────────────────┘

The bot buys only when the last tick is under 3 seconds old and the offer under 5 seconds old.

• Good to know:
  • Both ages must be numbers above 0, or the bot stops with a message.
  • Keep "block" as the choice unless you have a reason: it is the safe default.
  • It checks how fresh the data is. It says nothing about the chance to win.

Contract compatibility gate

• Kind: BRINOVS custom, block #8
• Type id: bnv_contract_compat_gate
• Shape: True/false block
• Where it goes: Anywhere a true/false block is wanted, usually in an if just before Purchase.
• What it does: Says true only when Deriv's live list for this market offers the contract you are about to buy. It checks the contract type, the duration and its unit, and the prediction digit or barrier from your Trade options.
• Inputs:
  • Contract type: a dropdown filled from Trade parameters ("... is offered now").
• Gives back: True when the contract is offered. False when it is not, or when anything is unclear (no answer in about 8 seconds, an empty list, a duration or barrier it cannot read).
• How it works: The bot asks Deriv for the live list of contracts for the market (it shares one answer for 5 seconds, so a loop cannot flood Deriv). When the answer is false, the journal says why, once for each reason. It never swaps to a different contract.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────────┐
│ if  < [ Over ▾ ] is offered now >                          │
│ then  Purchase [ Over ▾ ]                                  │
└────────────────────────────────────────────────────────────┘

The bot buys Over only when Deriv currently offers Over with your duration and prediction.

• Good to know:
  • It only checks that the contract exists. It says nothing about the chance to win.
  • Unclear means false, so a slow or missing answer from Deriv blocks the purchase.
  • Use it to avoid repeated refused buys, for example a duration the market does not offer.

Buy price ceiling

• Kind: BRINOVS custom, block #9
• Type id: bnv_buy_price_ceiling
• Shape: Action block (it can have blocks above and below)
• Where it goes: In "Run once at start" of "1. Trade parameters". One is enough.
• What it does: Sets the most the bot will ever pay for one contract. Before every purchase (Purchase, Multi purchase, Hedge purchase) the bot checks the price. If it is above your number, nothing is bought and the bot stops with the reason.
• Inputs:
  • Buy price ceiling: a number above 0, in your account currency (toolbox starts at 10).
• How it works: The ceiling is one of the safety rules in the execution layer. A buy request is only sent to Deriv when its price is at or below the ceiling. In Multi purchase and Hedge purchase each contract is checked on its own.
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   Buy price ceiling (10)                                   │
└────────────────────────────────────────────────────────────┘

A contract that would cost 12 is refused and the bot stops with a message. A contract that costs 10 or less goes through.

• Good to know:
  • Without this block there is no ceiling.
  • A price the bot cannot read (for example a payout-based contract with no live offer) is also refused.
  • It needs the execution layer. If the layer is off, the block stops the bot instead of looking protected.
  • It protects your money. It does not change your chance of winning.