Send Cross-Chain Message from Stellar to EVM

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { AxelarExecutable } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol';
import { IAxelarGasService } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol';
/**
 * @title Call Contract
 * @notice Receive a message from Stellar and store the GMP message
 */
contract CallContract is AxelarExecutable {
    string public message;
    string public sourceChain;
    string public sourceAddress;
    IAxelarGasService public immutable gasService;
    event Executed(bytes32 commandId, string sourceAddress, string message);
    /**
     * @param gateway address of axelar gateway on deployed chain
     * @param gasReceiver address of axelar gas service on deployed chain
     */
    constructor(address gateway, address gasReceiver) AxelarExecutable(gateway) {
        gasService = IAxelarGasService(gasReceiver);
    }
    /**
     * @notice Send message from chain A to chain B
     * @param destinationChain name of the dest chain (ex. "Fantom")
     * @param destinationAddress address on dest chain this tx is going to
     * @param _message message to be sent
     */
    function setRemoteValue(
        string calldata destinationChain,
        string calldata destinationAddress,
        string calldata _message
    ) external payable {
        require(msg.value > 0, 'Gas payment is required');
        bytes memory payload = abi.encode(_message);
        gasService.payNativeGasForContractCall{ value: msg.value }(
            address(this),
            destinationChain,
            destinationAddress,
            payload,
            msg.sender
        );
        gateway().callContract(destinationChain, destinationAddress, payload);
    }
    /**
     * @notice logic to be executed on the dest chain
     * @dev this is triggered automatically by the relayer
     * @param commandId Unique ID for this message
     * @param _sourceChain blockchain where tx is originating from
     * @param _sourceAddress address on src chain where tx is originating from
     * @param _payload encoded gmp message sent from src chain
     */
    function _execute(
        bytes32 commandId,
        string calldata _sourceChain,
        string calldata _sourceAddress,
        bytes calldata _payload
    ) internal override {
        (message) = abi.decode(_payload, (string));
        sourceChain = _sourceChain;
        sourceAddress = _sourceAddress;
        emit Executed(commandId, sourceAddress, message);
    }
}

[package]
name = "axelar-gmp"
version = "0.0.0"
edition = "2021"
publish = false
[lib]
crate-type = ["cdylib"]
doctest = false
[dependencies]
soroban-sdk =  {version = '22.0.6', features = ["alloc"]}
stellar-axelar-gateway = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", subdir = "contracts/stellar-axelar-gateway", features = [
    'library',
] }
stellar-axelar-gas-service = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", subdir = "contracts/stellar-axelar-gas-service", features = [
    'library',
] }
stellar-axelar-std = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", subdir = "packages/stellar-axelar-std" }
alloy-sol-types = "=0.7.6"
[dev-dependencies]
soroban-sdk = { version = '22.0.6', features = ["testutils"] }
[profile.release-with-logs]
inherits = "release"
debug-assertions = true

use soroban_sdk::contracttype;

#[contracttype]
#[derive(Clone, Debug)]
pub enum DataKey {
    Gateway,
    GasService,
    ReceivedMessage
}

use stellar_axelar_std::{Bytes, IntoEvent, String};

#[derive(Debug, PartialEq, Eq, IntoEvent)]
pub struct ExecutedEvent {
    pub source_chain: String,
    pub message_id: String,
    pub source_address: String,
    #[data]
    pub payload: Bytes,
}

use stellar_axelar_gateway::executable::AxelarExecutableInterface;
use stellar_axelar_std::types::Token;
use stellar_axelar_std::{Address, Env, String};

pub trait AxelarGMPInterface: AxelarExecutableInterface {
    /// Retrieves the address of the gas service.
    fn gas_service(env: &Env) -> Address;

    /// Sends a message to a specified destination chain.
    ///
    /// The function also handles the payment of gas for the cross-chain transaction.
    ///
    /// # Arguments
    /// * caller - The address of the caller initiating the message.
    /// * destination_chain - The name of the destination chain where the message will be sent.
    /// * destination_address - The address on the destination chain where the message will be sent.
    /// * message - The message to be sent.
    /// * gas_token - An optional gas token used to pay for gas during the transaction.
    ///
    /// # Authorization
    /// - The caller must authorize.
    fn send(
        env: &Env,
        caller: Address,
        destination_chain: String,
        destination_address: String,
        message: String,
        gas_token: Option<Token>,
    );

    /// Returns the most recently received message.
    fn received_message(env: &Env) -> String;
}

use crate::abi::alloc::{string::String as StdString, vec};
use alloy_sol_types::{sol_data, SolType};
use soroban_sdk::{contracterror, Bytes, Env, String};

extern crate alloc;

#[contracterror]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum AbiError {
    InvalidUtf8 = 1,
}

pub fn abi_encode(env: &Env, message: String) -> Result<Bytes, AbiError> {
    let message = to_std_string(message)?;
    let encoded = sol_data::String::abi_encode(&message);

    Ok(Bytes::from_slice(&env, &encoded))
}

/// Decodes an ABI-encoded `Bytes` (as created by `abi_encode`) back into a Soroban `String`.
pub fn abi_decode_string(env: &Env, encoded_bytes: Bytes) -> Result<String, AbiError> {
    // Bytes to Vec<u8> for decoding.
    let encoded_vec = encoded_bytes.to_alloc_vec();

    //Decode data into Rust String.
    let rust_string =
        sol_data::String::abi_decode(&encoded_vec, true).map_err(|_| AbiError::InvalidUtf8)?;

    // Rust String to Soroban String
    Ok(String::from_str(env, &rust_string))
}

