In this next edition of the ongoing series covering the Lisk interoperability solution, we discuss the salt and pepper of interoperability: cross-chain messages. In the , Maxime Gagnebin presented the cross-chain updates, the transactions used to exchange information between chains in the Lisk ecosystem. A brief summary of this is given below, however it is highly recommended to read the entire blog post, before diving into cross-chain messages. Furthermore, Maxime also discussed cross-chain messages at . previous blog post Lisk.js If cross-chain updates are the envelopes used to deliver information from one chain to another, cross-chain messages are the actual content inside the envelope. Users can send messages from one chain to another to move tokens, send information, or in general implement any kind of cross-chain custom logic. Overview To understand why we need cross-chain messages, it is better to start from the very basics. Stripping it down to the essentials, a blockchain is a distributed database. At any given time, the database is in one of finitely many precise states (also called ). For example, the state of the blockchain could correspond to Alice having 5 LSK and Bob having no LSK. The blockchain can undergo and move from one database state to another. Users can trigger a state transition by sending a . Each transaction contains a that, once executed, changes the state of the database. For instance, Alice can send 2 LSK to Bob by issuing a LSK transfer command. Batches of transactions are regularly collected into blocks which are sent across the network to keep the distributed database in sync. finite-state machine state transitions transaction command However, not all state transitions are allowed. In general, the set of valid state transitions depends on the current state of the blockchain. In the previous example, a command sending 10 LSK from Alice to Bob would be invalid, as Alice does not have enough LSK. The rules defining the valid state transitions are called the blockchain protocol (again, we are simplifying things somewhat here, as the consensus rules are also part of the protocol). But what happens if we have two blockchains running independently from each other? How can users of blockchain A trigger a state transition on blockchain B? An obvious way would be to just send a transaction to blockchain B directly. This transaction however can only be validated against the state of blockchain B. What we really want instead is to trigger a state transition on blockchain B from blockchain A (validating it against the state of blockchain A). Here is where come into play. A cross-chain transaction is a transaction that, upon its execution, creates one or more . Cross-chain messages are a new data structure introduced with interoperability. They play a similar role to transactions, in the sense that they contain a . In analogy with commands, cross-chain commands induce a state transition in the receiving chain. Several cross-chain messages are collected together and posted to another chain as part of a cross-chain update (again, more information can be found in the ). cross-chain transactions cross-chain messages cross-chain command previous blog post Hence, cross-chain commands are validated in the sending chain. In the receiving chain, the validity of the cross-chain messages can be assumed (there are certain checks that are performed to the cross-chain update that guarantee the validity of all cross-chain messages contained in it). If the cross-chain message is also valid with respect to the state of the receiving chain, the state transition can be finally processed. Alice can now send 2 LSK she has on blockchain A to Bob on blockchain B. To do that, she issues a cross-chain LSK transfer command on blockchain A. The command creates a cross-chain message which is included in a cross-chain update command included in blockchain B. The cross-chain update is processed along with all cross-chain messages contained in it, including Alice’s LSK transfer. Bob finally gets his 2 LSK directly on blockchain B. Hurray! Terminology Summary An envelope object for a command. Transaction: Trigger of a state transition in the same chain. Command: Transaction generating one or more cross-chain messages. Cross-chain transaction: An envelope object for a cross-chain command. Cross-chain message: Trigger of a state transition coming from another chain. Cross-chain command: A special command containing cross-chain messages. Cross-chain updates: Format of Cross-chain Messages In this section, we briefly describe the properties common to all cross-chain messages (see LIP " " for more information). Introduce cross-chain messages Sending Chain ID and Receiving Chain ID As previously explained, cross-chain messages are spawned in one blockchain and processed in another. The blockchain where the cross-chain message is created is called the sending chain and it is identified by the sending chain ID. The blockchain where the message is processed is called the receiving chain and is identified by the receiving chain ID. The mainchain uses the receiving chain ID to route the message to the correct chain. Nonce This property counts the total number of messages that were sent from the sending chain. When a cross-chain message is created, it is automatically assigned the correct nonce. The mainchain does not update this value when a message is routed. Module ID and Cross-chain Command ID Similar to transactions, cross-chain messages have a module ID and a cross-chain command ID. The module ID and the cross-chain command ID are used to identify the logic that should be processed in the receiving chain. Fee Transaction fees pay for the processing on the sending chain. Similarly, message fees pay for the processing on the receiving chain. Message fees are paid in LSK in the whole ecosystem. When routing a message, the mainchain also transfers LSK from the sending to the receiving chain to account for the transferred fees. Status The status property is used for error handling. If it is not possible to deliver a cross-chain message (for example if the receiving chain does not exist), the status of the message is updated and the message is routed back to the sending chain. The sending chain can then process the failed message and potentially refund users. Currently, interoperability supports 5 status codes. The status used for error handling describes the reason for the message failure as shown below: : the default status of a cross-chain message. OK : status assigned on the receiving chain if it does not implement any module with ID equal to the message module ID. MODULE_NOT_SUPPORTED : status assigned on the receiving chain if it does not implement any command with ID equal to the message command ID. CROSS_CHAIN_COMMAND_NOT_SUPPORTED : status assigned on the mainchain if the receiving chain is not available (it does not exist, it is not active, or it has been terminated). CHANNEL_UNAVAILABLE : status assigned on the mainchain to a cross-chain message after it has been recovered from the outbox of a terminated sidechain (more information will be provided in a future blog post). RECOVERED Modules can introduce new values for the status property, which can be used for custom error handling. Notice that the first 64 error codes are reserved for the Interoperability module. For instance, the new Token module defines the status to indicate that a cross-chain token transfer is invalid because the receiving chain does not support that specific token. TOKEN_NOT_SUPPORTED Params Similar to transactions, the params property contains the specific parameters used to process the cross-chain message. This property is defined by the relevant module and can follow any schema. Notice that the mainchain does not deserialize nor validate this property when routing a message. Cross-chain Messages of the Interoperability Module There are 4 special cross-chain messages that are used to facilitate interoperability. A brief description of these messages is covered below in this section. Cross-chain Update Receipt The cross-chain update receipt acknowledges the inclusion of a cross-chain update transaction. The receiving chain automatically generates this message, which is then sent back to the sending chain. The cross-chain update receipt contains the following properties: : the fee of the cross-chain update. This property can be used back in the sending chain to reimburse the relayer, for instance (recall that the relayer is the user that prepared and sent the cross-chain update). paidFee : the address of the relayer. relayerAddress : the size of the inbox in the receiving chain. This property informs the sending chain on the number of messages that have been processed on the receiving chain. In general, the size of the outbox on the sending chain is not equal to the size of the inbox in the receiving chain (as, for example, a cross-chain update has not been posted on the receiving chain yet). This property allows users to recover unprocessed messages from a terminated sidechain outbox. partnerChainInboxSize Channel Terminated Message When a sidechain is terminated, the mainchain automatically generates a channel terminated message and sends it to the terminated sidechain. This message also contains the property. partnerChainInboxSize Registration Message When a sidechain registers on the mainchain, a registration message is generated to acknowledge the successful registration. This message contains the network ID and the name of the sidechain. The network ID and name included in the mainchain registration transaction (see "Mainchain registration process" in the blog post " ") must match these values, guaranteeing their correctness. The Lifecycle of a Sidechain in the Lisk Ecosystem Sidechain Terminated Message The sidechain terminated message is created on the mainchain when a message should be routed to a terminated or inactive chain. This message is sent to the original sending chain, allowing it to create a terminated sidechain account which can then be used for the recovery commands. It contains the chain ID and the last certified state root of the terminated sidechain. Life Cycle of a Cross-chain Message In this section, we summarize again the main features of Lisk interoperability from the point of view of a cross-chain message. : The Lisk ecosystem is organized in a star topology: Each sidechain is connected to the Lisk mainchain. Sidechain-to-sidechain cross-chain messages are always first posted on the mainchain. The mainchain is then responsible for delivering the message to the correct receiving chain. Notice that in doing so, the mainchain does not process the message, but merely moves it from the inbox of the sending chain to the outbox of the receiving chain. Mainchain routing : While delivering messages, the mainchain also provides a base level of error handling: If the receiving chain does not exist, is not active, or has been terminated, the message is sent back to the sending chain with status set to and sending chain ID and receiving chain ID swapped. The original sending sidechain can process this, and, for instance, revert it. In general, mainchain error handling allows sidechains to send messages without monitoring the status of other chains. Mainchain error handling CHANNEL_UNAVAILABLE : On the other hand, sometimes a cross-chain message can be errored only once it reaches the receiving chain. As mentioned above, the Interoperability module provides the predefined error codes and . In addition, custom modules can introduce new error codes. Sidechain error handling MODULE_NOT_SUPPORTED CROSS_CHAIN_COMMAND_NOT_SUPPORTED : All messages are uniquely identified in the ecosystem by the ( ) tuple. Messages that have been sent back from the mainchain with status are instead identified by the ( ) tuple, since the sending and receiving chain IDs have been swapped. This property is very useful to track messages throughout the ecosystem, for instance using a UI tool. Furthermore, just as for transactions, we define the cross-chain message ID to be the hash of the serialized message object. Message tracking sendingChainID, nonce CHANNEL_UNAVAILABLE receivingChainID, nonce It is easier to follow the path of a cross-chain message in the ecosystem with two concrete examples. Notice that in both these examples, the user starting the process, Alice, only has to care about sending the initial cross-chain command. From her point of view, everything else happens automagically. Mainchain-to-sidechain LSK transfer Arguably the most important cross-chain message, and one that many users will actually use, is the . cross-chain LSK transfer LSK are the native tokens of the Lisk mainchain. This means that originally all LSK are stored on the mainchain. LSK tokens are used to power interoperability: All cross-chain messages fees are paid in LSK, and cross-chain updates posted on the mainchain pay a fee in LSK (just as any other mainchain transaction). Therefore, users need to move their LSK to a sidechain to start sending cross-chain commands from there. The first step is to send a cross-chain LSK transfer command on the mainchain, targeting the sidechain. Alice has 10 LSK on the Lisk mainchain and she wants to send 5 LSK to her account on sidechain A. The complete process of transferring LSK from the mainchain to a sidechain looks like this: 1. Alice sends a cross-chain LSK transfer command with the following parameters: {

tokenID = {"chainID": 1, "localID": 0} : the ID of the LSK token

amount = 5 : the amount of LSK to transfer

receivingChainID = 16 : the ID of sidechain A

recipientAddress = 0x0a11ce : Alice’s address

data = "" : Alice could add a custom message in this field

messageFee = 0.01 : the fee associated to the message

} 2. Alice is debited the 5 LSK on the mainchain. 3. The command spawns a cross-chain message with the following parameters: {

nonce = 21 : in this example, the current mainchain nonce

moduleID = MODULE_ID_TOKEN : ID of the token module

crossChainCommandID = 0 : ID of the token transfer cross-chain command

sendingChainID = 1 : ID of the Lisk mainchain

receivingChainID = 16 : ID of sidechain A

fee = 0.01 : message fee specified in the command

status = OK : default status of a cross-chain message

params = {
              tokenID = {"chainID": 1, "localID": 0} =

          amount = 5

          senderAddress = 0x0a11ce

          recipientAddress = 0x0a11ce

          data = ""

       } : these parameters correspond to the command parameters
} 4. The cross-chain message is added to the sidechain A outbox. 5. The cross-chain message is included in a cross-chain update posted on sidechain A. 6. The cross-chain update is processed on sidechain A. The cross-chain message is added to the mainchain inbox and has its effect. Alice is credited with 5 LSK on sidechain A. 🎉 Sidechain-to-sidechain Custom Message Sidechain-to-sidechain messages are the humus on which a rich interoperability ecosystem can flourish. The Lisk interoperability provides the general protocol for exchanging messages, but the real fun happens with the custom cross-chain commands and messages developers create for the blockchain applications. As previously mentioned, the mainchain does not process custom cross-chain messages but only routes them without even looking at them. Alice decides to send a cross-chain message from sidechain A to sidechain B. The effect of this message on sidechain B is part of its protocol, and here we do not care about the specific functionality, only about the general procedure. Alice sends a custom cross-chain transaction with some custom parameters. The command is processed on sidechain A. The command spawns a cross-chain message with the following parameters: {

nonce = 22 : in this example, the current sidechain A nonce

moduleID = 1034 : ID of the custom module

crossChainCommandID = 2 : ID of the custom cross-chain command

sendingChainID = 16 : ID of sidechain A

receivingChainID = 42 : ID of sidechain B

fee = messageFee : message fee specified in the command

status = OK : default status of a cross-chain message

params : custom parameters of the cross-chain message

} The cross-chain message is added to the mainchain outbox. The cross-chain message is included in a cross-chain update posted on the mainchain. The cross-chain update is processed on the mainchain. The cross-chain message is added to the sidechain A inbox and immediately added to the sidechain B outbox. The cross-chain message is included in a cross-chain update posted on sidechain B. The cross-chain update is processed on sidechain B. The cross-chain message is added to the mainchain inbox and has its effect on sidechain B. Something went wrong! An error occurred during the processing of the message, for instance, sidechain B does not support the cross-chain command ID. A new message is then created: {

nonce = 31 : in this example, the current sidechain B nonce

moduleID = 34 : ID of the custom module

crossChainCommandID = 2 : ID of the custom cross-chain command

sendingChainID = 42 : ID of sidechain B

receivingChainID = 16 : ID of sidechain A

fee = 0 : message fee is set to 0, no one is paying for the error

status = CROSS_CHAIN_COMMAND_NOT_SUPPORTED : error status for invalid cross-chain command

params : custom parameters of the cross-chain message

} The error message is added to the mainchain outbox. The cross-chain message is included in a cross-chain update posted on the mainchain. The cross-chain update is processed on the mainchain. The cross-chain message is added to the sidechain B inbox and immediately added to the sidechain A outbox. The cross-chain message is included in a cross-chain update posted on sidechain A. The cross-chain update is processed on sidechain A. The cross-chain message is added to the mainchain inbox and has its effect on sidechain A. In particular, the error code is used to trigger the correct processing logic (for instance, the message could be simply reverted). Conclusion and Next Topic This blog post has presented the cross-chain messages in detail. We discussed the general procedure to send a cross-chain message between two interoperable chains and described the format of a cross-chain message. The Interoperability module will contain 4 standard messages by default, while the Token module allows the transfer of standard tokens between chains with the cross-chain token transfer command. Custom modules can implement new cross-chain commands in a similar manner to normal custom commands. The details of the Token module will be presented in the next blog post.

Chain

fees

Lisk

YouTube

Lisk Preparing for AmpliFire: A Hybrid Event for Blockchain Enthusiasts

Cross-chain Communication and the Role of CCU

Visit us

Too Long; Didn't Read

CTA: Download the FREE AI Productivity Shift report

Blockchain Interoperability: What Do Cross-Chain Messages Do Anyway

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

How Enevti Drives NFT Evolution with Lisk

(1/100) Crypto Countdown: Golem

A Research Report on the Trader $JOE DeFi Platform

07/03/2018: Biggest Stories in the Cryptosphere

05/02/2018: Biggest Stories in the Cryptosphere

How Enevti Drives NFT Evolution with Lisk

(1/100) Crypto Countdown: Golem

A Research Report on the Trader $JOE DeFi Platform

07/03/2018: Biggest Stories in the Cryptosphere

05/02/2018: Biggest Stories in the Cryptosphere

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps