BRINOVS blocks: Stake management (10 to 13)

Stake management (blocks 10 to 13)

The stake is the money you put on one contract. The four blocks in this section work out a stake from what has already happened: your finished rounds, your balance, or how much the market is moving. They are value blocks, so each one gives back a number. You find them in the Blocks menu under BRINOVS, in the sub-folder "Stake management" (soft violet). The usual place is the Stake box of the Trade options inside "1. Trade parameters"; the bot asks the block for the next stake each time it needs one. You can also put one block inside another, for example a Stake plan inside a Stake percent cap. None of these blocks makes a win more likely, and raising a stake after a loss can empty an account quickly.

The blocks

Stake plan

• Kind: BRINOVS custom, block #10
• Type id: bnv_stake_plan
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted. It is made for the Stake box of the Trade options in "1. Trade parameters".
• What it does: Gives the next stake, worked out from your finished rounds. It can keep the stake fixed, or raise it after each loss by a step, by a multiplier or along your own list. A maximum stake is required.
• Inputs:
  • Stake plan: base stake: the starting stake (toolbox starts at 1).
  • mode: "fixed" (first choice), "add a step after a loss", "multiply after a loss" or "custom sequence".
  • step or multiplier: the amount added, or the number multiplied by, after each loss (starts at 2).
  • custom sequence: your own list of stakes, typed with commas (starts as 1, 2, 4, 8). Used only in custom mode.
  • max steps: how many raises are allowed, a whole number from 1 to 50 (starts at 4).
  • MAX STAKE (required): the hard cap, a number above 0 (starts at 16).
  • go back to the base stake: "after a win" (first choice), "only after max steps" or "by hand (Resume ticket)".
  • Resume ticket: a whole number, 0 or more (starts at 0).
• Gives back: The next stake, as a number, never above MAX STAKE.
• How it works: A round is one purchase; a hedge or a multi-contract purchase counts as one round with its profits added up. A loss moves one step up. A loss at the last step goes back to the base stake. A win goes back to the base stake only if you chose "after a win". A round that ends at exactly 0 changes nothing. To restart by hand, raise the Resume ticket above its old value.
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Stake: [ USD ▾ ] ( Stake plan: base stake (1)              │
│  mode [ multiply after a loss ▾ ]  step or multiplier (2)  │
│  max steps (4)  MAX STAKE (required) (16) )                │
└────────────────────────────────────────────────────────────┘

After losses the stakes run 1, 2, 4, 8, 16. A loss at 16 goes back to 1, and with the first "go back" choice a win does too. The tooltip shows the worst case, 16.

• Good to know:
  • It refuses and stops the bot without a MAX STAKE, if the base stake is above it, or if a custom sequence has a number above it or fewer than 2 numbers.
  • Once the block has run, its MAX STAKE is enforced on every real purchase even if you delete the block: a larger stake is refused. A pretend (dry run) purchase is not stopped and has its own step count.
  • It needs the execution layer. Multiply modes can empty an account quickly, so pick a cap you can afford to lose.

Stake percent cap

• Kind: BRINOVS custom, block #11
• Type id: bnv_stake_percent_cap
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted, usually the Stake box of the Trade options in "1. Trade parameters". It can wrap a Stake plan.
• What it does: Keeps a stake from being bigger than a percentage of your balance, and never above your ceiling. It asks Deriv for a fresh balance every time it works out a stake.
• Inputs:
  • Stake percent cap: stake: the stake to check, a number above 0 (starts at 1).
  • at most ... % of the balance: above 0 and at most 100 (starts at 5).
  • balance to use: "at the start of this run" (first choice) or "now".
  • floor: the smallest stake you accept, 0 or more (starts at 0.35).
  • ceiling: the biggest stake you accept, above 0 (starts at 100).
• Gives back: An approved stake: the smaller of your stake, the percentage of the balance and the ceiling, rounded down to cents.
• How it works: "At the start of this run" uses the first fresh balance the bot saw in this run. "now" uses the balance at that moment. If the stake is cut, the journal says so. If the cap comes out below your floor, the bot stops instead of raising the stake.
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Stake: [ USD ▾ ] ( Stake percent cap: stake (8)            │
│    at most (5) % of the balance                            │
│    balance [ at the start of this run ▾ ]                  │
│    floor (0.35)  ceiling (100) )                           │
└────────────────────────────────────────────────────────────┘

