Solana von EVM aus aufrufen

Romes CPI-Precompile ermöglicht es Solidity-Verträgen, jedes Solana-Programm direkt aufzurufen. Dieser Leitfaden behandelt die Mechanik.

Voraussetzungen

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

• Ein bereitgestellter Rome-Vertrag (siehe Solidity bereitstellen)

Der CPI-Precompile

Der 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);

// Aufruf mit PDA-Signatur (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-Instruktion des System Program erstellen
        ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
        accounts[0] = ICrossProgramInvocation.AccountMeta(senderPda, true, true);   // Absender (Signer, schreibbar)
        accounts[1] = ICrossProgramInvocation.AccountMeta(recipient, false, true);   // Empfänger (schreibbar)

        // Transfer-Instruktion des System Program (Variante 2, little-endian u64-Betrag)
        bytes memory data = abi.encodePacked(uint32(2), lamports);

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

Kontodaten lesen

Der CPI-Precompile ermöglicht es Ihnen außerdem, die Daten eines 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 {
    // 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

Konvertieren Sie zwischen bytes32 und base58 (dem Adressformat von Solana):

// 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 irgendein 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 enthalten, das der CPI berührt. Eine dynamische Kontoermittlung innerhalb von CPI ist nicht möglich.

2. CPI-Tiefe-Limit: 4 Ebenen. Rome EVM → Ihr Ziel → Aufruf des Ziels → Noch eine 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. Instruktionsdaten sind rohe Bytes. Sie müssen die Instruktionsdaten in dem Format kodieren, das das Zielprogramm erwartet (typischerweise Borsh-kodiert, little-endian).

Was kommt als Nächstes

• Token-Verpackung — ERC-20-Wrappers 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