Solana aus EVM aufrufen

Romes CPI-Precompile ermöglicht es Solidity-Verträgen, jedes Solana-Programm direkt aufzurufen. Diese Anleitung erklärt die Funktionsweise.

Voraussetzungen

• Rome Solidity SDK installiert: npm install @rome-protocol/solidity-sdk

• Ein bereitgestellter Rome-Vertrag (siehe Solidity bereitstellen)

Das CPI-Precompile

Das CPI-Precompile unter 0xFF00000000000000000000000000000000000008 stellt zwei Funktionen bereit:

import {CpiProgram} from "@rome-protocol/solidity-sdk/contracts/core/Precompiles.sol";

// Ein Solana-Programm aufrufen
CpiProgram.invoke(programId, accounts, instructionData);

// Mit PDA-Signierung aufrufen (Ihr Vertrag signiert als PDA)
CpiProgram.invoke_signed(programId, accounts, data, seeds);

Einfaches Beispiel: SOL übertragen

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {SystemProgram, CpiProgram} from "@rome-protocol/solidity-sdk/contracts/core/Precompiles.sol";
import {RomeEVMAccount} from "@rome-protocol/solidity-sdk/contracts/core/RomeEVMAccount.sol";

contract SolTransfer {
    function transferSol(bytes32 recipient, uint64 lamports) external {
        // PDA des Absenders abrufen
        bytes32 senderPda = RomeEVMAccount.pda(msg.sender);

        // Transfer-Anweisung des Systemprogramms erstellen
        ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
        accounts[0] = ICrossProgramInvocation.AccountMeta(senderPda, true, true);   // Absender (Signaturgeber, schreibbar)
        accounts[1] = ICrossProgramInvocation.AccountMeta(recipient, false, true);   // Empfänger (schreibbar)

        // Transfer-Anweisung des Systemprogramms (Variante 2, u64-Betrag in Little-Endian)
        bytes memory data = abi.encodePacked(uint32(2), lamports);

        CpiProgram.invoke(SystemProgram.program_id(), accounts, data);
    }
}

Kontodaten lesen

Das CPI-Precompile ermöglicht es Ihnen auch, die Daten jedes beliebigen Solana-Kontos zu lesen:

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

Arbeiten mit SPL-Token

Verwenden Sie das SPL-Token-Precompile für gängige Token-Operationen:

import {SplToken, AssociatedSplToken} from "@rome-protocol/solidity-sdk/contracts/core/Precompiles.sol";

contract TokenOperations {
    // Das Guthaben eines Token-Kontos lesen
    function getBalance(bytes32 tokenAccount) external view returns (uint64) {
        ISplToken.Account memory acc = SplToken.account_state(tokenAccount);
        return acc.amount;
    }

    // SPL-Token übertragen
    function transferTokens(bytes32 recipientAta, bytes32 mint, uint256 amount) external {
        SplToken.transfer(recipientAta, mint, amount);
    }

    // Ein Associated Token Account erstellen
    function createAta(bytes32 wallet, bytes32 mint) external {
        AssociatedSplToken.create_associated_token_account(wallet, mint);
    }
}

PDA-Ableitung

Program-Derived-Addresses aus Solidity finden:

import {SystemProgram} from "@rome-protocol/solidity-sdk/contracts/core/Precompiles.sol";

// Eine PDA ableiten
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-Konvertierung

Zwischen bytes32 und base58 konvertieren (Solanas Adressformat):

// bytes32 → base58-String
bytes memory base58Str = SystemProgram.bytes32_to_base58(pubkey);

// base58-String → bytes32
bytes32 pubkey = SystemProgram.base58_to_bytes32(base58Bytes);

Benutzerdefinierte Solana-Programme aufrufen

Um ein beliebiges beliebiges Solana-Programm aufzurufen:

contract CustomCPI {
    bytes32 constant MY_PROGRAM = 0x...; // Ihre 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 einschließen, das die CPI berühren wird. Eine dynamische Kontenermittlung innerhalb der CPI ist nicht möglich.

2. CPI-Tiefenlimit: 4 Ebenen. Rome EVM → Ihr Ziel → Aufruf des Ziels → Eine weitere Ebene. Planen Sie Ihre Aufruftiefe sorgfältig.

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

4. Instruction-Daten sind rohe Bytes. Sie müssen die Instruction-Daten in dem Format kodieren, das das Zielprogramm erwartet (typischerweise Borsh-kodiert, Little-Endian).

Was kommt als Nächstes

• Token-Wrapping — ERC-20-Wrapper für SPL-Token bereitstellen

• Transfer Hook erstellen — EVM-gestützte Transfer-Hooks erstellen

• CU-Optimierung — den Verbrauch von Compute Units für CPI-Aufrufe reduzieren