DeXTT: Deterministic Cross-Blockchain Token Transfers

TL;DR

DeXTT introduces a decentralized protocol enabling simultaneous token transfers across multiple blockchains, enhancing interoperability and scalability in blockchain systems.

Contribution

It presents the first protocol for deterministic, multi-chain token transfers with a reference implementation and performance analysis.

Findings

Logarithmic scalability with respect to nodes

Efficient cost requirements for token transfers

Decentralized multi-chain token transfer capability

Abstract

Current blockchain technologies provide very limited interoperability. Restrictions with regards to asset transfers and data exchange between different blockchains reduce usability and comfort for users, and hinder novel developments within the blockchain space. As a first step towards cross-blockchain interoperability, we propose the DeXTT cross-blockchain transfer protocol, which can be used to transfer a token on any number of blockchains simultaneously in a decentralized manner. We provide a reference implementation using Solidity, and evaluate its performance. We show logarithmic scalability of DeXTT with respect to the number of participating nodes, and analyze cost requirements of the transferred tokens.

Tables

Table 1. TABLE V: Cost Analysis

	Cost (kGas)			Cost (USD)
Transaction	Mean	$\sigma$		Mean	$\sigma$
claim	$57.7$	$11.1$		$0.0668$	$0.0128$
contest	$81.5$	$64.2$		$0.0943$	$0.0743$
finalize	$45.5$	$0.1$		$0.0527$
veto	$131.3$	$91.9$		$0.1520$	$0.1063$
finalize-veto	$48.6$	$1.7$		$0.0563$	$0.0020$

Equations

$$\displaystyle\begin{aligned} \mathcal{W}_{w}:\textsc{trans}~{}&\Big{[}~{}a,\,b,\,c~{}\Big{]}_{\sigma}\end{aligned}$$

$$\Big{[}~{}\mathcal{W}_{s}\xrightarrow{x}\mathcal{W}_{d},\,t_{0},\,t_{1}~{}\Big{]}_{\alpha}$$

$$\Big{[}~{}\mathcal{W}_{s}\xrightarrow{x}\mathcal{W}_{d},\,t_{0},\,t_{1},\,\alpha~{}\Big{]}_{\beta}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{d}:\textsc{claim}~{}&\Big{[}~{}\mathcal{W}_{s}\xrightarrow{x}\mathcal{W}_{d},\,t_{0},\,t_{1},\,\alpha~{}\Big{]}_{\beta}\end{aligned}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{d}:\textsc{claim}~{}&\Big{[}~{}\mathcal{W}_{s}\xrightarrow{20}\mathcal{W}_{d},\,1,\,61,\,\texttt{0xAA}~{}\Big{]}_{\texttt{0xBB}}\end{aligned}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{o}:\textsc{contest}~{}&\Big{[}~{}\mathcal{W}_{s}\xrightarrow{x}\mathcal{W}_{d},\,t_{0},\,t_{1},\,\alpha,\,\beta~{}\Big{]}_{\omega}\end{aligned}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{u}:\textsc{contest}~{}&\Big{[}~{}\mathcal{W}_{s}\xrightarrow{20}\mathcal{W}_{d},\,1,\,61,\,\texttt{0xAA},\,\texttt{0xBB}~{}\Big{]}_{\texttt{0xC2}}\end{aligned}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{v}:\textsc{contest}~{}&\Big{[}~{}\mathcal{W}_{s}\xrightarrow{20}\mathcal{W}_{d},\,1,\,61,\,\texttt{0xAA},\,\texttt{0xBB}~{}\Big{]}_{\texttt{0xC3}}\end{aligned}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{w}:\textsc{contest}~{}&\Big{[}~{}\mathcal{W}_{s}\xrightarrow{20}\mathcal{W}_{d},\,1,\,61,\,\texttt{0xAA},\,\texttt{0xBB}~{}\Big{]}_{\texttt{0xC1}}\end{aligned}$$

$$\displaystyle\begin{aligned} \textsc{finalize}~{}&\Big{[}~{}\alpha~{}\Big{]}\end{aligned}$$

$$\displaystyle\begin{aligned} \mathcal{W}_{w}:\textsc{veto}~{}&\Big{[}~{}\alpha,\,\mathcal{W}_{s}\xrightarrow{x^{\prime}}\mathcal{W}_{d^{\prime}},\,t_{0}^{\prime},\,t_{1}^{\prime},\,\alpha^{\prime}~{}\Big{]}_{\omega}\end{aligned}$$

$$t_{\text{textsc}veto}=\max (t_1,t_1^{\prime })+\max (t_1-t_0,t_1^{\prime }-t_0^{\prime })$$

$$\displaystyle\begin{aligned} \textsc{finalize-veto}~{}&\Big{[}~{}\alpha,\,\alpha^{\prime}~{}\Big{]}\end{aligned}$$

$$\frac{{\log }_{2}n}{n}p>0.94\text{[USD]}$$

Full text

As a first step towards cross-blockchain interoperability, we propose the DeXTT cross-blockchain transfer protocol, which can be used to transfer a token on any number of blockchains simultaneously in a decentralized manner. We provide a reference implementation using Solidity, and evaluate its performance. We show logarithmic scalability of DeXTT with respect to the number of participating nodes, and analyze cost requirements of the transferred tokens.

I Introduction

Blockchains, the underlying technology of cryptocurrencies, have gained significant interest in both industry and research [31]. After the feasibility of decentralized ledgers has been demonstrated by Bitcoin [21], significant investment into research and development related to blockchains and cryptocurrencies was sparked. Technologies range from adding new layers on top of existing blockchain implementations [7, 25], improvements of Bitcoin itself [19], to entirely new blockchains [26], which provide novel concepts, such as smart contracts [6].

The level of investment in the blockchain space is indicative for the technological impact and the broad range of potential use cases for blockchain technologies [11]. However, despite this positive momentum, structural problems exist within the blockchain field. Development so far is centered on the creation of new blockchains and currencies, or altering major blockchains like Bitcoin [28]. Furthermore, there is substantial research on potential use cases of blockchains in various economic, social, political, and engineering fields [11]. Nevertheless, the ways in which blockchains could potentially interact with each other remain mostly unexplored.

The constant increase in the number of independent, unconnected blockchain technologies causes significant fragmentation of the research and development field, and poses challenges for both users and developers of blockchain technologies. On the one hand, users have to choose which currency and which blockchain to use. Choosing novel, innovative blockchains enables users to utilize new features and take advantage of state-of-the-art technology. However, users also risk the loss of funds if the security of such a novel blockchain is subsequently breached, potentially leading to a total loss of funds [22]. Choosing mature, well-known blockchains reduces the risk of such loss, since these blockchains are more likely to have been analyzed in-depth [18], but novel features remain unavailable.

On the other hand, when designing decentralized blockchain-based applications, currently, developers must decide which blockchain to base their application on. This can form a substantial impedance to research and technical progress, since individual technologies form isolated solutions, and interoperability between blockchains is mostly not given.

We therefore aim to enable cross-blockchain interoperability. As an overarching goal, we seek to provide means of interaction between blockchains, including cross-blockchain data transmission, cross-blockchain smart contract interaction, or cross-blockchain currency transfer. As a first step to enable such cross-blockchain interoperability, we propose a protocol for cross-blockchain token transfers, where the transferred token is not locked within an individual blockchain. Instead, it can be used on any number of blockchains, and its transactions are autonomously synchronized across blockchains by the system in a decentralized manner. Our solution prevents double spending, is resilient to the cross-blockchain proof problem (XPP) [4], and does not need external oracles or other means of cross-blockchain communication to function. We provide a reference implementation using Solidity, and evaluate its performance with regards to time and cost.

The contributions of this manuscript are as follows:

• •

We discuss how to use eventual consistency for cross-blockchain token transfers by utilizing concepts such as claim-first transactions and deterministic witnesses.

• •

We formally define Deterministic Cross-Blockchain Token Transfers (DeXTT), a protocol which implements eventual consistency for cross-blockchain token transfers.

• •

We provide a reference implementation in Solidity, presenting and evaluating DeXTT.

The remainder of this paper is structured as follows. In Section II, we discuss underlying technologies, provide a brief discussion of blockchains and transaction types, claim-first transactions, and witness rewards, and define notation used throughout this work. Section III presents the transfer protocol in detail, and Section IV provides an evaluation of our approach. Section V gives a brief overview of related work, and describes the relation of the work at hand to our own former work in the field of cross-blockchain interoperability. Finally, Section VI concludes the paper.

II Background

Our work aims at providing a protocol for cross-blockchain asset transfers, ensuring that such transfers are performed in a decentralized and trustworthy manner. Assets can be represented on blockchains in various ways. Apart from native currencies (e.g., Ether on the Ethereum blockchain, or Bitcoin on the Bitcoin blockchain), there are other types of assets, commonly called tokens. In the recent past, various asset types with different properties have been discussed, such as fungibility, divisibility, and types of implementation like the user-issued asset (UIA) and Unspent Transaction Output (UTXO) models. We refer to our previous work for a thorough analysis [3].

In the work at hand, we discuss a token that exists on a given number of blockchains simultaneously, i.e., a pan-blockchain token (denoted as PBT). PBT are not locked to a single blockchain and can be traded using the DeXTT protocol, which ensured synchronization of token balances across blockchains. We refer to the set of blockchains participating in this protocol as an ecosystem of blockchains. According to our protocol, a wallet $\mathcal{W}_{w}$ is holding PBT not only on a given blockchain, but on all blockchains in the ecosystem. Thus, a transfer from $\mathcal{W}_{w}$ to another wallet $\mathcal{W}_{v}$ is required to be recorded on all participating blockchains, and there must be consensus among all participating blockchains about the balance of each wallet.

Due to the XPP [4], strict consistency between blockchains is not possible using practical means, since any verification of data between two blockchains would essentially require the nodes of one blockchain to verify blocks of another blockchain. This requires both the data and the consensus protocol to be shared across blockchains, which is not possible in practice. Therefore, in our proposal, we relax this requirement to eventual consistency, i.e., we accept temporary disagreement with regard to balances, as we show in the following. In practice, blockchains themselves only provide eventual consistency, since there is no guarantee when data submitted to the network will be included in a block. Therefore, using eventual consistency for synchronizing data between blockchains is a feasible approach.

For the purpose of this paper, we follow the assumption that each party is generally interested in all the blockchains in an ecosystem, and specifically, in the consistency of their balance across all blockchains. This means that all interested parties (i.e., wallet holders) are monitoring all blockchains in the ecosystem, and if a party participates in the protocol on one blockchain, it also participates on all other blockchains. We support this assumption by defining later that any inconsistency in wallet balances between blockchains effectively renders the wallet useless.

DeXTT assumes that non-zero token balances already exist on the involved blockchains. We explicitly do not define the economic aspect of PBT, i.e., the lifecycle of tokens. Several minting strategies exist, and we provide an overview of such approaches (constant supply, minting rate, etc.) in previous work [3]. Any of these approaches is usable together with DeXTT, since the protocol assumes that tokens already exist.

