zilliqa / scilla

Scilla - A Smart Contract Intermediate Level Language

Zilliqa

Overview

Zilliqa is a scalable smart contract platform that aims to tackle the congestion issue plaguing the blockchain industry. Zilliqa utilises a unique sharded architecture to achieve parallel processing of transactions while maintaining a large number of public nodes. Hence, Zilliqa is a blockchain capable of reaching high throughput and processing more complex computations while remaining decentralised and secure.

• If you’re interested in mining Zilliqa, see here: https://dev.zilliqa.com/docs/miners/mining-getting-started/.
• If you’d like to use the interface with Zilliqa nodes to transfer ZIL and deploy/call smart contracts, see here: https://dev.zilliqa.com/docs/apis/api-introduction.
• If you’re interested more about the core protocol, see the developer portal.
• If you’re interested in hacking on the Zilliqa code base, see the Coding Guidelines.

NOTE: The master branch is not for production as development is currently being worked constantly, please use the tag releases if you wish to work on the version of Zilliqa client that is running live on the Zilliqa blockchain.

Zilliqa Mainnet

The current live version on the Zilliqa Mainnet is Zilliqa v9.2.3 and Scilla v0.13.3.

	URL(s)
API URL	https://api.zilliqa.com/
Block Explorer	Viewblock DEVEX

Developer Testnet

The current live version on the Developer Testnet is Zilliqa v9.2.5 and Scilla v0.13.3.

	URL(s)
API URL	https://dev-api.zilliqa.com/
Block Explorer	Viewblock DEVEX
Faucet	Link

Zilliqa Improvement Proposal (ZIP)

The Zilliqa Improvement Proposals (ZIPs) are the core protocol standards for the Zilliqa platform.To view or contribute to ZIP, please visit https://github.com/Zilliqa/zip

Available Features

The current release has the following features implemented:

• Network sharding
• Transaction sharding
• Ethash Proof of Work (PoW) for joining the network
• GPU (OpenCL and CUDA) for PoW
• Block rewarding mechanism
• Gas pricer
• Coinbase rewards
• EC-Schnorr signature
• pBFT Consensus mechanism
• Data layer and accounts store
• Smart contract layer
• State delta forwarding
• Lookup nodes and Seed nodes for receiving and dispatching transactions
• Persistent storage for transactions and state
• S3 storage retrieval from archival nodes.
• View change mechanism
• Node recovery mechanism
• Protocol upgrade mechanism
• Gossip protocol for network message broadcasting
• Seed Node Staking

In the coming months, we plan to have the following features:

• Further unit and integration tests
• Enhancement of existing features
• More operating system support
• And much more...

Minimum System Requirements

To run Zilliqa, we recommend the minimum system requirements specified in our Mining page.

Build from Source Code

Starting with Zilliqa v8.6.0, the officially supported operating system is Ubuntu 22.04.

If you'd like to experiment with a different distro (including the previously supported Ubuntu 18.04), please make sure to install gcc >= 11.

Run the following to install the build dependencies:

sudo apt-get update
sudo apt-get install autoconf \
    build-essential \
    ccache \
    clang-format \
    clang-tidy \
    git \
    lcov \
    libcurl4-openssl-dev \
    libssl-dev \
    libtool \
    libxml2-utils \
    ninja-build \
    ocl-icd-opencl-dev \
    pkg-config \
    python3-dev \
    python3-pip \
    libgmp-dev \
    bison \
    gawk
git submodule update --init --recursive

Run the following to install latest version of cmake. CMake version >= 3.19 must be used:

wget https://github.com/Kitware/CMake/releases/download/v3.19.3/cmake-3.19.3-Linux-x86_64.sh
mkdir -p "${HOME}"/.local
bash ./cmake-3.19.3-Linux-x86_64.sh --skip-license --prefix="${HOME}"/.local/
export PATH=$HOME/.local/bin:$PATH
cmake --version
rm cmake-3.19.3-Linux-x86_64.sh

To install, clone vcpkg to a separate location (do not use brew on macos):

$ git clone https://github.com/Microsoft/vcpkg.git /path/to/vcpkg
$ cd /path/to/vcpkg && git checkout 2022.09.27 && ./bootstrap-vcpkg.sh
$ cd /path/to/zilliqa
$ export VCPKG_ROOT=/path/to/vcpkg

