Eigener Baustein

Fehlt dir ein Baustein, baust du ihn selbst. Ein eigener Baustein hat Eingänge links auf der Karte, Einstellungen, die du auf dem Board änderst, und Ausgänge rechts, jeder mit einer Formel. Code schreibst du dabei nicht: Die Formel ist eine Rechnung wie ema(price, 20) oder rsi(price, 14) < 30.

Eigene Bausteine rechnen genau wie die offiziellen: im Test wie im Livebetrieb gleich und nie mit Kursen aus der Zukunft. Sie stehen in der Bausteinleiste unter Eigene Bausteine, lassen sich wie jeder andere Baustein verbinden und als Datei weitergeben.

Eigene Bausteine gibt es ab Pro. Mit Free baust du sie trotzdem und testest sie im Replay; aktivieren lässt sich eine Chain mit eigenem Baustein erst mit Pro, siehe Pläne.

In sechs Schritten

1. Öffne rechts die Bausteinleiste und klick unter Eigene Bausteine auf Neuer Baustein.

2. Wähl ein Beispiel, etwa Abstand zum EMA, oder Leer anfangen. Ein Beispiel ist der schnellste Weg: Es ist fertig und lässt sich anpassen.

3. Gib dem Baustein unter Name und Aussehen einen Namen, eine Kurzbeschreibung für die Leiste und ein Icon.

4. Leg die Eingänge an. Jeder hat einen Namen, der auf der Karte steht, und eine Art: Kursreihe (etwa der Kurs einer Kerze), Zahl (etwa ein RSI oder das Volumen) oder Signal (wahr oder falsch). Das Feld daneben in Farbe, etwa price, ist der Name in den Formeln.

5. Leg Einstellungen an, wenn sich etwas auf dem Board ändern lassen soll, etwa die Zahl der Kerzen mit Standard 20, von 2 bis 500.

6. Leg die Ausgänge an und schreib zu jedem die Formel. Namen und Funktionen fügst du mit einem Klick ein. Rechts siehst du, wie die Karte auf dem Board aussieht, und einen Probelauf über 500 Stunden BTC/USDT. Mit Speichern und aufs Board liegt der Baustein auf dem Board und steht ab jetzt unter Eigene Bausteine.

Tipp

Fehler stehen rot direkt am Feld, und die Stelle in der Formel ist markiert, etwa bei emaa(price, 20) mit dem Hinweis „Gemeint ist vielleicht ema(…)“. Speichern geht erst, wenn alles stimmt. Gelbe Hinweise, etwa ein Eingang, den keine Formel liest, verhindern nichts.

Formeln schreiben

Eine Formel rechnet an jeder Kerze. price - ema(price, 20) ergibt an jeder Kerze den Abstand des Kurses zu seinem EMA 20. Was du brauchst:

So schreibst du es	Bedeutung
+ - * / % ^	rechnen; ×, ÷ und − gehen auch
> < >= <= == !=	vergleichen; das Ergebnis ist ein Signal
and, or, not	Signale verknüpfen, auch und, oder, nicht
bedingung ? a : b	je Kerze a oder b, etwa close > open ? high : low
price[1]	der Wert eine Kerze vorher, price[4] vier Kerzen vorher
1.5, 0.02	Dezimalzahlen mit Punkt

Gut zu wissen:

• Ausgang Signal: Die Formel muss wahr oder falsch ergeben, also meist einen Vergleich enthalten, etwa rsi(price, 14) < 30.
• Längen sind feste Werte: eine Zahl, eine Einstellung oder eine Rechnung daraus, etwa ema(price, length * 2). Erlaubt sind 1 bis 1.000 Kerzen. Eine Einstellung, die als Länge dient, braucht deshalb einen Mindest- und einen Höchstwert.
• Spätere Ausgänge lesen frühere: Bei den RSI-Zonen rechnet der erste Ausgang value = rsi(price, length), die beiden nächsten vergleichen nur noch value < low und value > high.
• Leere Werte am Anfang: Ein EMA 200 hat erst nach 200 Kerzen einen Wert. Davor ist das Ergebnis leer und jedes Signal falsch. Das Replay lädt diese Kerzen vorher mit, du merkst davon nichts. nz(wert, 0) setzt bei Bedarf eine Zahl ein.

Alle Funktionen

Funktionen schreibst du klein, EMA geht auch. Im Editor findest du dieselbe Liste unter Funktionen am Formelfeld.