II-A Cross-Blockchain Balance Consistency

As outlined before, we require eventual consistency between blockchains participating in the proposed protocol. Since due to the XPP, we cannot directly propagate information across blockchains, we require an alternative way to reach consistency across blockchains.

For this, we propose to achieve eventual consistency using claim-first transactions [4]. While traditionally, blockchain transfers disallow claiming tokens before they have been marked as spent, we explicitly decouple the required temporal order of $\textsc{spend}\rightarrow\textsc{claim}$ and allow its reversal, i.e., claiming tokens before spending them. In our case, for a certain period of time, tokens are allowed to exist in the balance of both the sender and the receiver (on different blockchains), namely until the information is propagated to all blockchains. In the presented protocol, we provide a mechanism to enforce eventual spending of the tokens in the sender balance, as described in Section III.

In order to ensure such eventual consistency, we rely on parties observing a transfer to propagate this information across blockchains. These parties are denominated as witnesses. A monetary incentive is provided for any witness in order to ensure propagation. We use part of the transferred PBT for these witness rewards. The main challenge of this approach is the decision which witness receives the reward. Using a first-come-first-serve basis is not feasible, since it is possible that on one blockchain, one witness is the first to propagate the transfer and claim the reward, while on another blockchain, another witness takes this place. This would lead to two different witnesses receiving a reward on two different blockchains, and therefore, to potentially inconsistent balances.

In this work, we address this problem by using deterministic witnesses [5]. In short, instead of using a first-come-first-serve reward distribution, we define a witness contest. Its duration is fixed to a validity period, contestants (i.e., reward candidates) can register for the contest, and the decision of who wins the contest is made deterministically and predictably by each blockchain at the end of the contest. In Section III, we propose an approach for deciding the winning witness in a way that is fair (i.e., all contestants have the same chance of winning), while at the same time, it is purely deterministic, and—given the assumptions discussed above—assures all blockchains reach the same decision about assigning witness rewards.

Our approach therefore solves the problem of assigning witness rewards, which is required as an incentive for observers of a cross-blockchain transfer to propagate this transfer information, ensuring eventual consistency across the ecosystem of blockchains.

II-B Cryptographic Signatures and Hashes

In our approach, we make extensive use of cryptographic signatures and hashes, which are essential for blockchains themselves. For instance, the ECDSA algorithm [17] is used by Ethereum for creating and verifying signatures, and is also implemented natively and available to the Ethereum Virtual Machine (EVM) [16]. We use Solidity, the smart contract language of Ethereum, for the reference implementation of DeXTT. However, we note that DeXTT is not limited to Solidity or the EVM, and other blockchains offering signatures and hash algorithms can very well be used. The only crucial property required by our approach is a distribution of hash values which is approximately uniform. Keccak256, the hash algorithm used by Ethereum, satisfies this requirement [12], as does the Sha-256 algorithm used by Bitcoin [13].

II-C Notations and Conventions

In the following, we use particular notations for concise description of certain objects: We denote blockchains as $\mathcal{C}$ with a subscript letter, e.g., $\mathcal{C}_{a}$. Additionally, we denote wallets as $\mathcal{W}$ with a subscript letter, e.g., $\mathcal{W}_{s}$, $\mathcal{W}_{d}$, or $\mathcal{W}_{w}$. A wallet consists of a pair of corresponding keys, out of which one is a public key, and one is a private key. When referring to a token transfer in general, $\mathcal{W}_{s}$ is used to denote the source (sending) wallet, $\mathcal{W}_{d}$ is used to denote the destination (receiving) wallet, and $\mathcal{W}_{w}$ denotes a witness as discussed in Section II-A. As discussed in Section I and demonstrated in Table I, the balance of a wallet is stored across all blockchains.

In this work, we use the concept of transactions to denote actions executed on a blockchain which modify the blockchain state. We use the expression “$\mathcal{W}_{w}$ posts the transaction trans on $\mathcal{C}_{c}$” to describe the conceptual protocol. In a scenario where smart contracts are used, this translates to the key pair of $\mathcal{W}_{w}$ being used to sign a call to the smart contract on blockchain $\mathcal{C}_{c}$, where the function trans() is invoked. For certain transactions, we define preconditions (e.g., sufficient balances), which can be implemented as checks within the smart contract function. The transactions posted by wallets can either originate from the action of a user, or be initiated by a program (e.g., a wallet application) acting autonomously.

To denote our transactions, we use the notation as shown in (1), where trans is the transaction type used (one out of claim, contest, finalize, veto, and finalize-veto), $\mathcal{W}_{w}$ is the wallet (i.e., the pair of keys) used to sign and post the transaction, $a$, $b$, and $c$ denote data contained in the transaction (i.e., the arguments), and $\sigma$ is the signature when using the private key of $\mathcal{W}_{w}$ to sign the data $[a,b,c]$. For brevity, we use only $\sigma$ to denote a multivariate value, e.g., a three-variate ECDSA signature.

[TABLE]

We denote a transfer of $x$ PBT from $\mathcal{W}_{s}$ to $\mathcal{W}_{d}$ as $\mathcal{W}_{s}\xrightarrow{x}\mathcal{W}_{d}$. Furthermore, we denote the PBT balance of $\mathcal{W}_{w}$ recorded on $\mathcal{C}_{c}$ as ${{\mathcal{C}_{c}}:\mathcal{W}_{w}}$.

III Decentralized Cross-Blockchain Transfers

