> 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/entwicklerleitfaden/integrate-solana-program.md).

# Ein Solana-Programm integrieren

Integrieren Sie ein Solana-Programm mit Rome EVM — wer der Solana-Signer ist, wie Werte in Ihr Programm gelangen und wieder zurückkommen, die Einspurregel, atomar vs. iterativ sowie die Bereitstellung von Konten.

Dieser Leitfaden richtet sich an ein Solana-Programmierteam, das möchte, dass Rome-EVM-Nutzer ihr Programm verwenden — ein Datenschutz-, Kredit- oder Vault-Programm, das für EVM-Konten Wert halten soll. Er baut auf [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md) (den Mechaniken der Precompiles) und beantwortet die Fragen, die auftauchen, sobald auf der anderen Seite ein echtes Programm steht: *wer* unterzeichnet, *wie* Token hinein- und herausgelangen, und *welche* Grenzen das Design prägen.

Der durchgängig verwendete Ablauf: Ein EVM-Konto bewegt USDC in Ihr Programm („shield“ oder „deposit“), Ihr Programm hält sie für diesen Nutzer, und gibt sie später wieder frei („unshield“ oder „withdraw“). Ersetzen Sie die Verben durch Ihre eigenen.

## 1. Jede EVM-Adresse hat eine Solana-Identität

Rome leitet für jede EVM-Adresse — Nutzer und Verträge gleichermaßen — ein Solana-Konto ab, genannt seine **externe Autorität**:

```
external_auth(addr) = find_program_address(["EXTERNAL_AUTHORITY", addr_h160], rome_evm_program_id)
```

Es besitzt die zugehörigen Tokenkonten der Adresse (dorther liest `wUSDC.balanceOf(addr)` aus) und es ist der Schlüssel, der CPIs im Namen dieser Adresse unterzeichnet. Ihr Programm sieht einen 32-Byte-Solana-Pubkey; es sieht nie ein H160.

**Wer unterzeichnet, entscheidet sich danach, wer das Precompile aufruft:**

| Das Precompile wird aufgerufen von                                                        | Der Solana-Signer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Eine **Vertrag**, mit einem normalen `CALL`                                               | Die **des Vertrags eigenen** externen Autorität (`external_auth(contract)`), plus alle gesalzenen Sub-PDAs des Vertrags, die er anfordert                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Eine **Nutzer**, in einer Transaktion, die direkt an die Precompile-Adresse gesendet wird | Die **des Nutzers eigene** externe Autorität                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Ein Vertrag per `DELEGATECALL`                                                            | Die bloße Autorität wird abgelehnt (`DelegatecallOwnerAuthority`). `invoke` ohne Unterzeichner, und `invoke_signed` mit gesalzenen Sub-PDAs werden weiterhin ausgeführt — aber diese Sub-PDAs werden nach der Adresse des laufenden Vertrags in Namespaces organisiert (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`), daher `pda_with_salt` leitet sie nicht ab. Bei HelperProgram bestehen nur die Erstellungs- und Finanzierungs-Selektoren (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint` ); sie sind ausgenommen, weil ihr Ziel an den Aufrufer gebunden oder vom Operator finanziert wird, nicht weil sie nichts unterzeichnen |

Die Konsequenz ist die ERC-20-Regel, die Sie bereits kennen: **ein Vertrag kann die Vermögenswerte eines Nutzers nicht eigenständig bewegen.** Es agiert unter seiner eigenen Identität, und der Nutzer gewährt ihm zuerst Rechte. Für Token, die auf der Solana-Seite bewegt werden müssen, ist diese Gewährung eine SPL-Delegation auf dem Tokenkonto des Nutzers; die ERC-20 des Wrappers `approve` ist nur eine EVM-seitige Allowance, die die eigenen Transfers des Wrappers respektieren. So arbeiten Rome's eigene Token-Wrapper, und so wird auch Ihr Adapter arbeiten (Abschnitt 3).

Gesalzene Sub-PDAs: `invoke_signed` nimmt eine Liste von `bytes32` Salts, und Rome unterzeichnet mit `["EXTERNAL_AUTHORITY", caller_h160, salt]` für jedes davon (Bump angehängt; der Aufrufer ist der Vertrag bei einem Direktaufruf). `HelperProgram.pda_with_salt(addr, salt)` gibt die Adresse aus Solidity zurück. Verwenden Sie einen Salt pro Nutzer (zum Beispiel die Adresse des Nutzers), wenn Ihr Programm pro Position ein eigenes Besitzerkonto möchte.