Durchschnitte

Funktion	Was sie tut	Beispiel
sma(Wert, Kerzen)	Einfacher Durchschnitt: jede Kerze zählt gleich.	sma(price, 50)
ema(Wert, Kerzen)	Exponentieller Durchschnitt: neue Kerzen zählen mehr.	ema(price, 200)
wma(Wert, Kerzen)	Gewichteter Durchschnitt: das Gewicht nimmt gleichmäßig ab.	wma(price, 20)
rma(Wert, Kerzen)	Geglätteter Durchschnitt nach Wilder, wie im RSI und in der ATR.	rma(price, 14)
hma(Wert, Kerzen)	Hull-Durchschnitt: schnell und trotzdem glatt.	hma(price, 21)

Indikatoren

Funktion	Was sie tut	Beispiel
rsi(Wert, Kerzen)	Relative Stärke von 0 bis 100.	rsi(price, 14) < 30
stdev(Wert, Kerzen)	Standardabweichung: wie stark der Wert schwankt.	stdev(price, 20)
highest(Wert, Kerzen)	Höchster Wert der letzten Kerzen, die aktuelle eingeschlossen.	price > highest(price, 20)[1]
lowest(Wert, Kerzen)	Tiefster Wert der letzten Kerzen, die aktuelle eingeschlossen.	lowest(price, 20)
sum(Wert, Kerzen)	Summe der letzten Kerzen.	sum(volume, 24)
change(Wert, Kerzen = 1)	Unterschied zum Wert vor so vielen Kerzen.	change(price, 4)
roc(Wert, Kerzen = 1)	Veränderung in Prozent gegenüber dem Wert vor so vielen Kerzen.	roc(price, 24) < -5
prev(Wert, Kerzen = 1)	Der Wert vor so vielen Kerzen. Kurz: Wert[1].	price > prev(price)
atr(Hoch, Tief, Schluss, Kerzen)	Durchschnittliche Schwankungsbreite einer Kerze, Average True Range.	atr(high, low, close, 14)
tr(Hoch, Tief, Schluss)	Spanne einer Kerze samt Lücke zum Schluss davor, True Range.	tr(high, low, close)
stoch(Wert, Hoch, Tief, Kerzen)	Wo der Wert in der Spanne der letzten Kerzen liegt, von 0 (tiefstes Tief) bis 100 (höchstes Hoch); leer, wenn Hoch und Tief gleich sind.	sma(stoch(close, high, low, 14), 3) < 20
cci(Wert, Kerzen)	Abstand vom Durchschnitt im Verhältnis zur mittleren Abweichung; über 100 ungewöhnlich stark, unter −100 ungewöhnlich schwach.	cci((high + low + close) / 3, 20) > 100
dev(Wert, Kerzen)	Mittlere Abweichung der letzten Werte von ihrem Durchschnitt.	dev(price, 20)
wpr(Hoch, Tief, Schluss, Kerzen)	Williams %R von −100 (Schluss am tiefsten Tief) bis 0 (am höchsten Hoch) der letzten Kerzen; leer, wenn Hoch und Tief gleich sind.	wpr(high, low, close, 14) < -80
mfi(Wert, Volumen, Kerzen)	Money Flow Index von 0 bis 100: wie der RSI, aber nach Volumen gewichtet; unter 20 gilt als überverkauft.	mfi((high + low + close) / 3, volume, 14) < 20
adx(Hoch, Tief, Schluss, Kerzen, Glättung = Kerzen)	Trendstärke von 0 bis 100, egal in welche Richtung; über 25 gilt als starker Trend.	adx(high, low, close, 14) > 25
diplus(Hoch, Tief, Schluss, Kerzen)	Stärke der Bewegung nach oben (+DI) von 0 bis 100.	diplus(high, low, close, 14) > diminus(high, low, close, 14)
diminus(Hoch, Tief, Schluss, Kerzen)	Stärke der Bewegung nach unten (−DI) von 0 bis 100.	crossover(diminus(high, low, close, 14), diplus(high, low, close, 14))
linreg(Wert, Kerzen, zurück = 0)	Lineare Regression: der Wert der Ausgleichsgeraden durch die letzten Kerzen, an der aktuellen oder so viele Kerzen davor.	linreg(price, 20) > linreg(price, 20)[1]
highestbars(Wert, Kerzen)	Wie viele Kerzen der höchste Wert der letzten Kerzen zurückliegt, 0 an der aktuellen; bei gleichen Werten zählt der jüngste.	100 * (14 - highestbars(high, 15)) / 14
lowestbars(Wert, Kerzen)	Wie viele Kerzen der tiefste Wert der letzten Kerzen zurückliegt, 0 an der aktuellen; bei gleichen Werten zählt der jüngste.	lowestbars(low, 20) == 0

Rechnen

Funktion	Was sie tut	Beispiel
abs(Wert)	Betrag: macht negative Zahlen positiv.	abs(change(price))
min(a, b, …)	Der kleinste der Werte.	min(open, close)
max(a, b, …)	Der größte der Werte.	max(open, close)
avg(a, b, …)	Durchschnitt der Werte an derselben Kerze.	avg(high, low, close)
sqrt(Wert)	Quadratwurzel; bei negativen Werten leer.	sqrt(abs(change(price)))
pow(Wert, Hochzahl)	Potenz, wie Wert ^ Hochzahl.	pow(change(price), 2)
log(Wert)	Natürlicher Logarithmus; bei 0 und negativen Werten leer.	log(price / prev(price))
exp(Wert)	e hoch Wert.	exp(1)
round(Wert, Stellen = 0)	Rundet auf so viele Nachkommastellen.	round(rsi(price, 14), 1)
floor(Wert)	Rundet ab auf eine ganze Zahl.	floor(price / 1000) * 1000
ceil(Wert)	Rundet auf auf eine ganze Zahl.	ceil(price / 1000) * 1000
sign(Wert)	1 bei positiven, -1 bei negativen Werten, sonst 0.	sign(change(price))
clamp(Wert, unten, oben)	Begrenzt den Wert auf einen Bereich.	clamp(rsi(price, 14), 20, 80)
nz(Wert, Ersatz = 0)	Setzt den Ersatz ein, solange der Wert noch leer ist, etwa im Vorlauf.	nz(volume)

Signale

Funktion	Was sie tut	Beispiel
crossover(a, b)	Wahr in der Kerze, in der a von unten über b steigt.	crossover(ema(price, 50), ema(price, 200))
crossunder(a, b)	Wahr in der Kerze, in der a von oben unter b fällt.	crossunder(price, sma(price, 200))
cross(a, b)	Wahr in der Kerze, in der a die Linie b in eine der beiden Richtungen kreuzt.	cross(price, 100000)
rising(Wert, Kerzen = 1)	Wahr, wenn der Wert höher ist als an jeder der Kerzen davor.	rising(volume, 3)
falling(Wert, Kerzen = 1)	Wahr, wenn der Wert tiefer ist als an jeder der Kerzen davor.	falling(price, 3)
holds(Signal, Kerzen)	Wahr, wenn das Signal so viele Kerzen in Folge wahr ist.	holds(price < ema(price, 200), 3)
count(Signal, Kerzen)	Wie oft das Signal in den letzten Kerzen wahr war.	count(close > open, 5) >= 4
barssince(Signal)	Kerzen, seit das Signal zuletzt wahr war; leer, solange es nie wahr war.	barssince(crossover(price, ema(price, 50))) <= 3
if(Bedingung, dann, sonst)	Wählt je Kerze einen von zwei Werten, wie Bedingung ? dann : sonst.	if(close > open, high, low)

Beispiele

Diese Beispiele stehen im Editor unter Neuer Baustein zur Auswahl. Das JSON kannst du auch kopieren und unter Importieren einfügen.

Abstand zum EMA

Wie weit der Kurs über oder unter seinem Durchschnitt liegt, in Prozent.

• Eingänge:Kurs (Kursreihe, price)
• Einstellungen:Kerzen length = 50
• Ausgänge:
  • Abstand (Zahl): (price - ema(price, length)) / ema(price, length) * 100

Als JSON zum Importieren