With a starting balance of 100, 5% is 5. The stake of 8 is cut to 5.

• Good to know:
  • The bot stops with the reason if the balance is unknown, zero, older than 60 seconds, or in a different currency than the trade.
  • It also stops if the floor is above the ceiling, or the cap is below the floor.
  • It checks only a stake that goes through this block. Unlike the Stake plan cap, it is not enforced on every purchase.

Volatility-scaled stake (experimental)

• Kind: BRINOVS custom, block #12
• Type id: bnv_volatility_stake
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted, usually the Stake box of the Trade options in "1. Trade parameters".
• What it does: Makes the stake smaller when the market moves more than usual and bigger when it is calm, always between your floor and your ceiling. Volatility means how much the price jumps around.
• Inputs:
  • EXPERIMENTAL Volatility-scaled stake: base stake: a number above 0 (starts at 1).
  • compare the last ... ticks: a whole number from 10 to 200 (starts at 50).
  • rule: "full (stake x usual / now)" (first choice) or "gentle (square root of that)".
  • floor: the smallest stake, 0 or more (starts at 0.35).
  • ceiling: the biggest stake, above 0 (starts at 5).
• Gives back: The scaled stake as a number, between the floor and the ceiling, rounded down to cents.
• How it works: "Usual" is the average size of a tick move over the last 1000 ticks of the traded market. "Now" is the same measure over the last ticks you choose. Full means base stake x usual / now. Gentle means base stake x the square root of that.
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Stake: [ USD ▾ ] ( EXPERIMENTAL Volatility-scaled stake:   │
│    base stake (1)  compare the last (50) ticks             │
│    rule [ full (stake x usual / now) ▾ ]                   │
│    floor (0.35)  ceiling (5) )                             │
└────────────────────────────────────────────────────────────┘

If the market moves twice as much as usual, the stake becomes 0.5. If it is half as lively as usual, the stake becomes 2.

• Good to know:
  • It is experimental. The bot stops with the reason if the price history cannot be read, has fewer than 100 prices, or did not move at all.
  • A bigger stake in calm periods is a bigger risk. Set a ceiling you can afford.
  • It does not make a win more likely.

Position size (experimental)

• Kind: BRINOVS custom, block #13
• Type id: bnv_position_size
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted.
• What it does: A calculator for multiplier-style trades with a stop loss and a take profit. It is not useful for digit contracts. It only does arithmetic and buys nothing.
• Inputs:
  • EXPERIMENTAL Position size: capital: your money for the trade (starts at 1000).
  • risk ... % of it: the share of the capital you risk, above 0 and at most 100 (starts at 1).
  • entry: the entry price (starts at 100).
  • stop loss: the price where you give up (starts at 99).
  • take profit: the price where you take the win (starts at 102).
  • give me: "the position size" (first choice), "the risk / reward ratio" or "the amount at risk".
• Gives back: A number. The amount at risk is capital x risk share. The position size is that amount divided by the distance from the entry to the stop loss. The ratio is the distance to the take profit divided by the distance to the stop loss.
• How it works: It calculates and returns a number straight away. It does not look at the market. The position size is rounded down to 4 decimals, the amount at risk to cents and the ratio to 2 decimals.
• Example:

┌─ 1. Trade parameters ──────────────────────────────────────┐
│ Run once at start:                                         │
│   set [ size ▾ ] to                                        │
│     ( EXPERIMENTAL Position size: capital (1000)           │
│       risk (1) % of it  entry (100)  stop loss (99)        │
│       take profit (102)  give me [ the position size ▾ ] ) │
└────────────────────────────────────────────────────────────┘

The amount at risk is 10 and the stop loss is 1 away from the entry, so the size is 10. The ratio would be 2 and the amount at risk 10.

• Good to know:
  • The stop loss and the take profit must be on opposite sides of the entry, and neither can equal it, or the bot stops with the reason.
  • The entry, the stop loss and the take profit must all be prices above 0.
  • It is only arithmetic. It does not make a win more likely.