Finanzierung: Ein PDA der externen Autorität muss nicht existieren, um ein ATA zu besitzen (`create_ata` ist idempotent und der Solana-Gebührenzahler der Transaktion deckt die Renten). Er muss nur existieren und Lamports halten, wenn er Konten finanziert, die Ihre Instruktion erstellt. `HelperProgram.create_pda(addr)` erstellt es als schlichtes System `CreateAccount`, daher rufen Sie es einmal auf; es ist nicht idempotent. `swap_gas_to_lamports(n)` schreibt dem PDA der Adresse `n` Lamports vom Solana-Gebührenzahler der Transaktion gut, und der Aufrufer bezahlt sie in Rome-Gas: Jede Auswirkung einer Legacy-Track-CPI auf das Guthaben des Gebührenzahlers wird zur Transaktionsgebühr addiert und dem Nutzer zum Gaspreis berechnet, genauso wie die Miete für Konten berechnet wird, die eine CPI erstellt. Der Bereitstellungsschritt der Solana-Lane wird in [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md)beschrieben; ein Vertrag stellt seinen eigenen PDA in seinem Konstruktor oder beim ersten Aufruf bereit.

## 2. Drei Möglichkeiten, die Position eines Nutzers zu halten

**A. Ein Adaptervertrag (empfohlen für einen wiederverwendbaren Adapter).** Ein Solidity-Vertrag steht vor Ihrem Programm. Der Nutzer gewährt der Autorität des Adapters eine SPL-Delegation auf seinem Tokenkonto; der Adapter zieht die Token in ein Tokenkonto, das ihm gehört, ruft Ihr Programm als er selbst auf und schlüsselt die Position des Nutzers in Ihrem Programm über ein nutzerspezifisches Sub-PDA oder über eine Kennung auf, die er in den Instruktionsdaten übergibt. Beim Herausgeben weist er Ihr Programm an, an das eigene Tokenkonto des Nutzers freizugeben. Der Adapter ist die einzige Solana-Identität, die Ihr Programm kennen muss. Die Gewährung ist eine SPL-Delegation, keine ERC-20 `approve`; Abschnitt 3 erklärt, warum und was es den Nutzer kostet.

