Solana von EVM aus aufrufen

Rufe Solana-Programme aus Solidity über Roms CPI und Hilfs-Precompiles auf.

Romes Precompiles ermöglichen es Solidity-Contracts, Solana-Programme direkt aufzurufen. Dieser Leitfaden erklärt die Mechanik.

Voraussetzungen

• Die Rome-Solidity-Interfaces aus dem öffentlichen rome-solidity Repo (von GitHub installiert, nicht über npm — siehe Solidity bereitstellen) — die Precompile-Interfaces befinden sich in contracts/interface.sol

• Ein bereitgestellter Rome-Contract (siehe Solidity bereitstellen)

Binde jedes Interface an seine Precompile-Adresse:

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

ICrossProgramInvocation constant CpiProgram    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
ISystemProgram          constant SystemProgram = ISystemProgram(0xFF00000000000000000000000000000000000007);
IHelperProgram          constant Helper        = IHelperProgram(0xFF00000000000000000000000000000000000009);

Das CpiProgram-Precompile

CpiProgram (0xFF…08) führt CPI aus (aufrufen / invoke_signed) plus Cross-State-Lese-Abkürzungen (account_info, account_data_at, account_u64_at, account_lamports, pdas_batch_derive):

// Rufe ein Solana-Programm auf
CpiProgram.invoke(programId, accounts, instructionData);

// Aufruf mit PDA-Signatur: Das PDA der externen Autorität deines Contracts signiert, plus ein
// gesalzenes Unter-PDA pro Eintrag in `salts` (Rome leitet ["EXTERNAL_AUTHORITY", contract, salt] ab)
CpiProgram.invoke_signed(programId, accounts, data, salts);

Lamports übertragen

Für einfache Lamport- und SPL-Überweisungen verwende das HelperProgram-Precompile — kein manuell gebautes CPI nötig. Ein Contract, der es aufruft, verhält sich als selbst: Die untenstehenden Überweisungen bewegen die eigenen Lamports und Tokens des Contracts (sein External-Authority-PDA signiert), nicht die des Nutzers. Damit ein Contract die SPL-Tokens eines Nutzers in ein von ihm kontrolliertes Token-Konto ziehen und wissen kann, wem sie gehören, erteilt der Nutzer eine SPL-Delegation. Ein ERC-20 transfer oder transferFrom an einen Contract schreibt nur das Escrow-Ledger des Wrappers gut und gibt dem Contract kein Token-Konto, aus dem er ausgeben könnte — siehe Integrieren Sie ein Solana-Programm.

contract Transfers {
    IHelperProgram constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);

    // Übertrage Lamports von diesem Contract-PDA zu einem PDA einer EVM-Adresse
    function transferSol(address to, uint64 lamports) external {
        Helper.transfer_lamports(to, lamports);
    }

    // Übertrage ein SPL-Token aus dem diesem Contract-PDA gehörenden Token-Konto
    function transferSpl(address to, uint64 tokens, bytes32 mint) external {
        Helper.transfer_spl(to, tokens, mint);
    }

    // Erstelle das ATA des Aufrufers für ein Mint
    function createAta(bytes32 mint) external {
        Helper.create_ata(msg.sender, mint);
    }
}

transfer_spl hat mehrere Überladungen (einschließlich einer Delegate-Variante für transferFrom Flows); siehe interface.sol. Auf dem gecachten Pfad verwende ISplCached (0xff…05) / IAssociatedSplCached (0xff…06) stattdessen — ein Contract verwendet konsequent nur einen Pfad, und nur der Legacy-Pfad kann aufrufen ein benutzerdefiniertes Programm (siehe Integrieren Sie ein Solana-Programm).

Kontodaten lesen

Lies die Daten beliebiger Solana-Konten über die Lese-Abkürzungen von CpiProgram:

(
    uint64 lamports,
    bytes32 owner,
    bool isSigner,
    bool isWritable,
    bool executable,
    bytes memory data
) = CpiProgram.account_info(accountPubkey);

PDA-Ableitung

Finde Program Derived Addresses aus Solidity über das System-Precompile:

ISystemProgram.Seed[] memory seeds = new ISystemProgram.Seed[](2);
seeds[0] = ISystemProgram.Seed("my-program-seed");
seeds[1] = ISystemProgram.Seed(abi.encodePacked(someValue));

(bytes32 pda, uint8 bump) = SystemProgram.find_program_address(targetProgramId, seeds);

Base58-Umwandlung

Konvertiere zwischen bytes32 und Base58 (Solanas Adressformat):

bytes memory base58Str = SystemProgram.bytes32_to_base58(pubkey);
bytes32 pubkey = SystemProgram.base58_to_bytes32(base58Bytes);

Benutzerdefinierte Solana-Programme aufrufen

Um ein beliebiges Solana-Programm aufzurufen, erstelle die Kontoliste und die Instruktionsdaten selbst:

contract CustomCPI {
    ICrossProgramInvocation constant CpiProgram = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    bytes32 constant MY_PROGRAM = 0x0000000000000000000000000000000000000000000000000000000000000000; // deine Solana-Programm-ID

    function callMyProgram(bytes32 account1, bytes32 account2, bytes calldata ixData) external {
        ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
        accounts[0] = ICrossProgramInvocation.AccountMeta(account1, false, true);
        accounts[1] = ICrossProgramInvocation.AccountMeta(account2, false, false);

        CpiProgram.invoke(MY_PROGRAM, accounts, ixData);
    }
}

Wichtige Einschränkungen

1. Alle Konten müssen im Voraus deklariert werden. Die Solana-Transaktion muss jedes Konto enthalten, das das CPI berühren wird — dynamische Kontenermittlung innerhalb des CPI ist nicht möglich.

2. CPI-Tiefe begrenzt: 4 Ebenen. Rome EVM → dein Ziel → der Aufruf des Ziels → noch einer. Plane deine Aufruftiefe.

3. Solana-Pubkeys sind bytes32, keine 20-Byte-Ethereum-Adressen.

4. Instruktionsdaten sind rohe Bytes im Format, das das Zielprogramm erwartet (typischerweise Borsh, Little-Endian).

Was kommt als Nächstes

• Sieh es in einer realen App — cardo sendet CPI-Aufrufe direkt aus der Wallet des Nutzers an das Precompile, ohne Adapter-Contract; rome-dex (Dual-Lane-AMM) macht dasselbe und hat außerdem einen treuhandlosen Router-Contract; aerarium ist eine Lending-App, die keine Solana-Programme aus Solidity aufruft.

• Integrieren Sie ein Solana-Programm — die Solana-Identität des Nutzers, das Signieren als sie, die Ein-Pfad-Regel und die Kontobereitstellung für ein echtes Programm auf der anderen Seite

• Precompile-Referenz — jeder Selector auf jedem Precompile

• Call EVM from Solana — das Gegenteil: EVM-Contracts von einer Solana-Wallet aus steuern

• Token-Interop — wie ERC-20- und SPL-Tokens zusammenarbeiten

• Beschränkungen — CPI-Tiefe und andere Grenzen