As part of building our source code, we patch websocketpp 0.8.2 to compile on C++20; please see the license: https://github.com/zaphoyd/websocketpp/blob/master/COPYING.

Build Zilliqa from the source:

# build Zilliqa binary
$ ./build.sh

If you want to contribute by submitting code changes in a pull request perform the build with clang-format and clang-tidy enabled by doing:

$ ./build.sh style

Build Scilla for Smart Contract Execution

The Zilliqa client works together with Scilla for executing smart contracts. Please refer to the Scilla repository for build and installation instructions.

Boot Up a Local Testnet for Development

1. Run the local testnet script in build directory:

   $ cd build && ./tests/Node/pre_run.sh && ./tests/Node/test_node_lookup.sh && ./tests/Node/test_node_simple.sh

2. Logs of each node can be found at ./local_run

3. To terminate Zilliqa:

   $ pkill zilliqa

Start a local network development environment

This is similar to the above, but deploys a local testnet to a local minikube cluster.

You can find documentation on how to do this on your local machine in docs/localdev.md.

You can find scripts which will set up an Ubuntu 22.04 machine in the cloud (or install necessary dependencies on your machine) in docs/setup/README.md.

Further Enquiries

	Link(s)
Development discussion (discord)
Bug report
Security contact	security 🌐 zilliqa.com
Security bug bounty	HackerOne bug bounty

scilla's Issues

Evaluator for contracts based on messages.

• Handling ill-formed messages;
• Supporting blockchain state;
• Step-based simulation;

Support accessing special variables in mutable state initialization

@ilyasergey

Amrit and me were further analyzing the zil-game contract, and we realized that if neither of the player makes a move (Play), then the money is frozen in the account. Withdraw that I added today cannot help (yet). To be able to make this safe, we need to set another timer, after which the owner can withdraw.

To achieve this, we'll need a mutable variable "start_block" that can be initialized with the block number during contract creation. We have no syntax to achieve this.

field player_a_hash : Option Hash = None {Hash}
field player_b_hash : Option Hash = None {Hash}
field timer         : Option BNum  = None {BNum}
field start_block : BNum <- & BLOCKNUMBER

What are your thoughts on this?

Setup LLVM OCaml interface

Add infrastructure for generating LLVM IR from parsed Scilla code. This task is to setup working with LLVM from Scilla.

Emacs indentation for multi-line constructs

The following snipped is not indented correctly:

match A with
| _ ->
  expr = {something ;
          something_else}

Implement ERC20 in Scilla

• Keep track of missing primitives, so they could be added to the standard libray

Implementation of the type checker

Improve zil-game

1. game-on variable is only being set but not used. Use it appropriately.
2. Add a new transition for the owner to claim back money in either of below two cases:
   (a) Too much time has passed and none of the players have claimed back.
   (b) Player-a = Player-b (same solution) and owner rightfully can get back the money. (right now, the owner depends on player-a or player-b to actually make a claim for him/her to get it back).

Add bash script for OCaml setup

Add a script to automate the OCaml setup process described in README.md. Running this on an Ubuntu system should make the system ready for building Scilla.

An API for serializing/deserializing contract state

• The OCaml data type should contain separate environments for contract parameters (immutable) and fields (mutable)

ScillaLexer.mll reads Sha3256 instead of Sha256.

ScillaLexer.mll in lang/syntax at line 21 reads let sha3256 = '0' 'x' ['a'-'f' '0'-'9']+. Aren't we using Sha256 and not Sha3-256? I think it will be good to be homogenous in terms of notations.

Extraction of programs into Coq for Scilla-Coq

See https://github.com/Zilliqa/scilla-coq

Command line parsing

Support below command line:

./scilla-runner -init init.json -istate input_state.json -iblockchain input_blockchain.json -imessage input_message.json -o output.json -i input.scilla

All arguments are mandatory and no other argument to be supported yet.

Add explicit types to `Emp` literal

Canonical representation of maps

• Sort the keys

Design standard library

A library to be included with each contract, to avoid duplication. Involves the following data types:

• Booleans
• Hashes
• Integers
• Natural numbers
• Lists
• Maps

Describe the interfaces in a separate document

Create a test for a contract calling another one