In the following, we present the DeXTT protocol, together with an example transaction. In our example, we consider three blockchains participating in cross-blockchain transfers, $\mathcal{C}_{a}$, $\mathcal{C}_{b}$, and $\mathcal{C}_{c}$. Note, however, that our approach is applicable to an arbitrary number of blockchains. Furthermore, we consider the wallets $\mathcal{W}_{s}$, $\mathcal{W}_{d}$, $\mathcal{W}_{u}$, $\mathcal{W}_{v}$, and $\mathcal{W}_{w}$. We assume that initially, $\mathcal{W}_{s}$ has 80 PBT, and all other wallets have a balance of zero (see Table I). We furthermore use a fixed reward of 1 PBT for the witness propagating this transaction across the blockchain ecosystem. Note that pro rata fees (e.g., 1% of the transferred PBT, or an amount selected by the sender) are also possible and the exact fee model is an economic choice. We will discuss this in more detail in Section IV-B.

As discussed in Section II-A, claim-first transactions require all blockchains within the ecosystem to maintain and synchronize token balances. Therefore, the initial situation is as depicted in Table I. Balances for $\mathcal{W}_{u}$ and $\mathcal{W}_{v}$ are not shown, as they will remain zero throughout the example.

III-A Transfer Initiation

In the following, we assume that $\mathcal{W}_{s}$ intends to transfer $20$ PBT to $\mathcal{W}_{d}$, i.e., reduce the PBT balance of $\mathcal{W}_{s}$ by $20$, increase the PBT balance of $\mathcal{W}_{d}$ by $19$ ($20$ reduced by $1$, the witness reward), and increase the PBT balance of a (yet to be decided) witness wallet by $1$. As stated in Section II-A, we only require eventual consistency for this transfer, i.e., a temporary overlap is allowed where $\mathcal{W}_{d}$ has already received $19$ PBT, but the balance of $\mathcal{W}_{s}$ is still unchanged.

Therefore, $\mathcal{W}_{s}$ signs this intent, confirming that indeed, $20$ PBT—minus $1$ PBT of witness reward—are to be transferred to $\mathcal{W}_{d}$. Furthermore, we define a validity period for the transfer, which denotes the time during which the witness selection for the transfer has to take place. In our example scenario, this time span lasts for 1 minute, however, this time can be set significantly shorter or longer, depending on the use case. We provide an analysis of the impact of this parameter in Section IV-A.

We denote the entirety of the sender’s intent using the notation shown in (2), where $[t_{0},t_{1}]$ is the validity period, and $\alpha$ denotes the signature of the entire content of the brackets by $\mathcal{W}_{s}$. The resulting signature itself is denoted as $\alpha$. We use the ECDSA algorithm, natively supported by the EVM, for all signatures. However, other algorithms can also be used, assuming that their verification is supported on all involved blockchains.

[TABLE]

The data contained in (2) is transferred to the receiving wallet $\mathcal{W}_{d}$. This transfer can happen on any blockchain within the ecosystem, or using an off-chain channel. Since all of the data contained in (2) will be published throughout the DeXTT transaction, this channel does not need to be secure, and we do not specifically define any communication means. The receiving wallet then counter-signs the data from (2) using its respective private key, yielding the entire Proof of Intent (PoI), as shown in (3).

[TABLE]

The PoI contains all information necessary to prove to any blockchain (i.e., to its smart contracts and miners) that the transfer is authorized by the sender and accepted by the receiver. The receiver can now post this PoI using a transaction we call claim. This transaction allows the receiver to publish the PoI in order to later claim the transferred PBT. The receiver can post this on any blockchain within the ecosystem, and does not need to post it on more than one blockchain. The claim transaction is defined and noted as shown in (4).

[TABLE]

The preconditions for the claim transaction are (i) that the PoI is valid (i.e., that the signatures $\alpha$ and $\beta$ are correct), (ii) that the balance of the source wallet $\mathcal{W}_{s}$ is sufficient, (iii) that the PoI is not expired, i.e., that its $t_{1}$ has not yet passed ($t<t_{1}$), and (iv) that no PoI is known to the blockchain on which it is posted with an overlapping validity period and the same source wallet $\mathcal{W}_{s}$. In other words, a wallet must not sign an outgoing PoI while another outgoing PoI is still pending. This is done in order to prevent a double spending attack, where two PoIs are signed which are conflicting, i.e., which, if both were executed, would reduce the sender’s balance below zero.

The purpose of the claim transaction is the publishing of the PoI, which can then be propagated across the blockchain ecosystem as described later.

In our example, we assume that the receiver $\mathcal{W}_{d}$ posts the claim transaction (containing the PoI) on $\mathcal{C}_{a}$ as shown in (5), where 1 and 61 mark the validity period in seconds (i.e., one minute total validity), 0xAA is assumed to be the signature $\alpha$, and 0xBB is assumed to be the signature $\beta$. For brevity, one-byte signatures are used for demonstration in this example. Naturally, in reality, the signature hashes are longer (e.g., 32 bytes for Keccak256).

[TABLE]

The claim transaction on $\mathcal{C}_{a}$ changes the blockchain state as shown in Table II. We see that the PoI has been stored within $\mathcal{C}_{a}$, which is referred to by its signature $\alpha$. The balances remain unchanged on $\mathcal{C}_{a}$ because the validity period is not yet concluded, i.e., $t_{1}$ is not yet reached. Naturally, since no information has been posted yet to $\mathcal{C}_{b}$ and $\mathcal{C}_{c}$, these blockchains also remain unchanged at this point.

III-B Witness Contest