{
  "format": 1,
  "id": "custom.abstand-zum-ema",
  "version": "1.0.0",
  "label": {
    "de": "Abstand zum EMA",
    "en": "Distance to EMA"
  },
  "description": {
    "de": "Abstand des Kurses zum EMA in %",
    "en": "Distance of the price to the EMA in %"
  },
  "help": {
    "de": "Rechnet aus, wie viel Prozent der Kurs über (positiv) oder unter (negativ) seinem exponentiellen Durchschnitt liegt. Beispiel: Mit 50 Kerzen und „unter -8“ meldet sich ein Alarm, wenn der Kurs ungewöhnlich weit unter den Trend gefallen ist.",
    "en": "Calculates how many percent the price is above (positive) or below (negative) its exponential average. Example: with 50 candles and “below -8” an alert fires when the price has fallen unusually far below the trend."
  },
  "icon": "ruler",
  "sentence": {
    "de": "EMA {length}",
    "en": "EMA {length}"
  },
  "inputs": [
    {
      "id": "price",
      "type": "price",
      "label": {
        "de": "Kurs",
        "en": "Price"
      }
    }
  ],
  "settings": [
    {
      "id": "length",
      "label": {
        "de": "Kerzen",
        "en": "Candles"
      },
      "help": {
        "de": "Über wie viele Kerzen der EMA rechnet, etwa 50 oder 200.",
        "en": "How many candles the EMA covers, such as 50 or 200."
      },
      "default": 50,
      "min": 2,
      "max": 500,
      "integer": true
    }
  ],
  "outputs": [
    {
      "id": "out",
      "type": "number",
      "unit": "percent",
      "label": {
        "de": "Abstand",
        "en": "Distance"
      },
      "formula": "(price - ema(price, length)) / ema(price, length) * 100"
    }
  ]
}

RSI-Zonen

Zwei Signale aus einem Baustein: überverkauft und überkauft, mit eigenen Grenzen.

• Eingänge:Kurs (Kursreihe, price)
• Einstellungen:Kerzen length = 14, Unten low = 30, Oben high = 70
• Ausgänge:
  • RSI (Zahl): rsi(price, length)
  • überverkauft (Signal): value < low
  • überkauft (Signal): value > high

Als JSON zum Importieren

{
  "format": 1,
  "id": "custom.rsi-zonen",
  "version": "1.0.0",
  "label": {
    "de": "RSI-Zonen",
    "en": "RSI zones"
  },
  "description": {
    "de": "Überverkauft und überkauft als Signal",
    "en": "Oversold and overbought as signals"
  },
  "icon": "gauge",
  "sentence": {
    "de": "unter {low}, über {high}",
    "en": "below {low}, above {high}"
  },
  "inputs": [
    {
      "id": "price",
      "type": "price",
      "label": {
        "de": "Kurs",
        "en": "Price"
      }
    }
  ],
  "settings": [
    {
      "id": "length",
      "label": {
        "de": "Kerzen",
        "en": "Candles"
      },
      "default": 14,
      "min": 2,
      "max": 100,
      "integer": true
    },
    {
      "id": "low",
      "label": {
        "de": "Unten",
        "en": "Low"
      },
      "default": 30,
      "min": 0,
      "max": 100
    },
    {
      "id": "high",
      "label": {
        "de": "Oben",
        "en": "High"
      },
      "default": 70,
      "min": 0,
      "max": 100
    }
  ],
  "outputs": [
    {
      "id": "value",
      "type": "number",
      "label": {
        "de": "RSI",
        "en": "RSI"
      },
      "formula": "rsi(price, length)"
    },
    {
      "id": "oversold",
      "type": "signal",
      "label": {
        "de": "überverkauft",
        "en": "oversold"
      },
      "formula": "value < low"
    },
    {
      "id": "overbought",
      "type": "signal",
      "label": {
        "de": "überkauft",
        "en": "overbought"
      },
      "formula": "value > high"
    }
  ]
}

Golden Cross

Der schnelle Durchschnitt kreuzt den langsamen nach oben, klassisch 50 über 200.

• Eingänge:Kurs (Kursreihe, price)
• Einstellungen:Schnell fast = 50, Langsam slow = 200
• Ausgänge:
  • Kreuz (Signal): crossover(ema(price, fast), ema(price, slow))

Als JSON zum Importieren