This can be a simple contract that invokes the crowdfunding contract, at a pre-determined address. This is to enable testing main Zilliqa code that is responsible for creating chains of contracts calls

Emacs mode doesn't correctly highlight strings in comments

Try

(* This is a string: "abc" *)
let s = "abc" in s

Rename "Pair" (datatype) to "Product", and "And" to "Pair"

Use of "And" in Scilla source can cause confusion. So rename it.

Support for primitive recursion

Primitive recursion for the following natively supported data types:

• Lists
• Nats

Automated test suite

Tests should be run automatically and cover the entire infrastructure: parser, evaluator, code generator, etc.

Some resources:

• http://jbuilder.readthedocs.io/en/latest/tests.html
• http://ounit.forge.ocamlcore.org/api-ounit/index.html

Write a tic-tac-toe game in Scilla

This is for getting a hang of writing Scilla code, and testing new ADTs such as Lists (and other features of the interpreter).

Implement standard library

Based on the design from #44

Synthesis from Scilla-Coq implementation

Utilities for debug output

Using printf everywhere is ugly and difficult to control.

Get rid of `assert false` in `JSON.ml`

It seems like those can be removed with a minor refactoring in most of the cases (I removed some).

Use, result-returning functions instead (pure/fail), so the failed attempt to serialize/deserialize would be handled with a meaningful message.

Implement ERC721 in Scilla

https://medium.com/blockchannel/walking-through-the-erc721-full-implementation-72ad72735f3c
https://medium.com/crypto-currently/the-anatomy-of-erc721-e9db77abfc24
http://erc721.org/
The official page:
https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md

Support for hashing

Implement using the cryptokit library

Implementation for pattern matching with embedded ADTs

Should support semantics of the following construct (as an example):

  match tm with
  | Some x => Some {BNum} x
  | None   => Some {BNum} z

Run individual tests from the suite with a simple command line interface.

Evaluator for expressions

Add support for string literals

Test and fix issue with multiple message output

See end of #55 for details. No test currently covers multi message output.

Setup Travis CI integration

Create a Payment Channel using Scilla

https://medium.com/@matthewdif/ethereum-payment-channel-in-50-lines-of-code-a94fad2704bc

Separate type for Money

• Needed to track cash flows

Implement cryptographic signing and signature checking

An API for serializing/deserializing messages.

• Use the data structure for messages
• Serialized records should have type information to match again parameter declarations i ncontract transitions.

Support for polymorphic types

Support Events in Scilla

This requirement came from the proposal to support ERC20 #43

Misc error checks

• 1. Either both -imessage and -istate options can be provided or both not (depending on contact creation or not). Enforce this.
• 2. Length / type for addresses and hashes in jsons aren't being verified.
• 3. More meaning full error messages for json parsing.
• 4. init.json must be validated even for contract creation.
• 5. Add test case for contract creation.

HMAC in BuiltIns.ml

@ilyasergey It seems like we are using an HMAC with a predefined key. We should replace HMAC with a normal SHA256.

A Type Checker for Scilla

• Type-checking expressions
• Basic effect tracking for statements
• Better dynamic type annotation (for ADTs)
• Bottom type an covariance

Implement a tracer/debugger for Scilla evaluation

Generalise from the "Result" monad, used now to bind sub-evaluations together (via Functors) and instantiate it differently in a debug mode.

Constraint-based cash flow tracking

• Checking that no funds go unaccounted
• Uses a dedicated type for Money

Emacs mode for Scilla keyword highlighting and indentation

Parser support for error reporting.

If a parser fails, provide a line number and a location in it, not a global location in the file.

Make _sender, _amount and _tag implicit to the language

transition GetFunds (sender: Address)

Now, sender field like this is a variable and is not tied with the actual sender of the transaction. Must make amends such that the field is same as the transaction sender.

Fix hashing in Scilla interpreter

Currently, a number to be hashed, say "1" (represented currently as a string) is hashed as "(IntLit 1)". This needs to be standardized.

Implementing Randao for random number generation

https://github.com/randao/randao/blob/master/contracts/Randao.sol. There is a more secure version called Randao++. But this will require zero-knowledge proofs. For now, we can go with Randao. It will only require hashing.

An API for the blockchain-related state

• BLOCKNUMBER
• TRANSACTION