This proposal aims to integrate Perun Channels with Stellar. This will, in the first phase, foster fast and secure payment settlement on Stellar. The resulting payment toolkit can be used by developers within the Stellar ecosystem. In a future proposal, these payment channels can be extended to State Channels or other functionalities such as cross-chain swaps (see Outlook).

Overview

Background. Perun Channel technology enables fast and cheap transactions on and across blockchains. The technology is based on peer-reviewed research that has been published at top conferences and is being implemented in the form of the open-source library go-perun written in Go. One of its main features is its blockchain-agnostic design, which means that most parts of the library do not depend on a concrete blockchain implementation, but are rather implemented against abstract blockchain backend components. Currently, we have backends for Ethereum, Cosmos, Polkadot, Cardano and Hyperledger Fabric.

Proposal. We propose to adapt the go-perun framework so that two-party single-asset payment channels between users on Stellar can be created, processed, closed and disputed.

We propose to release this work open-source under the Apache 2.0 license.

Outlook. We currently focus on two-party single-asset payment channels between users on the same Stellar chain.

For the future, we consider adding state channel functionality, multi-asset support, multi-party support, and cross-chain functionality for establishing channels between Stellar and all other chains supported by Perun.

Project Details

Architecture

Go-Perun is the core library of the Perun project. It is a toolkit for developers to integrate state channels within their application. The library is written in Go and it implements the client protocols against a set of abstract interfaces for blockchain communication, off-chain communication, persistence, and so on. To the developer, it exposes an easy enough interface to integrate Perun channels within their application.

See attachments: Figure 1. Package structure of Go-Perun.

An overview of the packages of Go-Perun is given in Figure 1. At the core of the library lies the client package, which holds the channel client type and an implementation of the channel protocols. For communication with other clients, the client package uses the wire package, which is an abstract definition of the communication layer that is to be instantiated with a concrete implementation suitable for the given application context. Furthermore, the client package interfaces with the wallet package and the channel package. The wallet package and the channel package lie at the core of any blockchain backend implementation. The wallet package provides functionality for account management and signature generation. The channel package provides the core data structures and functionality for interacting with the blockchain. Besides that, the library contains the persistence package and the log package, which are abstractions for persistence and logging functionality which can be instantiated suitable to the application environment.

Scope of current proposal

The focus of this proposal is to provide basic integration of Perun channels within Stellar that can serve as a foundation for future projects and enhancements. This will include the following:

1. On-chain contract: A Go-Perun blockchain backend consists of an on-chain contract running on the blockchain and an off-chain connector that integrates the on-chain contract with the off-chain Go-Perun core. Here the focus will be on delivering a basic contract implementation that provides payment channel functionality (funding, settlement, dispute).
2. Off-chain integration: For the off-chain integration with Go-Perun, we will need to connect the Go-Perun core with the on-chain contract written in the previous step. This means translating the calls of the core client against the abstract interface into concrete calls to the Perun contract deployed on a Nervos network. We plan to use the library stellar-sdk-go for that.
3. Demonstrator: It has been shown in the past that it is useful to have a basic demonstrator delivered with the core components, which is capable of demonstrating the new functionality in a way that end users can experience it directly in a small sample application.

1. On-Chain part: Create a technical concept of building payment channels using Soroban.
2. On-Chain part: Start with a stripped down, easy version of our contract to familiarize with Soroban contract development using the rs-soroban-sdk.

1. We present an overview of our concept for building payment channels on Soroban and go over a first version of our initial contract code.
2. The reviewer can review our Code in a public Github repository.
3. The reviewer can ask questions regarding specific functionalities regarding the development of payment channels using Soroban.