**B. Der Nutzer als Solana-Signer.** Das Frontend sendet eine Transaktion vom EVM-Konto des Nutzers **direkt an das CpiProgram-Precompile** (`to = 0xff…08`, calldata = das ABI-kodierte `invoke` oder `invoke_signed`), sodass die eigene externe Autorität des Nutzers unterzeichnet und Ihr Programm die Position darüber schlüsselt. Kein Adaptervertrag und keine Delegation, aber jede Aktion ist eine undurchsichtige calldata-Transaktion im Wallet, und alles, was der Ablauf außer der CPI braucht (das ATA, eine vorherige Übertragung), ist eine separate Transaktion. Das eignet sich für einmalige Gewährungen (eines Nutzers `approve_spl` an einen Wrapper) und für einfache Programme, nicht für mehrstufige Abläufe. [Cardo](https://github.com/rome-protocol/cardo) nutzt diese Form: Sein Frontend sendet die `invoke` direkt aus dem Wallet des Nutzers an das Precompile.

**C. Ein verwahrungsfreier Router.** Ein Vertrag, der niemals die Token des Nutzers hält. Der Nutzer gewährt der Autorität des Routers eine SPL-Delegation auf seinem eigenen Tokenkonto; der Router führt CPIs in Ihr Programm mit dieser Autorität als Transfer-Autorität aus, sodass Token vom Tokenkonto des Nutzers in das Konto Ihres Programms (oder zurück zum Nutzer) wandern, und der Router hält zwischen Aufrufen nichts. Der Router leitet jedes nutzerseitige Konto aus `msg.sender` , sodass die Gewährung eines Nutzers nicht auf das Konto eines anderen Nutzers gezeigt werden kann, und er ruft ein festes Programm mit festen Instruktionsformen auf, statt als allgemeiner `invoke` Durchleitung zu `RomeDexRouter` in [rome-dex](https://github.com/rome-protocol/rome-dex) ist so geschrieben; die EVM-Lane von rome-dex bietet außerdem das rohe direkte `invoke` von Form B. Es benötigt dieselbe Gewährung wie A, mit denselben Kosten für einen einzelnen Delegate (Abschnitt 3), und keinen Pull-Schritt.

Der Rest dieses Leitfadens folgt A; C verwendet dieselbe Gewährung und dieselbe Signaturregel.

## 3. Token hinein, Token hinaus

USDC auf Rome ist ein SPL-Mint, von zwei Seiten betrachtet: der `wUSDC` ERC-20-Wrapper auf der EVM-Seite und das ATA der externen Autorität auf der Solana-Seite. Für die eigene Adresse eines Nutzers sind beide derselbe Saldo: `wUSDC.balanceOf(user)` liest das ATA des Nutzers. Zwischen den beiden Ansichten bewegt oder synchronisiert sich nichts.

**Der Wrapper-Saldo eines Vertrags ist kein Tokenkonto, das der Vertrag kontrolliert.** Die Factory deployt `SPL_ERC20_cached` für einen gewöhnlichen Mint, und Hadrians `wUSDC` ist einer. Dieser Wrapper kann nicht für einen Vertrag unterzeichnen, also wenn `wUSDC.transferFrom(user, adapter, amount)` oder `transfer` Token an einen Vertrag sendet, wandern die SPL-Token in das **eigene Escrow-Tokenkonto des Wrappers** (`escrow_ata()`), und der Wrapper speichert den Betrag pro Vertrag in seinem Storage. `wUSDC.balanceOf(adapter)` gibt diesen Datensatz zurück, ein Escrow-Buchungskonto, nicht den Saldo eines Tokenkontos, das im Besitz von `external_auth(adapter)`. Ihr Adapter kann diese Token Ihrem Programm nicht in einer CPI übergeben; sie können nur wieder über den Wrapper herausgelangen. Ein Adapter, der sich mit `transferFrom` finanziert, hat auf der Solana-Seite nichts, das er ausgeben kann.

Der funktionierende Weg ist eine SPL-Delegation:

* **Gewährung.** Der Nutzer sendet `approve_spl(adapter, amount, mint)` als Transaktion **direkt an das HelperProgram** (`to = 0xff…09`), wobei `mint` ist der `mint_id()`. Die eigene Autorität des Nutzers unterzeichnet, und der Delegate, den sie auf dem Tokenkonto des Nutzers setzt, ist die externe Autorität des Adapters.
* **In.** Die `deposit(amount)` zieht mit der Delegate-Überladung `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`, mit dem ATA des Nutzers als Quelle und dem eigenen ATA des Adapters (`HelperProgram.ata(address(this), mint)`, einmal erstellt mit `create_ata`) als Ziel. Die Autorität des Adapters unterzeichnet als Delegate. Die Token befinden sich nun in einem Tokenkonto, das `external_auth(adapter)`gehört `wUSDC.balanceOf(adapter)`.
* **Heraus.** Die Withdraw-Instruktion Ihres Programms überträgt an das **des Nutzers** ATA, `HelperProgram.ata(user, mint)`. Der Empfang benötigt keine Signatur des Nutzers, und der Saldo ist sofort sichtbar als `wUSDC.balanceOf(user)`. Falls das ATA noch nicht existieren sollte, erstellen Sie es zuerst mit `HelperProgram.create_ata(user, mint)` (idempotent).

**Ein Tokenkonto hat genau einen Delegate.** Die obige Gewährung ersetzt die eigene Gewährung des Wrappers auf diesem Konto. Bis der Nutzer den Wrapper erneut gewährt, schlägt jeder `wUSDC` `transfer` oder `transferFrom` Transfer aus ihrer Adresse mit SPL-Fehler `0x4`fehl. Nach jedem Ablauf, der diese Gewährung nutzt, rufen Sie `wUSDC.isEnabled(user)`; wenn es `false`zurückgibt, bitten Sie den Nutzer, zu senden `approve_spl(wrapper, 2^64-1, mint)` erneut an das HelperProgram, dieselbe maximale Gewährung, um die der Wrapper gebaut ist (siehe [Einmalig: dem Wrapper gewähren](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md#one-time-grant-the-wrapper)). Eine begrenzte Gewährung würde die normalen `wUSDC` Transfers des Nutzers erneut unterbrechen, sobald sie knapp wird, und `isEnabled` bleibt `true` solange noch etwas davon übrig ist, sodass die App nicht wüsste, dass sie erneut fragen muss.

Um zu prüfen, welchen Wrapper ein Mint hat, lesen Sie das der Factory `wrapper_kind_by_mint(mint)` (die Factory-Adresse steht in der `contracts.json` in der [Registry](https://github.com/rome-protocol/rome-registry)). `1` ist der Cached-Wrapper, den dieser Abschnitt beschreibt. `2` ist der Direct-CPI-Wrapper, den die Factory für einen Token-2022-Mint mit einem aktivierten Transfer Hook deployt; dieser Leitfaden behandelt ihn nicht. Die Registry `tokens.json` listet die Wrapper-Adresse und den Mint auf, aber nicht, um welche Art es sich handelt.

## 4. Ein Track pro Vertrag und pro Transaktion

Rome hat zwei Familien von Precompiles, die den Solana-Zustand verändern, und **eine Transaktion verwendet genau eine davon** — die Runtime lehnt eine Transaktion ab, die mutierende Aufrufe aus beiden mischt, selbst über Vertragsgrenzen hinweg.

| Track      | Precompiles                                                                                         | Effekte wirken sich aus                                                                                 | Funktioniert in iterativer Ausführung                                                                    |
| ---------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| **Legacy** | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Withdraw` `0x42…16` | Sofort, als echte CPI innerhalb des EVM-Schritts                                                        | **Nein** — eine Legacy-CPI in einer iterativen Transaktion schlägt fehl mit `CpiProhibitedInIterativeTx` |
| **Cached** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | In einem Overlay vorgemerkt und am Ende der Transaktion als CPIs committed; ein EVM-Revert verwirft sie | Ja                                                                                                       |

Was das für eine Programmintegration bedeutet:

* **Das Aufrufen der Instruktionen Ihres eigenen Programms ist nur auf dem Legacy-Track möglich.** Der Cached-Track hat kein generisches `invoke`; er umfasst SPL-Transfers, ATA-Erstellung, Systemprogramm-Operationen und Gasabhebung.
* Daher muss der Schritt, der den Adapter finanziert, ebenfalls auf dem Legacy-Track liegen, wenn er in derselben Transaktion wie die CPI läuft. Der Cached-Wrapper `transferFrom` ist ein Cached-Track-Aufruf, daher kann er sich keine Transaktion mit Ihrer CPI teilen (und, wie Abschnitt 3 zeigt, würde er nur ein Escrow-Buchungskonto gutschreiben). Ziehen Sie stattdessen mit `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` nachdem der Nutzer den Adapter zum SPL-Delegate gemacht hat (`approve_spl`direkt vom Nutzer an das HelperProgram gesendet). Der Pull und die CPI liegen beide auf dem Legacy-Track, also laufen sie in einer Transaktion.
* **Halten Sie den Wrapper aus dieser Transaktion heraus.** Rufen Sie die mutierenden Funktionen des Wrappers nicht auf (`wUSDC.transfer`, `transferFrom`) vom Adapter aus in derselben Transaktion wie einer Legacy-CPI auf. Prüfen Sie `isEnabled(user)` und Salden vom Frontend aus mit `eth_call`.
* **Und die CPI-Transaktion muss atomar sein.** Das ist die Grenze, unter der das Design liegt.

Lesezugriffe liegen außerhalb dieser Regel: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` und `HelperProgram.user_balance` / `allowance_of` sind Lesezugriffe auf vorab geladene Konten (keine CPI), auf beiden Tracks und in beiden Ausführungsmodi erlaubt. Legen Sie Ihre Vorprüfungen darauf. Eine Reihenfolgeregel: Sobald in einer Transaktion eine Cached-Änderung ausgelöst wurde, sind Legacy-Track-Lesezugriffe für den Rest der Transaktion blockiert — zuerst lesen, dann ändern.

## 5. Atomar ist das Budget

Eine atomare Rome-Transaktion ist eine Solana-Transaktion: etwa **1,4 Mio. Compute Units**, eine **64-Adressen** Kontenliste und eine **4 KB** Wire-Größe (Solana-v1-Transaktionen). Das Rome-Programm und Ihre CPI teilen sich dieses Budget. Ein Wrapper-Transfer läuft auf Hadrian mit etwa 170K CU, und Ihre Instruktion bringt ihre eigenen hinzu; messen Sie anhand des Solana-Belegs `computeUnitsConsumed`, nicht EVM `gasUsed`.

Wenn die Emulation entscheidet, dass eine Transaktion nicht passt, führt Rome sie **iterativ** über mehrere Solana-Transaktionen hinweg aus, und eine Legacy-CPI darin schlägt dann fehl. Beschränken Sie sowohl Deposit als auch Withdraw auf eine Tokenbewegung plus eine CPI in Ihr Programm, und halten Sie das Solidity darum herum klein. Teilen Sie alles Größere in zwei Nutzertransaktionen auf.

CPI-Tiefe: Solana erlaubt 4 Ebenen und Rome nutzt eine, also läuft Ihre Instruktion auf Ebene 2 mit zwei Ebenen darunter (Ihr Programm → SPL Token lässt eine übrig).

## 6. Kontobereitstellung

Ihr Programm erhält seine Konten zur Laufzeit nicht von Solidity. Der Proxy **emuliert** jede Transaktion vor dem Senden, zeichnet jedes Solana-Konto auf, das die CPIs berührt haben, und platziert sie in der Solana-Transaktion. Ihr Adapter nennt die Konten in der `invoke_signed` Kontenliste; die Emulation beweist, dass sie aufgelöst werden. Daraus folgen drei Dinge:

* Jedes Konto, das Ihre Instruktion berührt, muss aus Eingaben ableitbar sein, die der Adapter hat (sein eigenes PDA und Sub-PDAs, Ihre Program-ID, Mints, die Adresse des Nutzers). `SystemProgram.find_program_address` und `CpiProgram.pdas_batch_derive` führen die Ableitungen in Solidity durch.
* Ein Konto, das noch nicht existiert (eine frische Position, ein frisches ATA), muss dennoch in der Kontenliste genannt werden; seine Adresse ist das, was in der Solana-Transaktion ankommt.
* Alles, was die Transaktion berührt — einschließlich Rome's eigener Konten für den Nutzer, den Adapter und den Wrapper — muss unter 64 Adressen bleiben. Ein Design, das in einem Aufruf zehn Märkte berührt, passt nicht.

Für die Solana-Wallet-Lane, `rome_emulateCallAccounts` stellt einem Client dieselbe Ermittlung zur Verfügung; das SDK nutzt sie.

Zwei Konten, die eine CPI niemals benennen darf: der Solana-Gebührenzahler, der die Transaktion einreicht (außer innerhalb einer einfachen System-Transfer-Instruktion), und das Rome-Programm selbst. Eine CPI zurück in das Rome-Programm wird abgelehnt.

## 7. Ein Deposit und ein Withdraw, in Solidity

Eine minimale Skizze eines Adapters auf dem Legacy-Track. Der Nutzer hat bereits `approve_spl(adapter, amount, mint)` an das HelperProgram gesendet (Abschnitt 3). `PRIVACY_PROGRAM` ist Ihre Programm-ID; `encodeDeposit` / `encodeWithdraw` bauen Ihre Instruktionsdaten (Borsh, Little-Endian); die Account-Metas folgen dem Layout Ihrer Instruktion.

```solidity
import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract PrivacyAdapter {
    ICrossProgramInvocation constant Cpi    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    IHelperProgram          constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
    bytes32 constant SPL_TOKEN = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9; // TokenkegQ...

    bytes32 immutable PRIVACY_PROGRAM;
    bytes32 immutable USDC_MINT;

    constructor(bytes32 program, bytes32 mint) {
        PRIVACY_PROGRAM = program; USDC_MINT = mint;
        Helper.create_pda(address(this));                 // die eigene Solana-Identität des Adapters
        Helper.create_ata(address(this), USDC_MINT);      // und ein USDC-Konto, das ihm gehört
    }

    function _salt(address user) internal pure returns (bytes32) { return bytes32(uint256(uint160(user))); }

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // Unterzeichner: die Autorität des Adapters
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // nutzerspezifisches Sub-PDA, unterzeichnet ebenfalls

        // Ziehe vom Tokenkonto des Nutzers. Die Autorität des Adapters unterzeichnet als SPL
        // Delegate, den der Nutzer gewährt hat; dies ist ein Legacy-Track-Aufruf, wie die CPI unten.
        Helper.transfer_spl(Helper.ata(msg.sender, USDC_MINT), adapterAta, amount, USDC_MINT);

        ICrossProgramInvocation.AccountMeta[] memory accs = new ICrossProgramInvocation.AccountMeta[](5);
        accs[0] = ICrossProgramInvocation.AccountMeta(self,       true,  true);
        accs[1] = ICrossProgramInvocation.AccountMeta(position,   true,  true);
        accs[2] = ICrossProgramInvocation.AccountMeta(adapterAta, false, true);                          // Quelle: im Besitz der Autorität des Adapters
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // Vault Ihres Programms
        accs[4] = ICrossProgramInvocation.AccountMeta(SPL_TOKEN, false, false);

        bytes32[] memory salts = new bytes32[](1);
        salts[0] = _salt(msg.sender);
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeDeposit(amount), salts);
    }

    function withdraw(uint64 amount) external {
        bytes32 position = Helper.pda_with_salt(address(this), _salt(msg.sender));
        bytes32 userAta  = Helper.ata(msg.sender, USDC_MINT);            // Ziel: das eigene Konto des Nutzers
        // ... gleiche Form: Ihr Programm bewegt `amount` vom Vault zu userAta, signiert von `position`
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

Der Adapter ruft nie den `wUSDC` Vertrag. Der Pull ist ein HelperProgram-Aufruf, der die Delegation des Nutzers ausgibt, und die Token liegen in einem Tokenkonto, das `external_auth(adapter)` besitzt, weshalb die CPI sie ausgeben kann.

Hinweise zum Signer. Rome unterzeichnet genau für zwei Kontentypen: die bloße Autorität des aufrufenden Vertrags (`Helper.pda(address(this))`), die ohne Auflistung in `Salts`unterzeichnet, und ein gesalzenes Sub-PDA pro Eintrag in `Salts`. Jeder von Ihnen aufgeführte Salt muss in der Kontenliste als Signer erscheinen, sonst schlägt der Aufruf fehl mit `unterzeichnendes Konto, das aus dem bereitgestellten Seed berechnet wurde, wurde nicht gefunden`. Jedes andere als Signer markierte Konto, einschließlich der eigenen Autorität des Nutzers, erhält von Rome keinen Seed, und die Solana-Runtime lehnt die CPI ab. Die Rechte des Nutzers an seinen Token stammen von der Delegation, niemals davon, dass der Adapter als Nutzer unterzeichnet.

Delegation ohne Pull: Wenn Ihr Programm direkt vom Tokenkonto des Nutzers ausgeben soll, sendet der Nutzer `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` direkt an das HelperProgram und benennt den PDA Ihres Programms als SPL-Delegate. Die Rome-Bridge verwendet dies für Wormhole. Die Ein-Delegate-Regel aus Abschnitt 3 gilt hier ebenfalls: Die Gewährung verdrängt die des Wrappers.

## 8. Testen

* Deployen gegen **Hadrian** (Testnetz, Chain 200010) zuerst; Adressen und RPC stehen in [Contract Addresses](https://docs.rome.builders/de/referenz/contract-addresses.md) und die [Registry](https://github.com/rome-protocol/rome-registry).
* `eth_call` und `eth_estimateGas` führen dieselbe Emulation aus, die der Proxy zum Senden verwendet, sodass eine CPI, die dort fehlschlägt, aus demselben Grund auf der Chain fehlschlägt, und die Revert-Daten den zugrunde liegenden Solana-Fehler tragen (`Nicht-EVM-Call-Fehler: …` im Log des Solana-Programms).
* Lesen Sie die Solana-Seite einer gelandeten EVM-Transaktion mit `rome_solanaTxForEvmTx(hash)`; im Solana-Beleg befinden sich CU und die Logs Ihres Programms.
* Eine CPI, die in `eth_call` funktioniert, aber beim Senden abgelehnt wird, hat meist eine Grenze ausgelöst, die die Emulation meldet: das 64-Adressen-Limit, das atomare CU-Budget (die Transaktion wurde iterativ) oder die Track-Regel.

## 9. Referenz

* [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md) — jeder Selector auf jedem Precompile, mit seiner Dispatch-Klasse und der Delegatecall-Regel.
* [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md) — die oben genannten Grenzen in einer Tabelle.
* [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.md) — Wrapper, kanonische Mints, Deposit und Withdraw.
* Referenz-Apps in den öffentlichen Repos: [cardo](https://github.com/rome-protocol/cardo) (der Nutzer ruft das CPI-Precompile direkt auf, Form B), [rome-dex](https://github.com/rome-protocol/rome-dex) (direkt `invoke` plus ein verwahrungsfreier Router, Form C), und [aerarium](https://github.com/rome-protocol/aerarium) (eine Compound-III-Lending-App über einen gemeinsam genutzten Markt; sie ruft keine Solana-Programme aus Solidity auf (keine CPI), also ist sie kein Beispiel für einen Adapter).


---

# 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/entwicklerleitfaden/integrate-solana-program.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.
