Non-EVM chains integration plan
STELLAR
I. Soroban is a key solution for integrating Stellar into the Asterizm protocol
Soroban, Stellar's smart contract platform, makes it possible to integrate Stellar into Asterizm by enabling complex programmable logic on Stellar, which was previously focused on fast payments and simple asset transfers. Soroban allows developers to build smart contracts with functionality similar to Ethereum's EVM, making it compatible with cross-chain protocols like Asterizm that rely on programmable contracts to execute secure cross-chain transactions. Here’s how Soroban facilitates this integration:
1. Support for Programmable Logic
Asterizm requires two key smart contracts on each chain (Initializer and Translator) to handle cross-chain messaging, validation, and transaction proof generation. With Soroban, Stellar can now support the deployment of such smart contracts.
Soroban Initializer: This smart contract can generate and validate cross-chain messages by creating unique transaction identifiers (xID) and cryptographic hashes. These are essential for ensuring the integrity of the cross-chain message.
Soroban Translator: This contract handles communication with the Asterizm relayer servers, sending and receiving transaction proofs (hash + xID). Soroban provides the ability to send these messages from Stellar to other chains and vice versa.
Soroban client smart contract Abstraction: This is a smart contract abstraction (template) that the client (dApp) must deploy when using Asterizm for cross-chain communication between Stellar, EVM, TON, and Solana.
2. Compatibility with Cross-Chain Protocols
Soroban brings Stellar closer to EVM-compatible environments, which makes it easier for protocols like Asterizm to interact with Stellar. Since Asterizm is designed to work across multiple blockchains, including non-EVM chains, Soroban’s flexibility allows Stellar to support the programmable smart contracts required by Asterizm without relying on third-party solutions.
Soroban allows Stellar to integrate into Asterizm in a way similar to EVM-based blockchains. This includes handling cross-chain transaction logic, generating unique transaction identifiers, and securely transmitting them via relayers.
3. Event-Driven Architecture
Cross-chain protocols like Asterizm rely on emitting events from smart contracts to trigger actions on other blockchains. Soroban's ability to emit events makes it possible to alert Asterizm relayers when a transaction is ready to be transmitted to another blockchain. This event-driven model is critical for synchronizing cross-chain actions.
When a transaction is initialized on Stellar, Soroban contracts emit the required events (such as xID and hash generation), which are then captured by the Asterizm relayer. This allows Stellar’s transactions to be securely communicated to other blockchains involved in the cross-chain messaging process.
4. Security and Validation
Soroban is built to handle the security requirements of cross-chain operations by providing strong cryptographic capabilities. For example, Soroban allows the secure generation of transaction hashes, which can be used to ensure that the correct payload is sent across chains. This is essential for Asterizm's cross-chain protocol, which relies on validating the integrity of messages between chains.
Soroban can securely store and validate these proofs, ensuring that cross-chain transactions are tamper-proof and adhere to Asterizm's validation requirements.
5. Stellar’s Low-Cost and High-Speed Transaction Model
One of Stellar’s key advantages is its fast and low-cost transaction model, which complements Asterizm’s goal of efficient and private cross-chain messaging. Soroban smart contracts can execute these operations at minimal cost compared to other blockchains, making it cost-effective to integrate Stellar into Asterizm's architecture for cross-chain messaging.
Conclusion
In summary, Soroban makes it possible to integrate Stellar into Asterizm by providing the necessary programmable smart contracts (Initializer and Translator), enabling cross-chain communication via event-driven logic, and offering secure cryptographic validation. This brings Stellar into the cross-chain ecosystem in a way that supports Asterizm’s privacy-focused and scalable cross-chain transactions. Soroban’s Rust-based development, flexibility, and security features provide all the tools necessary to seamlessly extend Stellar’s capabilities into Asterizm’s cross-chain protocol.
II. Stellar integration into Asterizm protocol (step-by-step plan)
To integrate Stellar into Asterizm using Soroban while following Asterizm’s cross-chain messaging architecture, we will need to follow a similar approach to how Asterizm integrates with other EVM-based chains. Here’s a step-by-step breakdown:
Asterizm Components and Their Role in Stellar Integration
Asterizm uses two types of smart contracts on both the source and destination chains: Initializer and Translator. These contracts ensure secure and private cross-chain messaging. The relayer software also plays a key role in transmitting proofs of transactions across chains.
Initializer Smart Contract:
Source chain role: Initializes cross-chain transactions, generates and stores transaction proofs (xID, hash).
Destination chain role: Receives the message, validates the proofs, and triggers the execution of the cross-chain transaction.
Translator Smart Contract:
Source chain role: Transmits proofs (hash, xID) to Asterizm Relayer Servers.
Destination chain role: Receives proofs from relayers and forwards them to the Initializer for validation.
Relayer Software:
Transmits cross-chain transaction proofs without accessing the actual transaction payload (for privacy and security).
Steps to Integrate Stellar via Soroban with Asterizm
1. Deploy Soroban Smart Contracts
Smart Contract Types:
Soroban Initializer: A smart contract that mimics the Asterizm Initializer’s functions. It will initialize the cross-chain transaction on Stellar, generate the xID and hash, and send the data to the Soroban Translator.
Soroban Translator: Responsible for transmitting transaction proofs (hash and xID) to the relayer software, and receiving them back from the relayer on the destination chain.
Soroban client smart contract Abstraction: This is a smart contract abstraction (template) that the client (dApp) must deploy when using Asterizm for cross-chain communication between Stellar, EVM, TON, and Solana.
Soroban supports the same basic operations required for this integration, such as emitting events, interacting with off-chain systems, and cryptographic hash functions.
Functionality:
On the source chain (Stellar), the Soroban Initializer will generate an xID and hash based on the transaction payload and send it to the Translator.
The Translator will forward this proof to the relayers via the client’s off-chain module (as detailed in the white paper), ensuring the cross-chain transaction is securely and privately initialized.
2. Relayer Software Upgrade
Stellar Support: Asterizm’s relayer software will need to be modified to recognize and process Stellar’s transactions. This involves:
Transaction Watching: The relayer should monitor the Stellar blockchain for specific events emitted by the Soroban Initializer and Translator contracts.
Cross-Chain Proof Transmission: Relayers must handle the hash and xID proof transmission to the destination chain.
Transaction Validation: After transmitting the proofs, the relayer must ensure that the destination chain’s Translator smart contract can successfully receive and validate the proof.
Stellar uses SCP (Stellar Consensus Protocol) for its consensus, which is quite different from EVM-based chains using PoS. However, this will not significantly affect the relayer’s role, as it primarily operates based on transaction and block confirmations.
3. Client Off-Chain Module
The client’s off-chain module (described as a Docker image) serves as a secure intermediary that passes the transaction payload between chains. This module should be adapted to handle Stellar’s transaction structure and integrate with Soroban smart contracts.
Data Handling: The off-chain module will transmit the payload to the destination chain, while the relayer handles the proofs separately to ensure data integrity.
4. Testing and Validation
Cross-Chain Messaging Test: After deploying the Soroban smart contracts and upgrading the relayer, we should conduct rigorous testing:
Sending Messages from Stellar: Verify that the Soroban Initializer on Stellar can successfully initiate a cross-chain transaction and send the xID/hash to the relayer.
Receiving Messages on Stellar: Ensure that Stellar’s Soroban Initializer can validate incoming cross-chain transactions from other networks, confirming the transaction's integrity via the xID and hash.
Additionally, we should ensure that message verification and execution on the destination chain (whether EVM or Stellar) works seamlessly.
III. Conclusion
Integrating Stellar into Asterizm using Soroban will involve deploying customized Soroban Initializer and Translator contracts that align with Asterizm’s architecture. The relayer software must be upgraded to handle Stellar’s SCP-based consensus and transaction structure. This integration will allow cross-chain transactions between Stellar and EVM-based chains, with the same level of privacy and security that Asterizm promises for its EVM integrations. The result is a seamless, confidential cross-chain messaging protocol that leverages Stellar’s low-cost, high-speed network.
Last updated