// soroban string to std string
fn to_std_string(soroban_string: String) -> Result<StdString, AbiError> {
    let length = soroban_string.len() as usize;
    let mut bytes = vec![0u8; length];

    soroban_string.copy_into_slice(&mut bytes);
    StdString::from_utf8(bytes).map_err(|_| AbiError::InvalidUtf8)
}

use stellar_axelar_gas_service::AxelarGasServiceClient;
use stellar_axelar_gateway::executable::{AxelarExecutableInterface, CustomAxelarExecutable};
use stellar_axelar_gateway::AxelarGatewayMessagingClient;
use stellar_axelar_std::events::Event;
use stellar_axelar_std::types::Token;
use stellar_axelar_std::{
    contract, contracterror, contractimpl, soroban_sdk, Address, AxelarExecutable,
    Bytes, Env, String,
};

use crate::event::ExecutedEvent;
use crate::interface::AxelarGMPInterface;
use crate::storage::DataKey;
use crate::abi::{abi_decode_string, abi_encode};

#[contract]
#[derive(AxelarExecutable)]
pub struct AxelarGMP;

#[contracterror]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum AxelarGMPError {
    NotApproved = 1,
    FailedDecoding = 2,
}

impl CustomAxelarExecutable for AxelarGMP {
    type Error = AxelarGMPError;

    fn __gateway(env: &Env) -> Address {
        env.storage().instance().get(&DataKey::Gateway).unwrap()
    }

    fn __execute(
        env: &Env,
        source_chain: String,
        message_id: String,
        source_address: String,
        payload: Bytes,
    ) -> Result<(), Self::Error> {
        let decoded_msg = abi_decode_string(env, payload.clone()).map_err(|_| AxelarGMPError::FailedDecoding)?;

        // Store the received message
        env.storage().instance().set(&DataKey::ReceivedMessage, &decoded_msg);

        // Emit event
        ExecutedEvent {
            source_chain,
            message_id,
            source_address,
            payload,
        }
        .emit(env);

        Ok(())
    }
}

#[contractimpl]
impl AxelarGMP {
    pub fn __constructor(
        env: &Env,
        gateway: Address,
        gas_service: Address,
    ) {
        env.storage().instance().set(&DataKey::Gateway, &gateway);
        env.storage().instance().set(&DataKey::GasService, &gas_service);
    }
}

#[contractimpl]
impl AxelarGMPInterface for AxelarGMP {
    fn gas_service(env: &Env) -> Address {
        env.storage().instance().get(&DataKey::GasService).unwrap()
    }

    fn send(
        env: &Env,
        caller: Address,
        destination_chain: String,
        destination_address: String,
        message: String,
        gas_token: Option<Token>,
    ) {
        let gateway = AxelarGatewayMessagingClient::new(env, &Self::gateway(env));
        let gas_service = AxelarGasServiceClient::new(env, &Self::gas_service(env));

        caller.require_auth();

        let encoded_msg = abi_encode(env, message).unwrap();

        if let Some(gas_token) = gas_token {
            gas_service.pay_gas(
                &env.current_contract_address(),
                &destination_chain,
                &destination_address,
                &encoded_msg,
                &caller,
                &gas_token,
                &Bytes::new(env),
            );
        }

        gateway.call_contract(
            &env.current_contract_address(),
            &destination_chain,
            &destination_address,
            &encoded_msg,
        );
    }

    fn received_message(env: &Env) -> String {
        env.storage().instance().get(&DataKey::ReceivedMessage)
            .unwrap_or_else(|| String::from_str(env, ""))
    }
}

#![no_std]

mod contract;
pub mod event;
pub mod interface;
mod storage;
pub mod abi;

pub use contract::{AxelarGMP, AxelarGMPClient};

ℹ️  Signing transaction: f05a2850aa49cb7172ac505e7c957a343ef8a21b2f151c9c936f3e8587b0cfa9
📅 CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC - Event: [{"symbol":"transfer"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"address":"CAZUKAFB5XHZKFZR7B5HIKB6BBMYSZIV3V2VWFTQWKYEMONWK2ZLTZCT"},{"string":"native"}] = {"i128":{"hi":0,"lo":10000000000}}
📅 CAZUKAFB5XHZKFZR7B5HIKB6BBMYSZIV3V2VWFTQWKYEMONWK2ZLTZCT - Event: [{"symbol":"gas_paid"},{"address":"CD66IHACNJOMCDCCL53GM3WTM3OHQFHOCOIM7NDJFF7TBPYQEU76OVBQ"},{"string":"avalanche"},{"string":"0x88f179ec476447a7219e5dc009cEF6f5848CBd29"},{"bytes":"40359292f954d7616ec60b4c1c79b9b9b02a4afdbadc665a6c0b8a5c09837230"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"map":[{"key":{"symbol":"address"},"val":{"address":"CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC"}},{"key":{"symbol":"amount"},"val":{"i128":{"hi":0,"lo":10000000000}}}]}] = {"vec":[{"bytes":""}]}
📅 CCSNWHMQSPTW4PS7L32OIMH7Z6NFNCKYZKNFSWRSYX7MK64KHBDZDT5I - Event: [{"symbol":"contract_called"},{"address":"CD66IHACNJOMCDCCL53GM3WTM3OHQFHOCOIM7NDJFF7TBPYQEU76OVBQ"},{"string":"avalanche"},{"string":"0x88f179ec476447a7219e5dc009cEF6f5848CBd29"},{"bytes":"40359292f954d7616ec60b4c1c79b9b9b02a4afdbadc665a6c0b8a5c09837230"}] = {"vec":[{"bytes":"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001348656c6c6f2066726f6d205374656c6c61722100000000000000000000000000"}]}