At this point, the information about the intended transfer (the PoI) is only recorded on $\mathcal{C}_{a}$. However, this information must be propagated to all other blockchains as well to ensure consistency of balances across blockchains. We use the following mechanism, which we refer to as the witness contest, to ensure this consistency.

Any party observing the claim transaction on $\mathcal{C}_{a}$ can become a contestant, i.e., a candidate for receiving a reward. In order to become a contestant, the party must propagate the PoI across all blockchains in the ecosystem. We define the transaction used for this as contest. This transaction is defined for any arbitrary wallet $\mathcal{W}_{o}$ as shown in (6), where the new signature $\omega$ is the result of the contestant $\mathcal{W}_{o}$ signing the PoI. This signature will later play a role in determining the winner of the witness contest, as described in Section III-C.

[TABLE]

The contest transaction can be posted multiple times by various contestants during the validity period. The preconditions are the same as for the claim transaction, i.e., the PoI must be valid and must not violate any other PoI’s validity period. The only effect of the claim transaction is that the PoI itself and the contestant’s participation in the witness contest are recorded on the respective blockchain.

In our example, we assume that $\mathcal{W}_{u}$ is the first to post a contest transaction on $\mathcal{C}_{b}$ as shown in (7), where again, $1$ and $61$ denote the validity period, 0xAA and 0xBB are the PoI signatures, and 0xC2 is the signature resulting from $\mathcal{W}_{u}$ signing the PoI. The signature values in this example are chosen arbitrarily in order to demonstrate the subsequent witness contest. Again, one-byte signatures are used for brevity.

[TABLE]

Next, we assume that the other observers $\mathcal{W}_{v}$ and $\mathcal{W}_{w}$ become contestants by posting similar contest transactions. We assume that the resulting signature $\omega$ for $\mathcal{W}_{v}$ is 0xC3, and that the signature for $\mathcal{W}_{w}$ is 0xC1.

[TABLE]

[TABLE]

Transactions (7–9) are eventually posted to $\mathcal{C}_{a}$, $\mathcal{C}_{b}$, and $\mathcal{C}_{c}$. This is because every contestant participating in the contest is interested in participating in all blockchains in the ecosystem to maintain their own consistency.

The state resulting from the three contestants posting to $\mathcal{C}_{a}$, $\mathcal{C}_{b}$, and $\mathcal{C}_{c}$ is shown in Table III. The blockchain maintains a list of contestants together with their $\omega$ signature values.

III-C Deterministic Witness Selection

After the expiration of $t_{1}$, the witness contest ends, a winning witness must be selected, and awarded the witness reward. This is performed by the finalize transaction, which must be triggered after $t_{1}$.

Conceptually, this transaction is purely time-based. It can be triggered by the receiver, by any other party, or using a decentralized solution like the Ethereum Alarm Clock [2]. The latter approach has the advantage of being independent of any party’s activity. However, for simplicity, in our current approach and the discussion below, we assume that the destination wallet $\mathcal{W}_{d}$ posts the finalize transaction on each blockchain. The finalize transaction is defined as shown in (10).

[TABLE]

The finalize transaction only requires the parameter $\alpha$, identifying the PoI, because the blockchain already contains all necessary information about the PoI. The precondition of $t_{1}$ being expired ($t>t_{1}$) is necessary for the finalize transaction to avoid premature finalization.

The effect of the finalize transaction is that the contest for the PoI referred to by its signature $\alpha$ is concluded. This means that the winning witness is awarded the witness reward, which, according to Section III, is 1 PBT in our current approach. Furthermore, the conclusion of the contest performs the actual transfer of PBT, i.e., $x$ PBT are deducted from the balance of $\mathcal{W}_{s}$, and $\mathcal{W}_{d}$ receives $x-1$ PBT ($x$ reduced by the witness reward). This action is executed on all blockchains, since finalize is posted on all blockchains.

We define the winning witness to be the contestant with the lowest signature $\omega$ (i.e., with its value closest to zero). Since this signature cannot be influenced by the contestants (because it is only formed from the PoI data and the contestants’ private key), they have no way of increasing their chances of winning a particular contest, except for creating a large number of wallets (private keys). Such “mining for wallets” is not a violation of our protocol and no threat to its fairness, since doing so is computationally expensive, and therefore creates cost on its own. There exists a break-even point of the witness reward and the cost created by the creation of a large number of wallets [5]. Effectively, this challenge is comparable to mining in Proof of Work (PoW) in that resources, i.e., computing power, can be traded for rewards.

In our example above, the witness with the lowest $\omega$ is $\mathcal{W}_{w}$, with $\omega=\texttt{0xC1}$. Therefore, this witness is awarded the witness reward. The final blockchain state is shown in Table IV. The balances of the competing contestants $\mathcal{W}_{u}$ and $\mathcal{W}_{v}$ remain zero. The expired PoIs are no longer shown for brevity.

III-D Prevention of Double Spending

A malicious sender might sign two different PoIs conflicting with each other. For instance, a sender owning $10$ PBT might create two PoIs, transferring $8$ PBT each, to two different wallets. Executing these transfers would reduce the sender’s balance by $16$ PBT in total, resulting in $-6$ PBT.

In order to prevent such behavior, we introduce the veto transaction. The veto transaction can be called by any party noticing two conflicting PoIs (i.e., two PoIs with the same source, different destinations, and overlapping validity periods). Since such PoIs are forbidden by definition, the veto transaction is used to penalize the sender, and to protect the receiver from losing PBT due to inconsistent balances.

Since the veto transaction requires incentive, we propose to use the same technique as presented above, i.e., a contest. Any observer of a PoI conflict can report this conflict using the veto transaction, and after the expiration of the veto validity period, the observer with the lowest $\omega$ signature is assigned a reward.