{
  "format": 1,
  "id": "custom.golden-cross",
  "version": "1.0.0",
  "label": {
    "de": "Golden Cross",
    "en": "Golden cross"
  },
  "description": {
    "de": "Schneller EMA kreuzt langsamen nach oben",
    "en": "Fast EMA crosses above the slow one"
  },
  "icon": "trending-up",
  "sentence": {
    "de": "EMA {fast} über {slow}",
    "en": "EMA {fast} over {slow}"
  },
  "inputs": [
    {
      "id": "price",
      "type": "price",
      "label": {
        "de": "Kurs",
        "en": "Price"
      }
    }
  ],
  "settings": [
    {
      "id": "fast",
      "label": {
        "de": "Schnell",
        "en": "Fast"
      },
      "default": 50,
      "min": 2,
      "max": 500,
      "integer": true
    },
    {
      "id": "slow",
      "label": {
        "de": "Langsam",
        "en": "Slow"
      },
      "default": 200,
      "min": 2,
      "max": 500,
      "integer": true
    }
  ],
  "outputs": [
    {
      "id": "out",
      "type": "signal",
      "label": {
        "de": "Kreuz",
        "en": "Cross"
      },
      "formula": "crossover(ema(price, fast), ema(price, slow))"
    }
  ]
}

Volumen-Spitze

Eine Kerze mit einem Vielfachen des üblichen Volumens, etwa bei Nachrichten.

• Eingänge:Volumen (Zahl, volume)
• Einstellungen:Kerzen length = 20, Faktor factor = 2.5
• Ausgänge:
  • Spitze (Signal): volume > sma(volume, length) * factor

Als JSON zum Importieren

{
  "format": 1,
  "id": "custom.volumen-spitze",
  "version": "1.0.0",
  "label": {
    "de": "Volumen-Spitze",
    "en": "Volume spike"
  },
  "description": {
    "de": "Volumen über dem Vielfachen des Schnitts",
    "en": "Volume above a multiple of its average"
  },
  "icon": "chart-column",
  "sentence": {
    "de": "{factor} × Ø {length}",
    "en": "{factor} × avg {length}"
  },
  "inputs": [
    {
      "id": "volume",
      "type": "number",
      "label": {
        "de": "Volumen",
        "en": "Volume"
      }
    }
  ],
  "settings": [
    {
      "id": "length",
      "label": {
        "de": "Kerzen",
        "en": "Candles"
      },
      "default": 20,
      "min": 2,
      "max": 500,
      "integer": true
    },
    {
      "id": "factor",
      "label": {
        "de": "Faktor",
        "en": "Factor"
      },
      "default": 2.5,
      "min": 1,
      "max": 20,
      "step": 0.5
    }
  ],
  "outputs": [
    {
      "id": "out",
      "type": "signal",
      "label": {
        "de": "Spitze",
        "en": "Spike"
      },
      "formula": "volume > sma(volume, length) * factor"
    }
  ]
}

Kerzenkörper

Wie groß der Körper einer Kerze ist, in Prozent; große Körper zeigen starke Bewegungen.

• Eingänge:Eröffnung (Kursreihe, open), Schluss (Kursreihe, close)
• Einstellungen:keine
• Ausgänge:
  • Körper (Zahl): (close - open) / open * 100
  • grün (Signal): close > open

Als JSON zum Importieren

{
  "format": 1,
  "id": "custom.kerzenkoerper",
  "version": "1.0.0",
  "label": {
    "de": "Kerzenkörper",
    "en": "Candle body"
  },
  "description": {
    "de": "Größe des Kerzenkörpers in %",
    "en": "Size of the candle body in %"
  },
  "icon": "chart-candlestick",
  "inputs": [
    {
      "id": "open",
      "type": "price",
      "label": {
        "de": "Eröffnung",
        "en": "Open"
      }
    },
    {
      "id": "close",
      "type": "price",
      "label": {
        "de": "Schluss",
        "en": "Close"
      }
    }
  ],
  "outputs": [
    {
      "id": "body",
      "type": "number",
      "unit": "percent",
      "label": {
        "de": "Körper",
        "en": "Body"
      },
      "formula": "(close - open) / open * 100"
    },
    {
      "id": "green",
      "type": "signal",
      "label": {
        "de": "grün",
        "en": "green"
      },
      "formula": "close > open"
    }
  ]
}

Grüne Serie

Mehrere grüne Kerzen in Folge, ein Zeichen für anhaltenden Kaufdruck.

• Eingänge:Eröffnung (Kursreihe, open), Schluss (Kursreihe, close)
• Einstellungen:Kerzen length = 3
• Ausgänge:
  • Serie (Signal): holds(close > open, length)

Als JSON zum Importieren

{
  "format": 1,
  "id": "custom.gruene-serie",
  "version": "1.0.0",
  "label": {
    "de": "Grüne Serie",
    "en": "Green streak"
  },
  "description": {
    "de": "Mehrere grüne Kerzen in Folge",
    "en": "Several green candles in a row"
  },
  "icon": "repeat",
  "sentence": {
    "de": "{length} Kerzen in Folge",
    "en": "{length} candles in a row"
  },
  "inputs": [
    {
      "id": "open",
      "type": "price",
      "label": {
        "de": "Eröffnung",
        "en": "Open"
      }
    },
    {
      "id": "close",
      "type": "price",
      "label": {
        "de": "Schluss",
        "en": "Close"
      }
    }
  ],
  "settings": [
    {
      "id": "length",
      "label": {
        "de": "Kerzen",
        "en": "Candles"
      },
      "default": 3,
      "min": 2,
      "max": 20,
      "integer": true
    }
  ],
  "outputs": [
    {
      "id": "out",
      "type": "signal",
      "label": {
        "de": "Serie",
        "en": "Streak"
      },
      "formula": "holds(close > open, length)"
    }
  ]
}

Auswahl als Baustein speichern

Hast du schon eine Chain gebaut, machst du aus einem Teil davon einen Baustein, ohne eine Formel zu schreiben:

1. Wähl die Bausteine auf dem Board aus: mit gedrückter ⌘ (Mac) bzw. Strg nacheinander anklicken, oder mit gedrückter Shift einen Rahmen um sie ziehen.

2. Rechts unter Eigenschaften auf Als Baustein speichern klicken.

3. Der Dialog zeigt den neuen Baustein mit fertigen Formeln. Was in die Auswahl hineinführt, ist ein Eingang, was hinausführt, ein Ausgang. Gib ihm einen Namen und klick auf Speichern und ersetzen.

Die Auswahl wird durch den neuen Baustein ersetzt und ist wie vorher verbunden. Er rechnet genau wie die Bausteine vorher; aus dem BTC Dip-Käufer etwa wird rsi(price, 14) < 35 and price > ema(price, 200). Quellen und Aktionen bleiben auf dem Board. Nicht übersetzen lassen sich Bausteine, die sich etwas über Kerzen hinweg merken (Cooldown), von ihrem ganzen Verlauf abhängen (Supertrend, OBV) oder mit Uhrzeit und Kalendertagen rechnen (Zeitfenster, Pivot-Punkte, VWAP, Hoch/Tief mit Vortag oder Vorwoche); der Editor sagt dann, welcher es ist.

Bearbeiten und löschen

• Bearbeiten: in der Bausteinleiste der Stift neben dem Baustein, oder auf dem Board den Baustein anklicken und unter Eigenschaften auf Baustein bearbeiten.
• Speichern erhöht die Version, etwa von 1.0.0 auf 1.1.0. Die offene Chain rechnet sofort mit der neuen Fassung. Andere Chains behalten ihre Fassung, bis du den Baustein dort neu aufs Board legst.
• Löschen im Dialog nimmt den Baustein aus Eigene Bausteine. Chains, die ihn nutzen, behalten ihre Kopie und rechnen weiter.

Teilen und importieren

• Exportieren im Dialog speichert den Baustein als Datei, etwa abstand-zum-ema.bellchain-node.json. Die Datei kannst du weitergeben, etwa im Chat.
• Importieren in der Kopfzeile des Editors nimmt Chains und eigene Bausteine an. Ein Baustein landet unter Eigene Bausteine.
• Eine Chain trägt ihre eigenen Bausteine in sich. Wer deine Chain importiert, bekommt die Bausteine mit, auch ohne die Dateien.
• Unter JSON im Dialog siehst du den Baustein als Text, so wie er in der Datei steht. Was du dort änderst, steht sofort auch unter Gestalten, und umgekehrt.

Mit Konto liegen deine eigenen Bausteine und Favoriten im Konto und sind auf jedem Gerät da. Ohne Konto speichert sie dieser Browser; nach der Anmeldung wandern sie ins Konto.

Hinweis

Eigene Bausteine sind sicher, weil sie keinen Code enthalten. Bellchain prüft jede Formel, bevor sie rechnet: nur bekannte Funktionen, feste Längen, keine Schleifen, kein Zugriff auf Uhrzeit oder Netz. Wie das Format im Detail aussieht, steht unter Node-Spezifikation.

Grenzen

Was	Grenze
Eingänge, Einstellungen, Ausgänge	je 8
Formel	1.000 Zeichen
Länge in Kerzen	1 bis 1.000
Eigene Bausteine je Chain	20
Eigene Bausteine im Konto	100
Favoriten	50