Welcome to the Dune Developer Documentation!

The Project

Dune is a distributed consensus platform with meta-consensus capability. Dune not only comes to consensus about the state of its ledger, like Bitcoin or Ethereum. It also attempts to come to consensus about how the protocol and the nodes should adapt and upgrade.

• Developer documentation is available online at https://dune.network/docs/dune-node-mainnet . Make sure you are consulting the right version.
• The website https://dune.network/ contains more information about the project.
• All development happens on GitLab at https://gitlab.com/dune-network

The source code of Dune is placed under the GPLv3 License.

The Community

• The website of the Dune Foundation.

• Dune sub-reddit is an important meeting point of the community.

• Several community-built block explorers are available:

  • https://dunscan.io
  • https://testnet.dunscan.io

• More resources can be found on https://docs.dune.network

The Networks

Mainnet

The Dune network is the current incarnation of the Dune blockchain.

It runs with real DUNs from several sources:

• Foundators of Dune received tokens on June 24, 2019
• Tezos users received tokens through an airdrop in September 2019
• Tezos ICO participants can claim DUNs equivalent to their Tezos allocation (see Activate ICO account - Mainnet).

The Dune network has been live and open since June 24th, 2019.

All the instructions in this documentation are valid for Mainnet however we strongly encourage users to first try all the introduction tutorials on Testnet to familiarize themselves without risks.

Testnet

Dune Testnet is a test network for the Dune blockchain with a faucet to obtain free DUNs (see Get free DUNs). It is updated and rebooted rarely and it is running the same code as the Mainnet. It is the reference network for developers wanting to test their software before going to beta and for users who want to familiarize themselves with Dune before using their real DUNs.

We offer support for Testnet on IRC.

Getting started

The best place to start exploring the project is following the How Tos in the introduction.

Documentation:

• Dune Documentation

Introduction tutorials:

• How to get Dune
  • Docker images
  • Build from sources
• How to use Dune
  • The binaries
  • Read The Friendly Manual
  • Node
  • Client
• How to run Dune
  • Delegating your coins
  • Running a delegate

User documentation:

• Key Management
  • Ledger support
  • Signer
  • Activate ICO account - Mainnet
• Baker Account Management
  • Account Administrator
  • Disabling/Enabling Delegation
  • Removing Delegations
  • Controling the Number of Rolls
  • Controling Destinations of Transfers
  • Viewing/modifying Everything at once
  • New Michelson Instructions
• Sandboxed mode
  • Run a sandboxed node
  • Use the sandboxed client
  • Tune protocol alpha parameters
  • Preserve data
• History modes
  • History modes in a nutshell
  • Setting up a node in full mode
  • Setting up a node in rolling mode
  • Setting up a node in archive mode
  • Switching between node’s modes
• Snapshots
  • Importing a snapshot
  • Exporting a snapshot
• Various
  • Private node
  • Configuration options for the node
  • Environment for writing Michelson contracts
  • Debugging
  • Admin Client
• Glossary
  • Dune
  • Protocol alpha

White doc:

• Dune Software Architecture
  • The Big Picture
  • Software Architecture and Packages Relationship
• The peer-to-peer layer
  • General operation
  • Welcome worker
  • Maintenance worker
• The validation subsystem
  • Validator
  • Prevalidator
  • Distributed DB
• Michelson: the language of Smart Contracts in Dune
  • Semantics
  • Introduction to the type system and notations
  • Core data types and notations
  • Core instructions
  • Operations
  • Domain specific data types
  • Domain specific operations
  • Macros
  • Concrete syntax
  • Annotations
  • JSON syntax
  • Examples
  • Full grammar
  • Reference implementation
• Proof-of-stake in Dune
  • Blocks
  • Delegation
  • Cycles
  • Accusations

the Love Smart-Contract Language:

• Introduction
• Love Reference
  • Contract Format
  • Basic Types and Values
  • The Modules and Contracts System
  • Love Grammar
• Love primitives
  • Prefix & Infix primitives
  • Comparison between values
  • The Current module
  • Raising exceptions
  • Operations on tuples
  • Operations on numeric values
  • Operations on contracts
  • Cryptographic operations
  • Operations on bytes
  • Operations on strings
  • Operations on lambdas
  • Operations on lists
  • Operations on sets
  • Operations on maps
  • Operations on Big maps
• Tutorial for Love (coming soon)

Developer Tutorials:

• JSON/RPC interface
• The data_encoding library
  • Examples/Tutorial
  • How the Dataencoding module works
• The Error Monad
  • Why you want the error monad
  • A simple version of the error monad
  • A slight improvement
  • Traces
  • A more descriptive message
  • Putting Lwt.t in the mix
  • The actual Dune error monad
• Michelson Anti-Patterns
  • Refunding to a list of contracts
  • Avoid batch operations when users can increase the size of the batch
  • Signatures alone do not prevent replay attacks
  • Storing/transferring private data
  • Not setting all state before a transfer
  • Do not store funds for others in spendable contracts
• How to start reading protocol Alpha
  • The TEZOS_PROTOCOL structure
  • The big abstraction barrier: Alpha_context
  • Below the Alpha_context
  • Above the Alpha_context
• Economic protocol sandboxing
• How to test a protocol proposal
  • Branches
  • Unit tests and sandbox
  • Test migration on Mainnet
  • Tips and tricks
  • Anatomy of migration code
• Profiling the Dune node
  • Memory profiling the OCaml heap
  • Memory profiling the C heap
  • Performance profiling
• Flexible Network Sandboxes
  • Build
  • Usage
  • Examples
  • Implementation Considerations
  • Special Coding Style
• Python Execution and Testing Environment
  • Code organization
  • Installation
  • A simple sandbox scenario
  • Test suite and pytest
  • TODO
  • Known issues
• How to contribute
  • Introduction
  • Reporting issues
  • First steps
  • Where to start
  • Our git workflow
  • Code Review

APIs:

• Building documentation locally
  • Building instructions
  • Sphinx extensions
  • OCaml documentation
• Online OCaml Documentation
• Command Line Interface
  • Client manual
  • Admin-client manual
  • Signer manual
  • Baker manual
  • Endorser manual
  • Accuser manual
• RPCs - Index
  • Shell
  • Protocol Alpha
• RPCs - Full description
  • Shell
  • Protocol Alpha
• RPC Errors
  • Protocol Alpha
  • Shell
  • Michelson parsing/macros
  • Client
  • Miscellaneous
• P2P message format
  • Block header (shell)
  • fitness.elem
  • Operation (shell)
  • Block_header (alpha-specific)
  • Operation (alpha-specific)
  • X_0
  • X_2
  • X_3
  • X_5
  • Z.t
  • X_6
  • X_4
  • X_7 (Determined from data, 8-bit tag)
  • scripted.opt_or_hash (Determined from data, 8-bit tag)
  • contract_id (22 bytes, 8-bit tag)
  • entrypoint (Determined from data, 8-bit tag)
  • X_8
  • N.t
  • public_key (Determined from data, 8-bit tag)
  • public_key_hash (21 bytes, 8-bit tag)
  • fitness.elem
  • block_header.alpha.full_header
  • inlined.endorsement.contents (5 bytes, 8-bit tag)
  • inlined.endorsement
  • operation.alpha.contents (Determined from data, 8-bit tag)

Indices and tables

• Index
• Module Index
• Search Page