We therefore define the veto transaction as shown in (11), where $\alpha$ refers to the original PoI, which is known to the blockchain because it has already been posted on a given blockchain, and the remaining data $\mathcal{W}_{s}\xrightarrow{x^{\prime}}\mathcal{W}_{d^{\prime}}$ and $t_{0}^{\prime},t_{1}^{\prime},\alpha^{\prime}$ describe the new, conflicting PoI.

[TABLE]

The veto transaction, similar to contest, is posted on all participating blockchains. Note that multiple observers can be expected to concurrently post veto transactions. Therefore, it is possible that on one blockchain, a given PoI (e.g., where $\alpha=\texttt{0x10}$) is posted first, and a second PoI (e.g., where $\alpha^{\prime}=\texttt{0x20}$) is presented as “conflicting” by a veto transaction, while on another blockchain, the PoI where $\alpha=\texttt{0x20}$ is posted first, and the PoI with $\alpha^{\prime}=\texttt{0x10}$ is posted in the veto transaction as “conflicting”. However, in the following, we define a behavior for the veto transaction that still maintains consistency, regardless of the order of PoIs.

The preconditions for veto are that $\alpha$ refers to a PoI already known to the blockchain, that the conflicting PoI is valid, and that the two PoIs are actually conflicting.

The effects of veto are as follows: (i) The sender of the conflicting PoIs loses all PBT, i.e., the balance is set to zero to penalize such protocol-violating behavior. (ii) Any PoI which has a non-expired validity period (i.e., every PoI where $t<t_{1}$) is canceled. This means that no finalize transaction will be permitted for this PoI, the transfer itself will therefore not be executed, and no witness reward will be assigned. Finally, (iii) a new contest is started, called the veto contest. The veto contest is similar to a regular witness contest in that its purpose is the propagation of information (in this case, the information of conflicting PoIs).

In the following, we propose a possible implementation of such veto contest, however, its details (i.e., the definition of its validity period or the reward) are specifics which may be implemented differently.

We propose to use the same reward for the veto contest as for the regular witness contest (in our case, $1$ PBT). Since all PBT held by the sender are destroyed, and only $1$ PBT is assigned to the winner of the veto contest, all remaining PBT are lost. Furthermore, we propose the validity period expiration of the veto contest, $t_{\textsc{veto}}$, to be defined as shown in (12).

[TABLE]

The definition shown in (12) states that the veto contest is valid until a point in time which is found by taking the later expiration time of the conflicting PoIs ($\max(t_{1},t_{1}^{\prime})$) and adding the longer validity period ($\max(t_{1}-t_{0},t_{1}^{\prime}-t_{0}^{\prime})$). This is done to ensure that sufficient time is available for the veto contest. Again, we note that this is an implementation detail and other approaches (e.g., a fixed period) are also possible.

The veto contest is concluded by a finalize-veto transaction, defined as shown in (13).

[TABLE]

The effect of the finalize-veto transaction is similar to that of the finalize transaction, except that no actual transfer is executed. The witness reward is again assigned to the veto contestant—that is, a wallet posting a veto transaction—with the lowest $\omega$ signature in the veto transaction. Similar to the finalize, the finalize-veto transaction can be called by anyone, in particular, the winning veto contestant has monetary incentive in doing so.

IV Evaluation

The approach presented in Section III introduces transactions which change the state of different blockchains within a blockchain ecosystem, according to given rules. This can be implemented using smart contracts, e.g., using the Solidity language [9]—more specifically, the EVM—on the Ethereum blockchain. We use Solidity to create a reference implementation of the proposed protocol for evaluation111https://github.com/pantos-io/dextt-prototype. However, other ways of implementing such transactions exist. For instance, instead of using smart contracts (e.g., when dealing with blockchains without such capabilities), one might add backwards-compatible layers on top of blockchains, providing the required capabilities for the transactions presented in this work. A similar approach is used by OmniLayer [25] or CounterParty [7, 8], which add such layers for enhanced features. For this work, however, we use our reference Solidity implementation of DeXTT for evaluation and cost analysis, postponing the integration of approaches such as OmniLayer or CounterParty to future work. Nevertheless, our current evaluation is sufficient to demonstrate the overall functionality of the DeXTT protocol using Solidity smart contracts and the conceptual applicability.

In order to evaluate our approach, we investigate its functionality, performance, and cost impact in an ecosystem of blockchains with agents performing repeated token transfers. We achieve these goals by using our reference implementation consisting of Solidity smart contracts, deploying these smart contracts on a number of private Ethereum-based blockchains, and using testing client software to perform transfers with a given rate.

We ensure a reproducible and uniform ecosystem of blockchains by using three geth nodes in Proof of Authority (PoA) mode, creating three private blockchains. We choose PoA to achieve an energy-efficient testing and evaluation platform while being able to perform repeated experiments. Note that the consensus algorithm, i.e., PoW, Proof of Stake (PoS), or PoA, defines the behavior of blockchain nodes between each other and maintains data consistency in the network of a given blockchain [30]. However, the smart contract layer is independent of the consensus algorithm. Therefore, our evaluation on PoA is directly applicable to blockchains with any consensus algorithm, including PoW.

The geth nodes used in our experiments can be configured, for instance, with regards to block time and Gas limit. We observe the behavior of the live Ethereum blockchain (January 2019) and configure our nodes to follow this behavior. Therefore, our nodes are configured to use a block time of 13 s on average, and a Gas limit of 8 million Ethereum Gas, mimicking the live Ethereum chain. We use private chains instead of the Ethereum main chain to enable a high number and low cost of repeatable experiments in an automated fashion without depending on external components, such as Ethereum nodes.

