> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/de/apps-auf-rome/bloom/issuing.md).

# Ausgeben

Bloom lässt Sie ein **genehmigtes Real-World-Asset** als normalen Solidity-Vertrag auf einer Rome-Chain ausgeben, und es über eine assetbezogene Konsole verwalten. Das Asset ist von EVM- und Solana-Wallets aus erreichbar, aber **die Ausgabe ist nur EVM** — eine Solana-Wallet hält Assets; sie erstellt sie nicht. Dieser Leitfaden behandelt die Issuer-Konsole, den Erstellungsassistenten, das Anmelde-Gate der Konsole und jeden der sechs Verwaltungstabs.

> **Bloom verlangt von Ihnen weder Dokumente noch personenbezogene Daten, und Ihr Investor auch nicht.** Bloom zeichnet die *Ergebnis* Ihrer Compliance-Entscheidung auf; die Chain zeichnet einen booleschen Wert pro Adresse auf. Ihr KYC/AML-Prozess — Ihre Dienstleister, Ihre Dateien, Ihre Aufbewahrung — bleibt vollständig in Ihrem eigenen System. Das vollständige Modell steht in [COMPLIANCE.md](https://docs.rome.builders/de/apps-auf-rome/bloom/compliance.md); dieser Leitfaden verweist darauf, statt es zu wiederholen.

***

## Was du tun kannst

Als Administrator eines Assets liegt alles unten für Sie in der Konsole bereit — und jede einzelne davon ist eine echte On-Chain-Transaktion, verlinkt auf der [Nachweis](https://docs.rome.builders/de/apps-auf-rome/bloom/evidence.md) Seite:

* **Ein Asset ausgeben** — der Assistent stellt es als drei Verträge bereit (unten).
* **Anträge prüfen** — jeden einzelnen genehmigen oder ablehnen (eine Ablehnung enthält einen Grund, den der Antragsteller beanspruchen kann), und eine genehmigte Adresse auf die Allowlist aufnehmen.
* **Die Allowlist verwalten** — eine Adresse hinzufügen, **eine Reihe von Adressen in einer einzigen Transaktion** (`batchAddToWhitelist`), oder eine Adresse entfernen; der Token erzwingt die Liste bei jeder Übertragung.
* **Das Asset sperren** — Übertragungen auf die Allowlist beschränken (wodurch die Versorgung endgültig wird), oder die Beschränkung aufheben.
* **Das Angebot verwalten** — die Gesamtsumme lesen und prägen oder verbrennen, sobald Sie die Rolle innehaben.
* **Den Verkauf durchführen** — einen Verkauf eröffnen (Mengen und Preis), ihn schließen, nicht verkaufte Bestände zurückrufen und den Erlös abheben.
* **Ertrag festlegen und verteilen** — die Auszahlungswährung festlegen, dann eine Auszahlung verteilen, die die Inhaber eine Transaktion nach der anderen abläuft; ausgeschlossene Inhaber werden übersprungen.
* **Rollen verwalten** — einer Adresse eine Rolle zuweisen, eine entziehen oder Ihre eigene aufgeben.

Jede wird unten im Detail beschrieben, zusammen mit dem, was die Chain erzwingt, in dem Tab, zu dem sie gehört.

***

## Die Issuer-Konsole

![Die Issuer-Konsole unter /issuer, die die Assets auflistet, die diese Bereitstellung kennt, und ihren Verkaufsstatus.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-c94de7c7a94a287a4d9b90a92b2b16022213b702%2Fissuer-console.png?alt=media\&token=657509e2-8263-4579-b54b-b6b4af33b6d6)

`/issuer` listet die Assets auf, die Sie auf dieser Chain ausgegeben haben, und lässt Sie ein neues starten.

* Verbinden Sie eine **EVM-Wallet**. Ein nicht verbundener Besucher oder eine Solana-Wallet sieht stattdessen eine Aufforderung, den richtigen Wallet-Typ zu verbinden, statt einer leeren Konsole — eine Solana-Wallet kann nicht ausgeben, und das ist eine Produktgrenze, die die Chain als zweite, unabhängige Schutzmaßnahme durchsetzt.
* In der Tabelle sind jedes Asset mit seinem **Namen und Symbol**, seinem Lebenszyklus **Phase**, und seinem **Verkauf** Status (ein *Öffnen Sie* Abzeichen oder *Geschlossen*).

Zwei Spalten — **Inhaber** und **Zu prüfen** — zeigen einen Strich. Die Inhaberzahl benötigt die Enumeration der Allowlist und die Prüfwarteschlange ist ein Off-Chain-Speicher, bei dem Sie sich pro Asset anmelden; ein Strich bedeutet *nicht abgefragt* wo ein `0` eine Tatsache behaupten würde, die die App nicht gelesen hat.

Drücke **Ein Asset ausgeben** um den Assistenten zu öffnen, oder wählen Sie eine Zeile aus, um die Konsole dieses Assets zu öffnen.

***

## Ein Asset erstellen: der Assistent

![Der Erstellungsassistent unter /create: die Asset-Felder, dann sechs Karten, die aufleuchten, sobald ihre Transaktionen ankommen.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-94683a3a49ac2418aed8cc66dbf47fad940814f7%2Fcreate-wizard.png?alt=media\&token=38b47568-d343-483d-8ce1-f437164bdeae)

`/create` erfasst vier Felder und stellt dann Ihr Asset bereit.

| Feld               | Regel                            |
| ------------------ | -------------------------------- |
| **Name**           | Erforderlich.                    |
| **Symbol**         | Erforderlich.                    |
| **Angebot**        | Eine ganze Zahl größer als null. |
| **Dezimalstellen** | Eine ganze Zahl von 0 bis 18.    |

Drücke **Start**. Wenn ein Feld ungültig ist, sagt Ihnen der Assistent, welches und warum, statt hinter einem deaktivierten Button zu warten. Wenn der Entwurf gültig ist, wird Ihre Wallet gebeten, jeden Schritt nacheinander zu signieren.

### Warum es in Teilen bereitgestellt wird

> **Ein Token wird in mehreren Transaktionen als drei Verträge bereitgestellt — niemals in einer.** Arcs Ein-Transaktions- `createToken` würde **77 Kontensperren**, und Rome begrenzt eine einzelne Transaktion auf **62 Locks**. Daher stellt der Assistent jedes Teil in einer eigenen Transaktion bereit und erhält danach über `ArcTokenFactoryV2.registerToken`. Dies ist eine Rome-Beschränkung, die sichtbar gemacht wird, keine optionale Optimierung — und die Schutzmechanismen bewahren Arcs Upstream-Sicherheitsmodell exakt (kanonischer Proxy, auf die Whitelist gesetzte Implementierung, der Aufrufer hält die Admin-Rolle des Tokens, Registrierung ist nur einmal möglich). Siehe [COMPLIANCE.md](https://docs.rome.builders/de/apps-auf-rome/bloom/compliance.md#what-rome-adds-and-what-registertoken-preserves).

### Die sechs Karten

Der Assistent zeigt sechs Karten, die dem Fortschritt der Bereitstellung folgen. Eine Karte wechselt von **Warten** zu **Signiert…** zu **Erledigt** (oder **Fehlgeschlagen**) sobald ihre Transaktion landet.

| # | Karte                           | Was es macht                                                                                                                               |
| - | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| 1 | **Implementierung**             | Die gemeinsame Asset-Implementierung für diese Chain — aufgelöst, nichts zu signieren. (Vor dem Start eines beliebigen Schritts erledigt.) |
| 2 | **Das Asset**                   | Stellt Ihr Asset bereit und setzt Name, Symbol, Angebot und Dezimalstellen in einem Schritt.                                               |
| 3 | **Wer ihn halten darf**         | Stellt das eigene Berechtigungsmodul dieses Assets bereit, mit Ihnen als dessen Administrator.                                             |
| 4 | **Bei Übertragungen erzwingen** | Zeigt das Asset auf dieses Modul, sodass jede Übertragung vom Asset selbst geprüft wird.                                                   |
| 5 | **Ertragsregeln**               | Stellt das Modul bereit und verknüpft es, das entscheidet, wer bezahlt wird.                                                               |
| 6 | **Registrierung**               | Registriert das Asset — das ist es, was den Verkauf öffnet und später ein Upgrade ermöglicht.                                              |

Die sechs Karten umfassen acht zugrunde liegende Bereitstellungsschritte, sodass eine einzige **Start** führt zu **acht Signaturen**. Ein Hinweis unter dem Button lautet *"Ihre Wallet wird Sie bitten, jeden Schritt zu signieren. Sie können jederzeit stoppen und später dort weitermachen, wo Sie aufgehört haben — nichts geht verloren."* Dass die Registrierung der letzte Schritt ist, ist der Grund, warum ein Stopp sicher ist: Das Asset ist in jeder Phase eine echte Bereitstellung und wird am Ende registriert.

Wenn der Lauf abgeschlossen ist, liest der Assistent *"Ausgegeben. Ihr Asset ist live unter …"* mit einem Link zur Konsole des Assets unter `/token/[address]`.

> **`initialize` gewährt Ihnen jede Rolle.** Der Assistentenbetreiber — Ihre EVM-Adresse — erhält die Admin-, Minter/Burner-, Yield-Manager/Distributor- und Upgrader-Rollen des Tokens sowie die Admin-Rolle des Allowlist-Moduls. Ihre Schlüsselverwahrung ist daher Teil der Compliance-Haltung des Assets: Eine verlorene Investor-Wallet kann nur durch Ihre Admin-Aktion wiederhergestellt werden, und der **Rechte** Registerkarte macht den Inhaber jeder Berechtigung sichtbar. (`UPGRADER_ROLE` ist *nicht* wird der Factory automatisch gewährt — gewähren Sie sie ausdrücklich, wenn Sie factory-vermittelte Upgrades möchten.)

***

## Die Asset-Konsole pro Asset und das Anmelde-Gate

![Das Anmelde-Gate der Konsole: Unterschreiben Sie eine Nachricht mit Ihrer Wallet — es gibt kein Passwort.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-a9377e3cad8460af1d9bb4eb3cf6f2a6a8f28b22%2Fconsole-signin.png?alt=media\&token=fdc19e4f-8724-4d36-999b-def1990685f9)

Öffnen `/token/[address]` funktioniert **nicht** zeigen die Konsole sofort an. Sie zeigt ein **Anmelde-Gate**:

> *"Melden Sie sich an, um dieses Asset zu verwalten. Signieren Sie eine Nachricht mit Ihrer Wallet — es gibt kein Passwort. Ihre Berechtigung stammt vom Asset selbst, und sie wird bei jeder Aktion erneut geprüft, sodass ein Widerruf sofort wirksam wird."*

Drücke **Melden Sie sich mit Ihrer Wallet an**. Genau Folgendes passiert:

1. Ihre Wallet wird gebeten, `personal_sign` eine kurze, für Menschen lesbare Erklärung (überschrieben mit *"Bloom — belegen Sie, dass Sie dieses Asset verwalten"*) zu signieren, die die eine Aktion nennt, die sie autorisiert — das Lesen der Anwendungswarteschlange dieses Assets — zusammen mit der Asset-Adresse, der Chain-ID und einem Zeitstempel.
2. Die App sendet diese signierte Erklärung an `GET /api/applications`.
3. Die **Server** prüft sie: Er ermittelt Ihre Adresse aus der Signatur, bestätigt, dass die Erklärung für diese Chain bestimmt ist und noch frisch ist (sie autorisiert für ein Zwei-Minuten-Fenster, nicht für eine Sitzung), liest das **eigene Allowlist-Modul des Tokens** von der Chain aus und prüft, dass Ihre Adresse die Rolle innehat, die das Schreiben auf die Allowlist tatsächlich erfordert — `MANAGER_ROLE` auf diesem Modul.
4. Wenn Sie sie innehaben, wird die Warteschlange zurückgegeben und die Konsole gerendert. Wenn nicht, verweigert der Server mit `403` und einem Grund.

![Das Gate zeigt eine zitierte Ablehnung: Eine Wallet, die dieses Asset nicht verwaltet, wird abgewiesen.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-99040b8d3c752f0f84615b913d6b75fb0d36f81b%2Fconsole-refusal.png?alt=media\&token=29c3ffcf-b826-4aa7-b9da-41bdc3ec2e1e)

> **Das Asset entscheidet, wer es verwalten darf — nicht diese App.** Die Rolle wird auf der Allowlist geprüft **Modul**, nicht auf dem Token, und das Halten einer gleichnamigen Rolle auf dem Token *nicht* wird nicht übertragen — es sind unterschiedliche Berechtigungen. Es gibt kein Konto und keine Sitzung: Jede folgende Anfrage trägt ihre eigene frische Signatur, und genau das *"bei jeder Aktion erneut geprüft"* bedeutet. Entziehen Sie einer Wallet ihre Rolle auf der Chain, und sie kann sich sofort nicht mehr anmelden.

Eine Ablehnung zeigt den Grund **in Zitatform** — Bloom schreibt niemals einen Satz darüber, warum eine Wallet abgelehnt wurde. Wenn Sie die Signatur in Ihrer Wallet ablehnen, ist das Ihr *"Nein"*, nicht das des Assets, und es wird nicht als Ablehnung gemeldet.

> **Das Gate entscheidet, wessen Konsole es ist, nicht was geheim ist.** Angebot, Verkaufsstatus, die Allowlist-Liste und die Rollen sind öffentliche Chain-Abfragen, die jeder Explorer beantworten kann. Was die Signatur verschafft, ist die **Antragswarteschlange** — die Erklärungen anderer — und das Recht, überhaupt die Konsole angezeigt zu bekommen.

### Die Kopfzeile der Konsole

Sobald Sie angemeldet sind, benennt die Kopfzeile das Asset und zeigt dessen **Phase** — die wichtigste Tatsache, die sie besitzt:

| Phase          | Bedeutung                                                                                                                                                          |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Entwurf**    | Es ist noch kein Berechtigungsmodul verknüpft, also schränkt nichts ein, wer dies halten darf.                                                                     |
| **Öffnen Sie** | Übertragungen sind offen und das Angebot kann sich noch ändern. Das Sperren des Assets macht sein Angebot endgültig, und das kann nicht rückgängig gemacht werden. |
| **Gesperrt**   | Nur auf der Allowlist stehende Adressen dürfen dies halten, **und sein Angebot ist endgültig** — es kann dauerhaft weder weiter geprägt noch verbrannt werden.     |

Über den Tabs zeigt eine Zusammenfassung vier Kennzahlen — **Inhaber · Zu prüfen · Verkauft · Ausgezahlt**. Zwei werden aus der Chain und dem Speicher gelesen (*Zu prüfen* sobald Sie angemeldet sind; *Verkauft* aus dem Storefront); *Inhaber* wartet auf die Inhaberzahl der Ertragsvorschau, und *Ausgezahlt* wartet auf den noch ausstehenden Cursor der Auszahlungshistorie. Jede wartende Zelle zeigt einen Strich und erklärt, was sie benötigt, statt einem `0` das eine Tatsache behaupten würde, nach der niemand die Chain gefragt hat.

***

## Die sechs Tabs

Die Konsole hat sechs Tabs, in dieser Reihenfolge: **Anträge · Wer es halten darf · Angebot · Verkauf · Ertrag · Rechte.**

Jede Schreibaktion in diesen Tabs verwendet eine gemeinsame Steuerung, die die **benannten Vorbedingungen** und ihre **Folgen** *vor* der Schaltfläche darstellt und ihre Phase beim Ausführen benennt (*„Warten auf deine Wallet…“*, *„Landet auf der Chain…“*). Nichts sollte zurückgesetzt werden müssen, um Ihnen zu zeigen, was hätte zuerst geprüft werden können.

### Anträge — die Prüfwarteschlange

![Der Tab Anträge — die Prüfwarteschlange mit einem ausstehenden Antrag zum Genehmigen oder Ablehnen und der Compliance-Schnittstelle.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-8249de8b76f757101cc945ca4a2687103428839c%2Ftab-applications.png?alt=media\&token=ab0def9b-0bcb-49eb-b785-fd78e6fa2f92)

Dieser Tab listet auf, wer beantragt hat, das Asset zu halten. Jede Zeile zeigt die Adresse des Antragstellers, die Jurisdiktion, den Inhabertyp, eine **Prüfungen** Spalte (*Bestanden* wenn Ihr Anbieter ein Ergebnis aufgezeichnet hat, andernfalls *Erklärt*), und eine **Status** (*Zu prüfen*, *Genehmigt*, *Abgelehnt*). Klappen Sie eine Zeile auf, um ihre Fakten und zwei Steuerelemente zu sehen: **Genehmigen — darf es halten** und **Ablehnen**. Eine Ablehnung erfordert einen Grund, der zur Antwort des Antragstellers wird.

> **Genehmigen sind zwei getrennte Handlungen, und der Tab hält sie ehrlich.** Drücken **Genehmigen** *zeichnet* Ihre Entscheidung im Antragspeicher auf. Die Adresse auf die Allowlist des Assets on-chain zu setzen, ist eine **zweite Signatur** — `batchAddToWhitelist` — und bis sie ankommt, sagt die Zeile das auch. Wenn die aufgezeichnete Entscheidung und die Chain nicht übereinstimmen, benennt der Tab die Lücke und bietet den Schreibvorgang an, der sie schließt: **Aufnehmen** um eine genehmigte Adresse zur Allowlist hinzuzufügen, oder (für eine abgelehnte Adresse, die noch gelistet ist) die Steuerung, um sie zu entfernen. Die Adresse kann das Asset erst halten, wenn der Allowlist-Schreibvorgang gelandet ist.

Ein dauerhafter Hinweis in diesem Tab — die **Compliance-Schnittstelle** — sagt aus, wo Ihr eigener Prozess andockt:

> *"Es werden hier keine Dokumente abgefragt oder aufbewahrt — die Prüfungen sind Ihre eigenen. Verbinden Sie Ihren Anbieter hinter der `Anträge` Schnittstelle, oder importieren Sie Entscheidungen, die Sie bereits getroffen haben. Bloom zeichnet das Ergebnis auf und die Chain zeichnet ein Ja oder Nein gegen die Adresse auf."*

Das ist die Schnittstelle, die ein Self-Hosting-Emittent ersetzt: Tauschen Sie die Implementierung des Antrags-Speichers gegen Ihre eigene dauerhafte aus, und kein Aufrufer ändert sich. Bloom führt keine Prüfungen durch und hält kein Dokument.

### Wer es halten darf — das Transfers-Gate

![Der Tab Wer-es-halten-darf — die Allowlist-Zählung und die Steuerung zur Beschränkung von Übertragungen, die ihre Folgen als Einbahnstraße zeigt.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-d32c410e3b5798d86dc5b914bce2f927eb4b1620%2Ftab-holders.png?alt=media\&token=aefe491d-2ce8-4478-a776-b9e612536d60)

Dieser Tab meldet, wie viele Adressen auf dem Asset auf der Allowlist stehen, und lässt Sie umschalten, ob die Allowlist **durchgesetzt**:

* Wenn Übertragungen **uneingeschränkt**sind, bietet er an, **Übertragungen auf die Allowlist zu beschränken**. Die Folgen des Schreibvorgangs besagen, dass dies das Angebot endgültig macht und für Nicht-Admins eine Einbahnstraße ist.
* Wenn Übertragungen **beschränkt**sind, bietet er an, **die Beschränkung aufheben**. Seine Folgen sagen unmissverständlich, dass dies kein Rückgängig-Machen ist.

Auf einem *ohne Gate* (Entwurfs-)Asset ohne verknüpftes Berechtigungsmodul sagt der Tab das — *"Es ist kein Berechtigungsmodul verknüpft, also schränkt nichts ein, wer dies halten darf"* — und der Schalter wird nicht gerendert.

> **Der Token prüft beide Seiten jeder Übertragung.** Solange das Asset gesperrt ist, schlägt eine Übertragung fehl, bei der eine der beiden Parteien nicht auf der Allowlist steht, mit einem typisierten Fehler auf der Chain fehl. Dasselbe Gate greift bei einer Übertragung aus einer EVM-Wallet, einer mit Solana signierten Übertragung, einem Storefront-Verkauf und dem anfänglichen Liquiditätsmove — es gibt keinen Weg daran vorbei außer mit Ihren eigenen Admin-Rechten.

### Angebot

![Der Tab Angebot — die Gesamtzahl existierender Einheiten.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-29eb2d741e5193eef3ea94a214a199f2eb404fe7%2Ftab-supply.png?alt=media\&token=2ab35474-ed9a-4d30-b978-5f69e1c0e7b9)

Dieser Tab meldet das gesamte existierende Angebot in ganzen Einheiten.

### Verkauf — öffnen, schließen und Erlös entgegennehmen

![Der Tab Verkauf — ein offener Verkauf, mit den Steuerelementen Verkauf schließen, Nichtverkauftes zurückrufen und Erlös abheben.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-573a99f9028a984b038162dc885a16b715673293%2Ftab-sale.png?alt=media\&token=18f59a19-9d83-4780-abf2-47e4a3e37d14)

Dieser Tab führt den Primärverkauf über den Storefront-Vertrag aus.

* **Wenn kein Verkauf offen ist**, bietet er an, einen zu eröffnen: Geben Sie ein **Zu verkaufende Einheiten** und **Preis pro Einheit** (in `wUSDC`), und drücken Sie dann **Verkauf eröffnen**. Die Vorbedingungen des Schreibvorgangs werden zuerst angezeigt — der Token muss registriert sein, die Storefront muss die Verkaufsbestände halten, und die Storefront selbst muss auf dem Token, den sie verkauft, auf der Allowlist stehen — damit ein noch nicht eröffneter Verkauf genau sagt, was er braucht.
* **Wenn ein Verkauf offen ist**, zeigt er, wie viele Einheiten des Angebots noch übrig sind, und bietet **Diesen Verkauf schließen**.
* **Nicht verkaufte Einheiten zurückrufen** verschiebt nicht verkaufte Bestände von der Storefront zurück an einen Empfänger (standardmäßig an Sie). Dies ist **nicht** kein Schließen — der Verkauf bleibt aktiviert, und die Folge des Schreibvorgangs sagt das auch, sodass ein Rückruf nicht als Rückgängigmachen missverstanden werden kann.
* **Erlös abheben** sendet die Einnahmen der Storefront an eine Adresse (standardmäßig an Sie). Der Erlös sammelt sich unabhängig vom Status des Verkaufs an, sodass er sowohl bei offenem als auch bei geschlossenem Verkauf abgehoben werden kann.

### Ertrag — Inhaber bezahlen, jeweils einer pro Transaktion

![Der Tab Ertrag — das Feld für den Verteilungsbetrag, mit dem Hinweis, zuerst eine Auszahlungswährung festzulegen.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-cc8150ea6fee72d99bd5a2254073779cbd896c11%2Ftab-yield.png?alt=media\&token=d190f7bd-1a1c-4ed2-b9a2-d27a399602f6)

Dieser Tab verteilt eine Ertragsauszahlung an Inhaber.

> **Eine Verteilung ist ein Gang, kein Klick.** Auf Rome, `distributeYieldWithLimit` zahlt **einen Inhaber pro Transaktion** (das Kontolimit), sodass eine Auszahlung eine Folge von Fenstern ist, jedes mit eigener Signatur. Sie geben den Betrag einmal ein, in ganzen Einheiten der Auszahlungswährung, und er wird gesperrt, sobald der Gang beginnt. Das **zuerst** Fenster zieht die gesamte Auszahlung von Ihnen ein und bezahlt den ersten Inhaber; jedes spätere Fenster bewegt nur noch Geld, das sich bereits im Token-Vertrag befindet. Bloom liest den Cursor nach jedem Fenster erneut von der Chain — der Inhabersatz ordnet sich mit den sich ändernden Salden neu an, und das Senden eines veralteten Index würde wieder bei Null beginnen und Ihr Geld ein zweites Mal einziehen.

Der Tab zeigt den Fortschritt — *"Bezahle Inhaber N von M"* — und endet, wenn der Cursor wieder umläuft. Wenn für das Asset keine Auszahlungswährung festgelegt ist, sagt der Tab das; die Festlegung der Auszahlungswährung ist das einzige Feld einer Verteilung, das nur Sie wählen können.

> **Die Anteile eingeschränkter Inhaber bleiben im Vertrag.** Eine durch das Yield-Blacklist-Modul ausgeschlossene Adresse wird übersprungen, und ihr anteiliger Anteil verbleibt im Token-Vertrag, statt ausgezahlt zu werden.

Vergangene Auszahlungen werden noch nicht angezeigt — um sie zu lesen, werden die Verteilungsereignisse bis zum ersten Block des Assets zurückverfolgt, wofür noch ein Historiencursor benötigt wird. Der Tab sagt das in sich selbst, statt ein `0`.

### Rechte — die Rollen

![Der Tab Rechte — jede Rolle und ob sie gehalten wird, sowie die Steuerung für Zuweisen / Entziehen / Aufgeben.](https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-fb54f6c73c2d194dd5b6321bc3cb0af825f6f637%2Ftab-rights.png?alt=media\&token=6f545a79-96f8-4c9e-ac38-ce435e547deb)

Dieser Tab listet jede Rolle auf, die der Token deklariert, und ob sie gehalten wird; jede wird mit einem einzelnen `hasRole` Aufruf gegen den Token gelesen. Eine Rolle, die **nicht** gehalten wird, wird auch so angezeigt, statt weggelassen zu werden — in einem Rechte-Tab sind eine fehlende Zeile und ein *"Nein"* zwei verschiedene Tatsachen.

Unter der Liste ändert eine Steuerung die Rollen:

| Aktion                        | Bezieht sich auf                                                          | Berechtigung         |
| ----------------------------- | ------------------------------------------------------------------------- | -------------------- |
| **Einem Konto zuweisen**      | Eine Adresse, die Sie eingeben                                            | `DEFAULT_ADMIN_ROLE` |
| **Von einem Konto entziehen** | Eine Adresse, die Sie eingeben                                            | `DEFAULT_ADMIN_ROLE` |
| **Ihre eigene aufgeben**      | Sie selbst (OpenZeppelin verlangt, dass die Bestätigung der Aufrufer ist) | Sie                  |

Die Rollenauswahl sind die des Tokens selbst, daher kann die Steuerung niemals eine Rolle anbieten, die der Token nicht hat. Wie bei jeder Schreibaktion werden die Autoritätszeile und die Folge vor der Schaltfläche dargestellt, sodass die Tür und ihre Einbahnigkeit angezeigt werden, bevor Sie signieren.

***

## Was Bloom oder die Chain niemals berührt

Um eindeutig zu machen, wo Compliance angesiedelt ist:

| Ding                                        | Wo es lebt                                                                                                                 |
| ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| KYC/AML-Dokumente und PII                   | Ihr eigenes System, mit Ihren eigenen Dienstleistern und Ihrer eigenen Aufbewahrung — **niemals** diese App oder die Chain |
| Ihre Entscheidung, eine Adresse aufzunehmen | Ein Off-Chain-Eintrag; Sie besitzen den Speicher                                                                           |
| Die On-Chain-Auswirkung dieser Entscheidung | Ein boolescher Wert — `isWhitelisted(address)` — geschrieben von `batchAddToWhitelist`                                     |
| Durchsetzung der Regel                      | Der Asset-Vertrag, bei jeder Übertragung                                                                                   |
| Wer das Asset verwalten darf                | Die Rolle, die im Allowlist-Modul des Assets gehalten wird und bei jeder Anfrage geprüft wird                              |

Für das vollständige Compliance-Modell lesen Sie [COMPLIANCE.md](https://docs.rome.builders/de/apps-auf-rome/bloom/compliance.md); für die Zwei-Lane-Mechanik (EVM und Solana), die Ihre Inhaber verwenden, lesen Sie [LANES.md](https://docs.rome.builders/de/apps-auf-rome/bloom/lanes.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/de/apps-auf-rome/bloom/issuing.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
