First commit

Author: Sébastien Dan

.github/workflows/docker.yml

@@ -0,0 +1,38 @@
+name: Publish Docker image
+
+on:
+  push:
+    branches:
+    # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  push_to_registry:
+    name: Push Docker image to GitHub Container Registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: robot-toposware
+          password: ${{ secrets.ROBOT_TOPOSWARE_GH_PACKAGE_TOKEN }}
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+      - name: Push to GitHub Container Registry
+        uses: docker/build-push-action@v2
+        with:
+          push: true
+          context: .
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: NPM_TOKEN=${{ secrets.ROBOT_TOPOSWARE_GH_PACKAGE_TOKEN }}

.gitignore

@@ -0,0 +1,20 @@
+# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.docusaurus
+.cache-loader
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

.prettierrc

@@ -0,0 +1,5 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "es5"
+}

Dockerfile

@@ -0,0 +1,11 @@
+FROM node:14 as build-deps
+WORKDIR /usr/src/app
+COPY package.json yarn.lock ./
+RUN yarn
+COPY . ./
+RUN yarn build
+
+FROM nginx:1.12-alpine
+COPY --from=build-deps /usr/src/app/build /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]

README.md

@@ -0,0 +1,33 @@
+# Website
+
+This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator.
+
+### Installation
+
+```
+$ yarn
+```
+
+### Local Development
+
+```
+$ yarn start
+```
+
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
+
+### Build
+
+```
+$ yarn build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+
+### Deployment
+
+```
+$ GIT_USER=<Your GitHub username> USE_SSH=true yarn deploy
+```
+
+If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
+};

docs/develop/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "Develop",
+  "position": 3
+}

docs/develop/getting-started.md

@@ -0,0 +1,10 @@
+---
+sidebar_position: 1
+---
+
+# Getting Started
+
+Welcome to the **Develop** section of Topos Docs!
+
+- Take a look at [Substrate](/develop/substrate) for information about the base framework Topos software extends.
+- Read [XCP Pallets](/develop/xcp-pallets) for details about how Topos software augments Substrate.

docs/develop/substrate.md

@@ -0,0 +1,35 @@
+---
+sidebar_position: 2
+---
+
+# Substrate
+
+Topos software is based on [Substrate](https://substrate.io/), a blockchain framework developed by [Parity](https://www.parity.io/) and written in rust.
+
+Originally the base project of [Polkadot](https://polkadot.network/), [Substrate](https://substrate.io/) packages a fully functional blockchain backbone and exposes a framework-in-the-framework ([FRAME](#frame)) tailored for custom _on-chain_ business logic—the **runtime**.
+
+:::info
+
+Refer to the [**Substrate Developer Hub**](https://docs.substrate.io/) for a complete overview of Substrate.
+
+:::
+
+## FRAME
+
+Developing a [Substrate](https://substrate.io/) runtime with FRAME comes down to writing domain-specific modules called **Pallets**. FRAME pallets implement a common interface that eases runtime development by clearly encapsulating the declaration of runtime specifc objects and methods (e.g. storage element, storage mutation functions).
+
+A large part of the blockchain backbone exposed by Substrate is itself developed in FRAME both as system/meta pallets that build FRAME itself and as pallets that define core components of a blockchain (e.g. block production mechanism).
+
+:::note Example: block production mechanism
+
+With regards to the block production mechanism of a Substrate blockchain—i.e. selecting the leaders who author blocks—FRAME exposes multiple solutions: the _Aura_ pallet introduces the Aura block production mechanism where known authorities take turns producting blocks, the _Babe_ pallet introduces the Babe block production mechanism where publicly verifiable randomness is used along with stake distribution to randomly designate block authors.
+
+:::
+
+The composition of FRAME prebuilt pallets and ones defining custom business logic is what makes a Substrate blockchain specific.
+
+:::info
+
+More details about FRAME [**here**](https://docs.substrate.io/v3/runtime/frame/).
+
+:::

docs/develop/xcp-pallets.md

@@ -0,0 +1,19 @@
+---
+sidebar_position: 3
+---
+
+# XCP Pallets
+
+Topos software builds on top of FRAME core pallets to augment Substrate with cross-chain capabilities.
+
+## Pallet 1
+
+TODO: Explain Pallet 1
+
+## Pallet 2
+
+TODO: Explain Pallet 2
+
+## Pallet 3
+
+TODO: Explain Pallet 3

docs/introduction.md

@@ -0,0 +1,19 @@
+---
+sidebar_position: 1
+---
+
+# Introduction
+
+Welcome to **Topos Docs**, the official documentation to help you get familiar with the Topos _Cross-Chain Protocol_ (_XCP_) and join the network!
+
+## Why Topos XCP?
+
+Today's Web2.0 Internet remains a network of highly centralized computers and services managed by a handful of big tech companies. Concerns from users about how their data is handled and to which extent it is controlled and owned by such companies are getting stronger every day.
+
+Blockchain has paved the way for Web3.0, a new era of distributed and decentralized web services that give back the control to application users. Yet, more than a decade later, the promised revolution hasn't landed. Facing scalability, interoperability and privacy issues, the blockchain technology hasn't been able to proceed to its full industrial adoption and still resides within the scope of experimentation and small-scale production deployment.
+
+**The Topos XCP aims at giving back the control and freedom to service users and to lead the way for a true open and decentralized Internet.**
+
+## How does the Topos XCP work?
+
+Continue with the [Learn](/learn/getting-started) section to learn more about Topos XCP.

docs/learn/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "Learn",
+  "position": 2
+}

docs/learn/certificate.md

@@ -0,0 +1,33 @@
+---
+sidebar_position: 3
+---
+
+# Certificate
+
+## State Transitions
+
+A blockchain participating in the Topos XCP is no different from a common blockchain: it is a distributed ledger that rests upon a p2p network which leverages a shared consensus mechanism to totally order propagated transactions and hence replicate a consistent state over the network.
+
+A state transition in a blockchain is a set of transactions, i.e. state mutations, that from a given state commitment induce the next state commitment. New blocks are such state commitments that are validated by the consensus layer as valid state transitions from their preceding block.
+
+## Proof of valid state transition
+
+For Topos XCP to retain a consistent global state—i.e. blockchains can interact with one another and inconsistent state is prevented— participating blockchains construct proofs of the validity of their state transitions. Topos XCP is **privacy-enhancing** hence does not request blockchains to publicly share their blocks. Instead, another form of state commitments is used by all ledgers: **Certificates**.
+
+To prove the validity of their state transitions while exposing only a part of their internal state (more on that later), Topos XCP blockchains nodes compute [zkSTARK](/learn/zkSTARK) proofs attesting the validity of every transaction that happened since the previous Certificate.
+
+Other blockchains verify such state transitions by verifying Certificates which among other things equates to verifying the zkSTARK proof.
+
+## Certificate composition
+
+Beside containing zkSTARK proofs, Certificates include in clear the set of new—i.e. since the previous Certificate—cross-chain (XC) transactions that were emitted towards other Topos XCP blockchains.
+
+Overall, Topos XCP blockchains construct Certificates with the following data:
+
+- The ledger id
+- A reference to the previous Certificate
+- zkSTARK proofs of valid state transition (both exposed and non-exposed state)
+- The list of outgoing XC transactions (exposed state)
+- A signature of the Certificate
+
+Certificates are signed by a [threshold signature](/learn/threshold-signature) scheme that is detailed in the next section.

docs/learn/getting-started.md

@@ -0,0 +1,9 @@
+---
+sidebar_position: 1
+---
+
+# Getting Started
+
+The Topos XCP is an open blockchain protocol that does not compromise in creating an ecosystem that permits full interoperability between participating ledgers. Typical trust assumptions are replaced by zk-based cryptographic constructions that allow for friction-less cross-chain communication. The Topos XCP does not require any specific blockchain architecture or framework from ledger developers and ensures global consistency between heterogeneous **private** and **public** blockchains via a core [reliable broadcast](/learn/reliable-broadcast) mechanism, where existing multi-chain projects commonly rely on a central consensus layer that has authority over the rest of the network chains.
+
+Ledgers in the Topos ecosystem prove the validity of their state transitions by computing [zkSTARKs](/learn/zkSTARK) which are published in [Certificates](/learn/certificate). On one hand [zkSTARKs](/learn/zkSTARK) are publicly verifiable by participants in and out of the protocol, and on the other hand [Certificates](/learn/certificate) are signed by known identities on each blockchain via a [threshold signature](/learn/threshold-signature) scheme. **It's the combination of publicly verifiable zk proofs and robust distributed signatures that allow the Topos XCP to rely on a consensus-less deterministic reliable broadcast of state transition certificates to ensure the global consistency of the ecosystem.**

docs/learn/reliable-broadcast.md

@@ -0,0 +1,7 @@
+---
+sidebar_position: 5
+---
+
+# Reliable Broadcast
+
+## Causal Ordering

docs/learn/threshold-signature.md

@@ -0,0 +1,21 @@
+---
+sidebar_position: 4
+---
+
+# Threshold Signature
+
+## Digital Signature
+
+To prevent spamming, false identity and data tampering, Topos XCP leverages _digital signatures_ to ensure Certificates are attributed to the right originators—i.e. the blockchains that emit them to prove the validity of their state transitions—and that their integrity is retained during their propagation. As seen previously, signatures are included in Certificates and hence can be validated prior to verifying the Certificate validity.
+
+## R-ICE-FROST
+
+To allow a non-unary and dynamic set of signers to sign Certificates against a static public key, Topos XCP makes use of **R-ICE-FROST**, an in-house customization of the [FROST](https://eprint.iacr.org/2020/852.pdf) threshold signature scheme.
+
+:::tip Threshold Signature
+
+A _t out of n_ threshold signature scheme is a multi-party digital signature protocol such that a subset of cardinality _t_ of the _n_ participants is large enough to successfully create a valid signature.
+
+:::
+
+In addition to augmenting FROST with robustness, the R-ICE-FROST protocol allows a blockchain network to distribute a **static long-running public key** against which partial signatures can be produced by any set of signers. This is a key feature for blockchains, i.e. dynamic networks whose participating nodes arbitrarily join and leave.

docs/learn/zkSTARK.md

@@ -0,0 +1,15 @@
+---
+sidebar_position: 2
+---
+
+# zkSTARK
+
+## Zero-knowledge Proofs
+
+Zero-knowledge protocols are such that allow one party to prove the validity of a given statement without revealing any information from it to another—verifying—party. Such technology has received major attraction in the field of blockchain for it is privacy enhancing, a property that is central to multi-chain networks open to both public and private ledgers.
+
+Topos XCP leverages zero-knowledge proofs in how a blockchain proves the validity of its state transitions to the rest of the ecosystem. More specifically, Topos XCP leverages zkSTARKs.
+
+## zkSTARKs
+
+zkSTARK stands for zero-knowledge scalable transparent argument of knowledge. Such proofs can be **non-interactive**, i.e. the verifying party need not interact with the prover to verify the proof. zkSNARKs are specifically used to prove **computation integrity**, meaning given a known computation specified by an alegbraic intermediate representation (AIR) or by a permuted algebraic intermediate representation (PAIR), the verifying party can attest the validity of the computation. The "zk" in zkSTARK adds the property that some inputs to that computation remain opaque to the verifier.