We use 10 clients constantly and simultaneously initiating transfers within the blockchain ecosystem. This number is chosen as a balance between feasible and reproducible experiments and expected real-world conditions. While it is small compared to evaluations of other classes of distributed systems, we note that the lack of scalability of blockchain technologies is a crucial issue in general, and is seen as one of the main challenges for existing blockchain technologies [15]. We refer to existing literature for a study on how scalability of blockchains can be improved [23].

In our experimental ecosystem, each client constantly transfers random amounts of PBT to random wallets. If a client owns too little PBT for a transaction, no transaction is performed until PBT are available again. After a successful transfer, the client waits for a random time between 15 s and 30 s. Afterwards, the process is repeated indefinitely throughout the entire experiment duration.

We perform two experiment series, as described in the following sections. The first series is used to evaluate DeXTT scalability and the impact of the transfer validity period, and consists of a series of 30-minute experiments, where each individual experiment uses an increased validity period. The second series consists of 20 experiments, again with a duration of 30 min each, used to measure the average cost of a DeXTT transfer.

IV-A Scalability and Timing

The DeXTT protocol requires one claim transaction per transfer, and for each transfer, one finalize transaction per blockchain. In addition, each contestant posts one contest transaction to each blockchain. We assume that candidates which no longer have a chance to win the witness contest (because a candidate with a lower signature $\omega$ for the given transaction has already posted a contest transaction) do not post contest transactions to avoid cost. Assuming uniform distribution of $\omega$ values, as defined in Section II-B, on the average case, each contest transaction halves the space of remaining possible winning signatures $\omega$ (because the expected value of the uniform distribution is the arithmetic mean of the domain). Therefore, with each contest transaction, the likelihood of another candidate existing with a lower $\omega$ is halved. Following from this, on average, $\log_{2}n$ candidates will post a contest transaction, where $n$ is the number of total observers.

Transfer time in the DeXTT protocol is directly impacted by the transfer validity period $[t_{0},t_{1}]$ chosen by the sender. We therefore first evaluate the impact of the validity period. Using too short validity periods leads to corrupted transfers, i.e., transfers which cause permanently inconsistent balances, since observers cannot post contest transactions in time. In such scenarios, eventual consistency between blockchains is not guaranteed. As stated above, we use a block time of 13 s, therefore, we start our experiments with 10 s, and increase the period by 5 s with each experiment. We then run our blockchain ecosystem for 30 min using each validity period and record the number of corrupted transactions. Note that we have to reset the inconsistent balances for wallets participating in a corrupted transaction in order to be able to run the experiments for 30 min.

Figure 1 shows the results of these experiments. Beyond 52 s, no corrupt transactions are observed. It becomes clear that using the reference implementation and waiting for 4 blocks (52 s) is sufficient for ensuring consistency. Between 1 and 3 blocks (13 s and 39 s, respectively), the amount of corrupted transactions declines with a varying rate.

From this experiment, we conclude that using a validity period with the length of at least 4 blocks (52 s) is sufficient to maintain consistency using our reference implementation. Additional time may be required in order to accommodate slow network connectivity.

IV-B Cost Analysis of DeXTT Transfers

To estimate the cost incurred by DeXTT transfers, we run the same experiment 20 times. Based on our previous experiment, we choose 65 s (5 blocks, well above the determined limit of 52 s) as the duration of the PoI validity period in each transaction. We record the average cost of each transaction. Table V shows an overview of the cost of the individual transactions involved in a DeXTT transfer. For each transaction, we show the mean cost, and its standard deviation, both in thousands of Ethereum Gas (kGas), and in USD. For this, we assume a Gas price of 10 Gwei (1 Ether = $10^{9}$ Gwei = $10^{18}$ wei) and a price of Ether of $115.71$ USD. These values were obtained from the Ethereum live chain in January 2019. Note that our implementation is optimized in that claim and contest both use the same smart contract function. Nevertheless, we distinguish the semantic difference (posting of new transfer for claim, and participating in a contest for contest) in the results.

In the following, we assume $m$ blockchains and $n$ total observers. For our calculation, we assume that all observers monitor all blockchains, and post contest transactions if it benefits them. A regular DeXTT transfer (i.e., one which does not contain a conflicting PoI, and therefore requires no veto) consists of one claim transaction (on the target chain), $\log_{2}n$ contest transactions (as discussed in Section IV-A) on each blockchain, i.e., $m\log_{2}n$ contest transactions, and $m$ finalize transactions. The claim transaction is posted by the receiver, and each contest transactions is posted by an observer (thus becoming a contestant). While the finalize transaction can be posted by any party, posting it is beneficial to the receiver (because it finalizes the transfer to the receiver), and therefore it can be expected that the receiver will bear its cost to finalize the transfer.

The expected cost in kGas for a DeXTT transfer are as follows: The receiver bears the cost for one claim transaction ($57.7$ kGas) and $m$ finalize transactions ($45.5$ kGas each). Each of the $\log_{2}n$ expected observers posting transactions bears the cost for $m$ contest transactions ($81.5$ kGas each). The sender does not bear any cost.

Assuming a blockchain ecosystem of 10 blockchains, the total transaction cost for the receiver is $0.59$ USD. Each of the $\log_{2}n$ observers posting transactions bears cost of $0.94$ USD. These numbers represent our current reference implementation and can be regarded as an upper bound for DeXTT transfer cost. Any additional optimization to the smart contract code has the potential to further reduce the Gas cost of the individual transactions, and therefore, of the overall DeXTT transfer.

Additionally, these numbers allow us to reason about the economic impact of a currency using DeXTT transactions. Observers pay transaction cost of $0.94$ USD, and potentially receive a witness reward, currently defined as 1 PBT. The chance of an observer winning is $\frac{1}{n}$, however, according to the discussion in Section IV-A on average, only $\log_{2}n$ out of all $n$ observers are expected to post contest transactions. Therefore, the likelihood for an observer posting a transaction to win the contest is $\frac{\log_{2}n}{n}$.

Therefore, the investment for each observer is $0.94$ USD, the contest reward is 1 PBT, and the winning likelihood is $\frac{\log_{2}n}{n}$. From this, it follows that in order for the observer to have incentive to post contest transactions in an ecosystem of $m=10$ blockchains, the inequation shown in (14) must hold, where $p$ is the price of PBT in USD.

[TABLE]

In other words, the price of PBT in USD divided by the number of observers must be higher than $0.94$. Assuming $n=10$ observers, the PBT price must be above $2.83$ USD. Assuming $n=100$, the PBT price must be above $14.15$ USD. For $n=1000$, the PBT price must be above $94.32$ USD.

Note that these number assume $m=10$ blockchains, and a fixed reward of 1 PBT. A pro rata reward, e.g., $1\%$ of the transferred PBT, would reduce the required PBT price but increase the complexity of calculating the witness incentive. Furthermore, a dynamic reward adaption based on the number of observers, similar to the variable mining rewards in Bitcoin, or a value selected by the sender, similar to the Gas price in Ethereum, can also be used to reduce the required PBT price, and therefore incentivize observers. We note again that these numbers pose an upper boundary for the expected DeXTT transfer cost and PBT price requirements for witness incentive.

V Related Work

As discussed in Section I, cross-blockchain interoperability can be used to address the fragmentation of the blockchain research field. Yet, to the best of our knowledge, contemporary approaches provide only limited interoperability across blockchains.

Initial interoperability was limited to trading assets on centralized exchanges. Subsequently, decentralized exchanges such as Bisq [1] or 0x [24] emerged. Most recently, the Republic protocol [29] has been proposed, which includes a decentralized dark pool exchange, i.e., details about an exchange are kept secret.

All of these approaches, however, are concerned with the exchange of assets, generally using atomic swaps [14] for trustless asset exchange. In such an atomic swap, one party might transfer, e.g., Bitcoin to another party, while the other party transfers, e.g., Ether to the first. In such an atomic swap, each asset remains on its blockchain. In contrast, we propose a protocol for trading assets independently of a specific blockchains. In our approach, the balance information for such assets is stored on all blockchains simultaneously.

Another approach for a multi-blockchain framework is presented in PolkaDot [27]. PolkaDot aims to provide “the bedrock relay-chain” upon which data structures can be hosted. However, in contrast to our approach, no specifics about cross-blockchain asset transfers are provided. Instead, PolkaDot is explicitly not designed to be used as a currency [27]. Furthermore, PolkaDot is meant to be used as a basis for future blockchains (and other decentralized data structures), while in our current approach, we aim to use existing blockchains and implement functionality on top of them. However, the concepts presented in the PolkaDot paper are complementary to techniques we used in our approach.

Decentralized cross-blockchain transfers allow users to fully utilize the existing variety of blockchains, instead of being locked to a single blockchain. To the best of our knowledge, the approach closest to the work at hand is Metronome [20], which uses assets available on multiple blockchains. However, Metronome proposes that assets still lie on one specific blockchain at a time, while in our proposal, the assets are not bound to one blockchain.

The DeXTT protocol presented in this paper is based on our own former work. The XPP has been formally described in [4]. Furthermore, in [5], we describe the deterministic witness selection approach conceptually. The work at hand significantly extends our former work by providing a concrete implementation of this approach within the DeXTT protocol. Furthermore, the work at hand is a significant enhancement of our earlier work, in which we also defined a token existing across blockchains. However, each wallet had a different balance on each blockchain (and all balances were recorded on all blockchains) [4]. In the work at hand, this concept is simplified, yielding only one balance per wallet (which is recorded on all blockchains).

VI Conclusion

In this paper, we have presented DeXTT, a protocol for transferring cross-blockchain tokens, existing on a single blockchain, but tradeable on multiple blockchains. This reduces dependency on a single blockchain and risk, e.g., of selecting a blockchain which later suffers from a security breach. DeXTT ensures eventual consistency of balances across blockchains, and prohibits double spending. We have presented the protocol in detail, implemented it in Solidity, and provided an experimental evaluation, highlighting its performance with regards to time and cost.

Our evaluation shows that the reference implementation of DeXTT requires at least 4 blocks for maintaining consistent balances. Furthermore, we show that a DeXTT transfer using our reference implementation costs 103.2 kGas for the receiver, and 81.5 kGas for any contributing observer. We also provide an analysis of the economic impact of the witness rewards based on the parameters of the multi-blockchain ecosystem used.

In future work, we will address the main limitation of our current evaluation by implementing DeXTT using additional technologies such as OmniLayer or CounterParty and therefore evaluate the performance of DeXTT in a blockchain ecosystem consisting of mixed blockchain types. Furthermore, we aim to implement DeXTT on other native smart contract platforms such as EOS.IO [10]. In addition, we aim to evaluate more refined approaches for the veto contest, which can be used to relax the currently strict requirement of not signing to outgoing PoIs with overlapping validity periods.

Acknowledgments

The work presented in this paper has received funding from Pantos GmbH within the TAST research project.