elois-compose-metrics to master · nodes / rust / Duniter v2S

Some changes are not shown.

For a faster browsing experience, only 38 of 422 files are shown. Download one of the files below to see all changes.

.cargo/config

deleted100644 → 0

+0 −5

Original line number	Original line	Diff line number	Diff line
	[alias]
	cucumber = "test -p duniter-end2end-tests --test cucumber_tests --"
	tu = "test --workspace --exclude duniter-end2end-tests"
	xtask = "run --package xtask --"

.cargo/config.toml

0 → 100644

+13 −0

Original line number	Original line	Diff line number	Diff line
			[alias]
			sanity-gdev = "test -Zgit=shallow-deps -p duniter-live-tests --test sanity_gdev -- --nocapture"
			tu = "test -Zgit=shallow-deps --workspace --exclude duniter-end2end-tests --exclude duniter-live-tests --features constant-fees" # Unit tests with constant-fees
			tf = "test -Zgit=shallow-deps --workspace --exclude duniter-end2end-tests --exclude duniter-live-tests test_fee" # Custom fee model tests
			# `te` and `cucumber` are synonyms
			te = "test -p duniter-end2end-tests --test cucumber_tests --features constant-fees --"
			cucumber-build = "build -Zgit=shallow-deps --features constant-fees"
			cucumber = "test -Zgit=shallow-deps -p duniter-end2end-tests --test cucumber_tests --"
			ta = "test -Zgit=shallow-deps --workspace --exclude duniter-live-tests --features constant-fees"
			tb = "test -Zgit=shallow-deps --features runtime-benchmarks -p"
			rbp = "run -Zgit=shallow-deps --release --features runtime-benchmarks -- benchmark pallet --chain=dev --steps=50 --repeat=20 --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --header=./file_header.txt --output=. --pallet"
			xtask = "run -Zgit=shallow-deps --package xtask --"
			cucumber-node = "run -Zgit=shallow-deps -- --chain=gdev_dev --execution=Native --sealing=manual --force-authoring --rpc-cors=all --tmp --rpc-port 9944 --alice --features constant-fees"

.dockerignore

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -6,3 +6,4 @@ docker/Dockerfile
	docker-compose.yml		docker-compose.yml
	arm-build/		arm-build/
	**/target/		**/target/
			build/

.github/PULL_REQUEST_TEMPLATE.md

+1 −1

Original line number	Original line	Diff line number	Diff line
	This project is tracked on our hosted gitlab server at: https://git.duniter.org/nodes/typescript/duniter/gitlab		This project is tracked on our hosted gitlab server at: https://git.duniter.org/nodes/rust/duniter-v2s

	The current github repository is a simple clone taken up to date at each push on the main gitlab repository.		The current github repository is a simple clone taken up to date at each push on the main gitlab repository.

.gitlab-ci.yml

+457 −163

File changed.

Preview size limit exceeded, changes collapsed.

.maintain/local-docker-test-network/duniter.Dockerfile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -29,7 +29,7 @@ USER duniter
	# check if executable works in this container		# check if executable works in this container
	RUN /usr/local/bin/duniter --version		RUN /usr/local/bin/duniter --version

	EXPOSE 30333 9933 9944		EXPOSE 30333 9944
	VOLUME ["/duniter"]		VOLUME ["/duniter"]

	ENTRYPOINT ["/usr/local/bin/duniter"]		ENTRYPOINT ["/usr/local/bin/duniter"]

.vscode/launch.json

+36 −23

Original line number	Original line	Diff line number	Diff line
	@@ -9,7 +9,12 @@
	"request": "launch",		"request": "launch",
	"name": "Debug unit tests in library 'duniter'",		"name": "Debug unit tests in library 'duniter'",
	"cargo": {		"cargo": {
	"args": ["test", "--no-run", "--lib", "--package=duniter"],		"args": [
			"test",
			"--no-run",
			"--lib",
			"--package=duniter"
			],
	"filter": {		"filter": {
	"name": "duniter",		"name": "duniter",
	"kind": "lib"		"kind": "lib"
	@@ -23,13 +28,20 @@
	"request": "launch",		"request": "launch",
	"name": "Debug executable 'duniter'",		"name": "Debug executable 'duniter'",
	"cargo": {		"cargo": {
	"args": ["build"],		"args": [
			"build"
			],
	"filter": {		"filter": {
	"name": "duniter",		"name": "duniter",
	"kind": "bin"		"kind": "bin"
	}		}
	},		},
	"args": ["--tmp", "--dev", "--execution", "Native"],		"args": [
			"--tmp",
			"--dev",
			"--execution",
			"Native"
			],
	"cwd": "${workspaceFolder}"		"cwd": "${workspaceFolder}"
	},		},
	{		{
	@@ -37,7 +49,12 @@
	"request": "launch",		"request": "launch",
	"name": "Debug unit tests in executable 'duniter'",		"name": "Debug unit tests in executable 'duniter'",
	"cargo": {		"cargo": {
	"args": ["test", "--no-run", "--bin=duniter", "--package=duniter"],		"args": [
			"test",
			"--no-run",
			"--bin=duniter",
			"--package=duniter"
			],
	"filter": {		"filter": {
	"name": "duniter",		"name": "duniter",
	"kind": "bin"		"kind": "bin"
	@@ -51,7 +68,12 @@
	"request": "launch",		"request": "launch",
	"name": "Debug unit tests in library 'gdev-runtime'",		"name": "Debug unit tests in library 'gdev-runtime'",
	"cargo": {		"cargo": {
	"args": ["test", "--no-run", "--lib", "--package=gdev-runtime"],		"args": [
			"test",
			"--no-run",
			"--lib",
			"--package=gdev-runtime"
			],
	"filter": {		"filter": {
	"name": "gdev-runtime",		"name": "gdev-runtime",
	"kind": "lib"		"kind": "lib"
	@@ -65,7 +87,12 @@
	"request": "launch",		"request": "launch",
	"name": "Debug unit tests in library 'pallet-certification'",		"name": "Debug unit tests in library 'pallet-certification'",
	"cargo": {		"cargo": {
	"args": ["test", "--no-run", "--lib", "--package=pallet-certification"],		"args": [
			"test",
			"--no-run",
			"--lib",
			"--package=pallet-certification"
			],
	"filter": {		"filter": {
	"name": "pallet-certification",		"name": "pallet-certification",
	"kind": "lib"		"kind": "lib"
	@@ -78,29 +105,15 @@
	"type": "lldb",		"type": "lldb",
	"request": "launch",		"request": "launch",
	"name": "Debug unit tests in library 'pallet-identity'",		"name": "Debug unit tests in library 'pallet-identity'",
	"cargo": {
	"args": ["test", "--no-run", "--lib", "--package=pallet-identity"],
	"filter": {
	"name": "pallet-identity",
	"kind": "lib"
	}
	},
	"args": [],
	"cwd": "${workspaceFolder}"
	},
	{
	"type": "lldb",
	"request": "launch",
	"name": "Debug unit tests in library 'pallet-ud-accounts-storage'",
	"cargo": {		"cargo": {
	"args": [		"args": [
	"test",		"test",
	"--no-run",		"--no-run",
	"--lib",		"--lib",
	"--package=pallet-ud-accounts-storage"		"--package=pallet-identity"
	],		],
	"filter": {		"filter": {
	"name": "pallet-ud-accounts-storage",		"name": "pallet-identity",
	"kind": "lib"		"kind": "lib"
	}		}
	},		},

.vscode/settings.json

+7 −10

Original line number	Original line	Diff line number	Diff line
	{		{
	"editor.formatOnSave": true,		"editor.formatOnSave": true,
	"editor.rulers": [100],		"editor.rulers": [
	"[typescript]": {		100
	"editor.defaultFormatter": "esbenp.prettier-vscode"		],
	},
	"[json]": {		"[json]": {
	"editor.defaultFormatter": "esbenp.prettier-vscode"		"editor.defaultFormatter": "vscode.json-language-features"
	},
	"[javascript]": {
	"editor.defaultFormatter": "esbenp.prettier-vscode"
	},		},
	"[yaml]": {		"[yaml]": {
	"editor.defaultFormatter": "esbenp.prettier-vscode"		"editor.defaultFormatter": "esbenp.prettier-vscode"
	@@ -18,5 +14,6 @@
	"port_p2p": 19931,		"port_p2p": 19931,
	"port_rpc": 19932,		"port_rpc": 19932,
	"port_ws": 19933		"port_ws": 19933
	}		},
			"rust-analyzer.showUnlinkedFileNotification": false
	}		}
			No newline at end of file

CONTRIBUTING.md

+18 −20

Original line number	Original line	Diff line number	Diff line
	@@ -4,7 +4,7 @@ Before contributing, please make sure that your development environment is prope

	[Setting up your development environment]		[Setting up your development environment]

	Sign-ups on our gitlab are disabled. If you would like to contribute, please ask for its creation on [the technical forum].		Sign-ups on our gitlab are disabled. If you would like to contribute, please ask for an account on [the technical forum].

	When contributing to this repository, please first discuss the change you wish to make via issue or		When contributing to this repository, please first discuss the change you wish to make via issue or
	via [the technical forum] before making a change.		via [the technical forum] before making a change.
	@@ -13,40 +13,38 @@ Please note we have a specific workflow, please follow it in all your interactio

	## Developer documentation		## Developer documentation

	Please read [Developer documentation] before contribute.		Please read [Developer documentation] before contributing.

	## Workflow		## Workflow

			- If there is an unassigned issue about the thing you want to contribute to, assign the issue to yourself.
	- Create a branch based on `master` and prefixed with your nickname. Give your branch a short name indicating the subject.		- Create a branch based on `master` and prefixed with your nickname. Give your branch a short name indicating the subject.
	- Create an MR from your branch to `master`.		- Create an MR from your branch to `master`. Prefix the title with `Draft: ` until it's ready to be merged.
	- Never contribute to a branch of ahother contributor! If the contributor make a `git rebase` your commit will be lost !		- If the MR is related to an issue, mention the issue in the description using the `#42` syntax.
			- Never push to a branch of another contributor! If the contributor makes a `git rebase` your commit will be lost!
	- Before you push your commit:		- Before you push your commit:
	- Apply formatters (rustfmt and prettier) and linter (clippy)		- Apply formatters (rustfmt and prettier) and linter (clippy)
	- Document your code.		- Document your code
	- Apply the [project's git conventions]		- Apply the [project's git conventions]

	## Merge Process		## Merge Process

	1. Ensure you rebased your branch on the latest `master` commit to avoid any merge conflicts.		1. Ensure you rebased your branch on the latest `master` commit to avoid any merge conflicts.
			1. Ensure that you respect the [commit naming conventions].
	2. Ensure that you respect the [commit naming conventions].		1. Ensure that all automated tests pass with the `cargo test` command.
			1. Ensure that the code is well formatted `cargo fmt` and complies with the good practices `cargo clippy`. If you have been working on tests, check everything with `cargo clippy --all --tests`.
	3. Ensure that all automated tests pass with the `npm test` command.		1. Update the documentation with details of changes to the interface, this includes new environment variables, exposed ports, useful file locations and container parameters.
			1. Push your branch on the gitlab and create a merge request. Briefly explain the purpose of your contribution in the description of the merge request.
	4. Update the documentation with details of changes to the interface, this includes new environment		1. Mark the MR as ready (or remove the `Draft: ` prefix) only when you think it can be reviewed or merged.
	variables, exposed ports, useful file locations and container parameters.		1. Assign a Duniter reviewer so they will review your contribution. If you still have no news after several weeks, ask explicitly for a review, or tag another reviewer or/and talk about your contribution on [the technical forum].

	5. Push your branch on the gitlab and create a merge request. Briefly explain the purpose of your contribution in the description of the merge request.

	6. Tag a Duniter reviewer so they will review your contribution. If you still have no news after several weeks, tag another reviewer or/and talk about your contribution on [the technical forum].

	## List of Duniter's reviewers		## List of Duniter's reviewers

	- @librelois		- @HugoTrentesaux
	- @tuxmain		- @tuxmain

	[commit naming conventions]: ./docs/dev/git-conventions.md#naming-commits		[commit naming conventions]: ./docs/dev/git-conventions.md#naming-commits
	[Developer documentation]: ./docs/dev/index.md		[Developer documentation]: ./docs/dev/
	[project's git conventions]: ./docs/dev/git-conventions.md		[project's git conventions]: ./docs/dev/git-conventions.md
	[Setting up your development environment]: ./docs/setup.md		[Setting up your development environment]: ./docs/dev/setup.md
	[the technical forum]: https://forum.duniter.org		[the technical forum]: https://forum.duniter.org

Cargo.lock

+11466 −6300

File changed.

Preview size limit exceeded, changes collapsed.

Cargo.toml

+210 −133

File changed.

Preview size limit exceeded, changes collapsed.

README.md

+82 −176

Original line number	Original line	Diff line number	Diff line
	# Duniter v2s		# Duniter v2s

	A rewriting of [Duniter](https://duniter.org) based on [Substrate](https://www.substrate.io/) framework.		🆙 A rewriting of [Duniter v1](https://duniter.org) in the [Substrate](https://www.substrate.io/) framework.

	duniter-v2s is under active development, only a test network called "ĞDev" is deployed.		⚠️ Duniter-v2s is under active development.

			🚧 A test network called "ĞDev" is deployed, allowing to test wallets and indexers.

			<div align="center">
			<img alt="logov2" src="https://duniter.fr/img/duniterv2.svg" width="128" height="128"/>
			</div>

			## Documentation

			Multiple documentation sources are available depending on the level of detail you need.

			- Full technical Rust doc (auto-generated with `cargo xtask gen-doc`) : https://doc-duniter-org.ipns.pagu.re/duniter/
			- User and client developer doc (official website) : https://duniter.org/wiki/duniter-v2/
			- Internal documentation (within git repository), see table of contents below : [./doc](./doc)

			### Internal documentation TOC

			- [README](./README.md) (this file)
			- [Use](#use)
			- [Contribute](#contribute)
			- [License](#license)
			- [docs](./docs/) internal documentation
			- [api](./docs/api/) API
			- [manual](./docs/api/manual.md) manage account and identities
			- [runtime-calls](./docs/api/runtime-calls.md) the calls you can submit through the RPC API
			- [runtime-errors](./docs/api/runtime-errors.md) the errors you can get submitting a call
			- [runtime-events](./docs/api/runtime-events.md) the events you can get submitting a call
			- [dev](./docs/dev/) developer documentation
			- [beginner-walkthrough](./docs/dev/beginner-walkthrough.md)
			- [git-conventions](./docs/dev/git-conventions.md)
			- [pallet_conventions](./docs/dev/pallet_conventions.md)
			- [launch-a-live-network](./docs/dev/launch-a-live-network.md)
			- [setup](./docs/dev/setup.md)
			- [compilation features](./docs/dev/compilation.md)
			- [verify-runtime-code](./docs/dev/verify-runtime-code.md)
			- [weights-benchmarking](./docs/dev/weights-benchmarking.md)
			- [upgrade-substrate](./docs/dev/upgrade-substrate.md)
			- [replay-block](./docs/test/replay-block.md)
			- [user](./docs/user/) user documentation
			- [autocompletion](./docs/user/autocompletion.md)
			- [debian installation](./docs/user/installation_debian.md)
			- [distance](./docs/user/distance.md)
			- [fees](./docs/user/fees.md)
			- [packaging](./docs/packaging/) packaging
			- [build-for-arm](./docs/packaging/build-for-arm.md) build for ARM architecture
			- [build-debian](./docs/packaging/build-deb.md) build a native Debian package
			- [docker](./docker/) docker-related documentation
			- [end2end-tests](./end2end-tests/) automated end to end tests written with cucumber
			- [live-tests](./live-tests/) sanity checks to test the storage of a live chain

	## Use		## Use

	@@ -10,65 +59,41 @@ duniter-v2s is under active development, only a test network called "ĞDev" is d

	The easiest way is to use the docker image.		The easiest way is to use the docker image.

	Minimal command to deploy a temporary mirror peer:		Minimal command to deploy a temporary mirror peer:

	```docker		```docker
	docker run -it -p9944:9944 -e DUNITER_CHAIN_NAME=gdev duniter/duniter-v2s:v0.1.0 --tmp --execution=Wasm		docker run -it -p9944:9944 -e DUNITER_CHAIN_NAME=gdev duniter/duniter-v2s-gdev-800:latest
	```		```

	To go further, read [How to deploy a permanent mirror node on ĞDev network](./docs/user/rpc.md).		To go further, read [How to deploy a permanent mirror node on ĞDev network 🔗](https://duniter.org/wiki/duniter-v2/#run-a-mirror-node).

	### Create your local blockchain		### Create your local blockchain

	It can be useful to deploy your local blockchain, for instance to have a controled environement		It can be useful to deploy your local blockchain, for instance to have a controlled environment to develop/test an application that interacts with the blockchain.
	to develop/test an application that interact with the blockchain.

	```docker		```docker
	docker run -it -p9944:9944 duniter/duniter-v2s:v0.1.0 --tmp		docker run -it -p9944:9944 duniter/duniter-v2s-gdev-800:latest
	```		```

	Or use the `docker-compose.yml` at the root of this repository.		Or use the [`docker-compose.yml`](./docker-compose.yml) at the root of this repository.

	#### Control when your local blockchain should produce blocks		#### Control when your local blockchain should produce blocks

	By default, your local blockchain produce a new block every 6 seconds, which is not practical in some cases.		By default, your local blockchain produces a new block every 6 seconds, which is not practical in some cases.

	You can decide when to produce blocks with the cli option `--sealing`, , there are 2 possible modes:

	* `--sealing=instant`: produce a block immediately upon receiving a transaction into the transaction pool
	* `--sealing=manual`: produce a block upon receiving an RPC request (method `engine_createBlock`).

	### Autocompletion

	See [autocompletion](./docs/user/autocompletion.md).		You can decide when to produce blocks with the cli option `--sealing` which has two modes:

	## Test		- `--sealing=instant`: produce a block immediately upon receiving a transaction into the transaction pool
			- `--sealing=manual`: produce a block upon receiving an RPC request (method `engine_createBlock`).

	### Test a specific commit		### Shell autocompletion

	At each commit on master, an image with the tag `debug-sha-******` is published, where `******`		See [autocompletion](./docs/user/autocompletion.md) to generate shell autocompletion for duniter commands.
	corresponds to the first 8 hash characters of the commit.

	Usage:

	```docker
	docker run -it -p9944:9944 --name duniter-v2s duniter/duniter-v2s:debug-sha-b836f1a6
	```

	Then open `https://polkadot.js.org/apps/?rpc=ws%3A%2F%2F127.0.0.1%3A9944` in a browser.

	Enable detailed logging:

	```docker
	docker run -it -p9944:9944 --name duniter-v2s \
	-e RUST_LOG=debug \
	-e RUST_BACKTRACE=1 \
	-lruntime=debug \
	duniter/duniter-v2s:debug-sha-b836f1a6
	```

	## Contribute		## Contribute

			If you are beginner in Rust and need a well guided tutorial, follow the [beginner walkthrough](./docs/dev/beginner-walkthrough.md).

	Before any contribution, please read carefully the [CONTRIBUTING](./CONTRIBUTING.md) file and our [git conventions](./docs/dev/git-conventions.md).		Before any contribution, please read carefully the [CONTRIBUTING](./CONTRIBUTING.md) file and our [git conventions](./docs/dev/git-conventions.md).

	### Setup your dev environment		### Setup your dev environment
	@@ -77,7 +102,7 @@ First, complete the [basic setup instructions](./docs/dev/setup.md).

	### Build		### Build

	NOTE: You must first follow the instructions in the [Setup] section (#setup).		NOTE: You must first follow the instructions in the [Setup](#setup-your-dev-environment) section.

	Use the following command to build the node without launching it:		Use the following command to build the node without launching it:

	@@ -90,20 +115,11 @@ cargo build
	Use Rust's native `cargo` command to build and launch the node:		Use Rust's native `cargo` command to build and launch the node:

	```sh		```sh
	cargo run -- --dev --tmp		cargo run -- --dev
	```		```

	This will deploy a local blockchain with test accounts (Alice, Bob, etc) in the genesis.		This will deploy a local blockchain with test accounts (Alice, Bob, etc) in the genesis.
			Open `https://polkadot.js.org/apps/?rpc=ws%3A%2F%2F127.0.0.1%3A9944` to watch and interact with your node.
	## Single-Node Development Chain

	This command will start the single-node development chain with persistent state:

	```bash
	./target/debug/duniter --dev --tmp
	```

	Then open `https://polkadot.js.org/apps/?rpc=ws%3A%2F%2F127.0.0.1%3A9944` in a browser.

	Start the development chain with detailed logging:		Start the development chain with detailed logging:

	@@ -111,134 +127,24 @@ Start the development chain with detailed logging:
	RUST_LOG=debug RUST_BACKTRACE=1 ./target/debug/duniter -lruntime=debug --dev		RUST_LOG=debug RUST_BACKTRACE=1 ./target/debug/duniter -lruntime=debug --dev
	```		```

	## Multi-Node Local Testnet		## License

	If you want to see the multi-node consensus algorithm in action, refer to
	[our Start a Private Network tutorial](https://substrate.dev/docs/en/tutorials/start-a-private-network/).

	### Purge previous local testnet

	```		See [LICENSE](./LICENSE)
	./target/debug/duniter purge-chain --base-path /tmp/alice --chain local
	./target/debug/duniter purge-chain --base-path /tmp/bob --chain local

	```		```
			CopyLeft 2021-2023 Axiom-Team

	### Start Alice's node		Some parts borrowed from Polkadot (Parity Technologies (UK) Ltd.)

	```bash		Duniter-v2S is free software: you can redistribute it and/or modify
	./target/debug/duniter \		it under the terms of the GNU Affero General Public License as published by
	--base-path /tmp/alice \		the Free Software Foundation, version 3 of the License.
	--chain local \
	--alice \
	--port 30333 \
	--ws-port 9945 \
	--rpc-port 9933 \
	--node-key 0000000000000000000000000000000000000000000000000000000000000001 \
	--validator
	```

	### Start Bob's node		Duniter-v2S is distributed in the hope that it will be useful,
			but WITHOUT ANY WARRANTY; without even the implied warranty of
			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			GNU Affero General Public License for more details.

	```bash		You should have received a copy of the GNU Affero General Public License
	./target/debug/duniter \		along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.
	--base-path /tmp/bob \
	--chain local \
	--bob \
	--port 30334 \
	--ws-port 9946 \
	--rpc-port 9934 \
	--validator \
	--bootnodes /ip4/127.0.0.1/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp
	```		```

	## Project Structure

	A Substrate project such as this consists of a number of components that are spread across a few
	directories.

	### Node

	A blockchain node is an application that allows users to participate in a blockchain network.
	Substrate-based blockchain nodes expose a number of capabilities:

	- Networking: Substrate nodes use the [`libp2p`](https://libp2p.io/) networking stack to allow the
	nodes in the network to communicate with one another.
	- Consensus: Blockchains must have a way to come to
	[consensus](https://substrate.dev/docs/en/knowledgebase/advanced/consensus) on the state of the
	network. Substrate makes it possible to supply custom consensus engines and also ships with
	several consensus mechanisms that have been built on top of
	[Web3 Foundation research](https://research.web3.foundation/en/latest/polkadot/NPoS/index.html).
	- RPC Server: A remote procedure call (RPC) server is used to interact with Substrate nodes.

	There are several files in the `node` directory - take special note of the following:

	- [`chain_spec.rs`](./node/src/chain_spec.rs): A
	[chain specification](https://substrate.dev/docs/en/knowledgebase/integrate/chain-spec) is a
	source code file that defines a Substrate chain's initial (genesis) state. Chain specifications
	are useful for development and testing, and critical when architecting the launch of a
	production chain. Take note of the `development_chain_spec` and `testnet_genesis` functions, which
	are used to define the genesis state for the local development chain configuration. These
	functions identify some
	[well-known accounts](https://substrate.dev/docs/en/knowledgebase/integrate/subkey#well-known-keys)
	and use them to configure the blockchain's initial state.
	- [`service.rs`](./node/src/service.rs): This file defines the node implementation. Take note of
	the libraries that this file imports and the names of the functions it invokes. In particular,
	there are references to consensus-related topics, such as the
	[longest chain rule](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#longest-chain-rule),
	the [Babe](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#babe) block authoring
	mechanism and the
	[GRANDPA](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#grandpa) finality
	gadget.

	After the node has been [built](#build), refer to the embedded documentation to learn more about the
	capabilities and configuration parameters that it exposes:

	```shell
	./target/debug/duniter --help
	```

	### Runtime

	In Substrate, the terms
	"[runtime](https://substrate.dev/docs/en/knowledgebase/getting-started/glossary#runtime)" and
	"[state transition function](https://substrate.dev/docs/en/knowledgebase/getting-started/glossary#stf-state-transition-function)"
	are analogous - they refer to the core logic of the blockchain that is responsible for validating
	blocks and executing the state changes they define. The Substrate project in this repository uses
	the [FRAME](https://substrate.dev/docs/en/knowledgebase/runtime/frame) framework to construct a
	blockchain runtime. FRAME allows runtime developers to declare domain-specific logic in modules
	called "pallets". At the heart of FRAME is a helpful
	[macro language](https://substrate.dev/docs/en/knowledgebase/runtime/macros) that makes it easy to
	create pallets and flexibly compose them to create blockchains that can address
	[a variety of needs](https://www.substrate.io/substrate-users/).

	Review the [FRAME runtime implementation](./runtime/src/lib.rs) included in this template and note
	the following:

	- This file configures several pallets to include in the runtime. Each pallet configuration is
	defined by a code block that begins with `impl $PALLET_NAME::Config for Runtime`.
	- The pallets are composed into a single runtime by way of the
	[`construct_runtime!`](https://crates.parity.io/frame_support/macro.construct_runtime.html)
	macro, which is part of the core
	[FRAME Support](https://substrate.dev/docs/en/knowledgebase/runtime/frame#support-library)
	library.

	### Pallets

	The runtime in this project is constructed using many FRAME pallets that ship with the
	[core Substrate repository](https://github.com/paritytech/substrate/tree/master/frame) and a
	template pallet that is [defined in the `pallets`](./pallets/template/src/lib.rs) directory.

	A FRAME pallet is compromised of a number of blockchain primitives:

	- Storage: FRAME defines a rich set of powerful
	[storage abstractions](https://substrate.dev/docs/en/knowledgebase/runtime/storage) that makes
	it easy to use Substrate's efficient key-value database to manage the evolving state of a
	blockchain.
	- Dispatchables: FRAME pallets define special types of functions that can be invoked (dispatched)
	from outside of the runtime in order to update its state.
	- Events: Substrate uses [events](https://substrate.dev/docs/en/knowledgebase/runtime/events) to
	notify users of important changes in the runtime.
	- Errors: When a dispatchable fails, it returns an error.
	- Config: The `Config` configuration interface is used to define the types and parameters upon
	which a FRAME pallet depends.

client/distance/Cargo.toml

0 → 100644

+42 −0

Original line number	Original line	Diff line number	Diff line
			[package]
			edition.workspace = true
			homepage.workspace = true
			license.workspace = true
			description = "Duniter client distance"
			name = "dc-distance"
			readme = "README.md"
			version = "1.0.0"
			repository.workspace = true

			[package.metadata.docs.rs]
			targets = ["x86_64-unknown-linux-gnu"]

			[features]
			std = [
			"frame-support/std",
			"pallet-distance/std",
			"sp-core/std",
			"sp-distance/std",
			"sp-runtime/std",
			]
			runtime-benchmarks = [
			"frame-support/runtime-benchmarks",
			"pallet-distance/runtime-benchmarks",
			"sp-runtime/runtime-benchmarks",
			]
			try-runtime = [
			"frame-support/try-runtime",
			"pallet-distance/try-runtime",
			"sp-distance/try-runtime",
			"sp-runtime/try-runtime",
			]

			[dependencies]
			frame-support = { workspace = true }
			log = { workspace = true }
			pallet-distance = { workspace = true }
			sc-client-api = { workspace = true }
			sp-core = { workspace = true }
			sp-distance = { workspace = true }
			sp-runtime = { workspace = true }
			thiserror = { workspace = true }

client/distance/README.md

0 → 100644

+3 −0

# Distance Oracle Inherent Data Provider

You can find the autogenerated documentation at: [https://doc-duniter-org.ipns.pagu.re/dc_distance/index.html](https://doc-duniter-org.ipns.pagu.re/dc_distance/index.html).

client/distance/src/lib.rs

0 → 100644

+186 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2022 Axiom-Team
			//
			// This file is part of Substrate-Libre-Currency.
			//
			// Substrate-Libre-Currency is free software: you can redistribute it and/or modify
			// it under the terms of the GNU Affero General Public License as published by
			// the Free Software Foundation, version 3 of the License.
			//
			// Substrate-Libre-Currency is distributed in the hope that it will be useful,
			// but WITHOUT ANY WARRANTY; without even the implied warranty of
			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			// GNU Affero General Public License for more details.
			//
			// You should have received a copy of the GNU Affero General Public License
			// along with Substrate-Libre-Currency. If not, see <https://www.gnu.org/licenses/>.

			//! # Distance Oracle Inherent Data Provider
			//!
			//! This crate provides functionality for creating an inherent data provider
			//! specifically designed for the "Distance Oracle".
			//! The inherent data provider is responsible for fetching and delivering
			//! computation results required for the runtime to process distance evaluations.
			//!
			//! ## Relationship with Distance Oracle
			//!
			//! The distance-oracle is responsible for computing distance evaluations,
			//! storing the results to be read in the next period, and saving them to files.
			//! These files are then read by this inherent data provider
			//! to provide the required data to the runtime.
			//!
			//! ## Overview
			//!
			//! - Retrieves period index and evaluation results from the storage and file system.
			//! - Determines whether the computation results for the current period have already been published.
			//! - Reads and parses evaluation result files when available, providing the necessary data to the runtime.

			use frame_support::pallet_prelude::*;
			use sc_client_api::{ProvideUncles, StorageKey, StorageProvider};
			use sp_runtime::{generic::BlockId, traits::Block as BlockT, AccountId32};
			use std::path::PathBuf;

			/// The file version that should match the distance oracle one.
			/// This ensures that the smith avoids accidentally submitting invalid data
			/// in case there are changes in logic between the runtime and the oracle,
			/// thereby preventing potential penalties.
			const VERSION_PREFIX: &str = "001-";

			type IdtyIndex = u32;

			#[derive(Debug, thiserror::Error)]
			pub enum Error<B: BlockT> {
			#[error("Could not retrieve the block hash for block id: {0:?}")]
			NoHashForBlockId(BlockId<B>),
			}

			/// Create a new [`sp_distance::InherentDataProvider`] at the given block.
			pub fn create_distance_inherent_data_provider<B, C, Backend>(
			client: &C,
			parent: B::Hash,
			distance_dir: PathBuf,
			owner_keys: &[sp_core::sr25519::Public],
			) -> sp_distance::InherentDataProvider<IdtyIndex>
			where
			B: BlockT,
			C: ProvideUncles<B> + StorageProvider<B, Backend>,
			Backend: sc_client_api::Backend<B>,
			IdtyIndex: Decode + Encode + PartialEq + TypeInfo,
			{
			// Retrieve the period_index from storage.
			let period_index = client
			.storage(
			parent,
			&StorageKey(
			frame_support::storage::storage_prefix(b"Distance", b"CurrentPeriodIndex").to_vec(),
			),
			)
			.ok()
			.flatten()
			.and_then(\|raw\| u32::decode(&mut &raw.0[..]).ok());

			// Return early if the storage is inaccessible or the data is corrupted.
			let period_index = match period_index {
			Some(index) => index,
			None => {
			log::error!("🧙 [distance inherent] PeriodIndex decoding failed.");
			return sp_distance::InherentDataProvider::<IdtyIndex>::new(None);
			}
			};

			// Retrieve the published_results from storage.
			let published_results = client
			.storage(
			parent,
			&StorageKey(
			frame_support::storage::storage_prefix(
			b"Distance",
			match period_index % 3 {
			0 => b"EvaluationPool0",
			1 => b"EvaluationPool1",
			2 => b"EvaluationPool2",
			_ => unreachable!("n<3"),
			},
			)
			.to_vec(),
			),
			)
			.ok()
			.flatten()
			.and_then(\|raw\| {
			pallet_distance::EvaluationPool::<AccountId32, IdtyIndex>::decode(&mut &raw.0[..]).ok()
			});

			// Return early if the storage is inaccessible or the data is corrupted.
			let published_results = match published_results {
			Some(published_results) => published_results,
			None => {
			log::info!("🧙 [distance inherent] No published result at this block.");
			return sp_distance::InherentDataProvider::<IdtyIndex>::new(None);
			}
			};

			// Find the account associated with the BABE key that is in our owner keys.
			let mut local_account = None;
			for key in owner_keys {
			// Session::KeyOwner is StorageMap<_, Twox64Concat, (KeyTypeId, Vec<u8>), AccountId32, OptionQuery>
			// Slices (variable length) and array (fixed length) are encoded differently, so the `.as_slice()` is needed
			let item_key = (sp_runtime::KeyTypeId(*b"babe"), key.0.as_slice()).encode();
			let mut storage_key =
			frame_support::storage::storage_prefix(b"Session", b"KeyOwner").to_vec();
			storage_key.extend_from_slice(&sp_core::twox_64(&item_key));
			storage_key.extend_from_slice(&item_key);

			if let Some(raw_data) = client
			.storage(parent, &StorageKey(storage_key))
			.ok()
			.flatten()
			{
			if let Ok(key_owner) = AccountId32::decode(&mut &raw_data.0[..]) {
			local_account = Some(key_owner);
			break;
			} else {
			log::warn!("🧙 [distance inherent] Cannot decode key owner value");
			}
			}
			}

			// Have we already published a result for this period?
			if let Some(local_account) = local_account {
			if published_results.evaluators.contains(&local_account) {
			log::debug!("🧙 [distance inherent] Already published a result for this period");
			return sp_distance::InherentDataProvider::<IdtyIndex>::new(None);
			}
			} else {
			log::error!("🧙 [distance inherent] Cannot find our BABE owner key");
			return sp_distance::InherentDataProvider::<IdtyIndex>::new(None);
			}

			// Read evaluation result from file, if it exists
			log::debug!(
			"🧙 [distance inherent] Reading evaluation result from file {:?}",
			distance_dir.clone().join(period_index.to_string())
			);
			let evaluation_result = match std::fs::read(
			distance_dir.join(VERSION_PREFIX.to_owned() + &period_index.to_string()),
			) {
			Ok(data) => data,
			Err(e) => {
			match e.kind() {
			std::io::ErrorKind::NotFound => {
			log::debug!("🧙 [distance inherent] Evaluation result file not found. Please ensure that the oracle version matches {}", VERSION_PREFIX);
			}
			_ => {
			log::error!(
			"🧙 [distance inherent] Cannot read distance evaluation result file: {e:?}"
			);
			}
			}
			return sp_distance::InherentDataProvider::<IdtyIndex>::new(None);
			}
			};

			log::info!("🧙 [distance inherent] Providing evaluation result");
			sp_distance::InherentDataProvider::<IdtyIndex>::new(Some(
			sp_distance::ComputationResult::decode(&mut evaluation_result.as_slice()).unwrap(),
			))
			}

distance-oracle/Cargo.toml

0 → 100644

+51 −0

Original line number	Original line	Diff line number	Diff line
			[package]
			name = "distance-oracle"
			version = "0.1.0"
			authors.workspace = true
			repository.workspace = true
			license.workspace = true
			edition.workspace = true

			[[bin]]
			name = "distance-oracle"
			required-features = ["standalone"]

			[features]
			default = ["gdev", "standalone", "std"]
			gdev = []
			gtest = []
			# Feature standalone is for CLI executable
			standalone = ["clap", "tokio"]
			# Feature std is needed
			std = [
			"codec/std",
			"fnv/std",
			"sp-core/std",
			"sp-distance/std",
			"sp-runtime/std",
			]
			try-runtime = ["sp-distance/try-runtime", "sp-runtime/try-runtime"]

			[dependencies]
			clap = { workspace = true, features = ["derive"], optional = true }
			codec = { workspace = true }
			fnv = { workspace = true }
			log = { workspace = true }
			rayon = { workspace = true }
			simple_logger = { workspace = true }
			sp-core = { workspace = true }
			sp-distance = { workspace = true }
			sp-runtime = { workspace = true }
			subxt = { workspace = true, features = [
			"native",
			"jsonrpsee",
			] }
			tokio = { workspace = true, features = [
			"rt-multi-thread",
			"macros",
			], optional = true }

			[dev-dependencies]
			bincode = { workspace = true }
			dubp-wot = { workspace = true }
			flate2 = { workspace = true, features = ["zlib-ng-compat"] }

distance-oracle/README.md

0 → 100644

+3 −0

Original line number	Original line	Diff line number	Diff line
			# Distance Oracle

			You can find the autogenerated documentation at: [https://doc-duniter-org.ipns.pagu.re/distance_oracle/index.html](https://doc-duniter-org.ipns.pagu.re/distance_oracle/index.html).

distance-oracle/src/api.rs

0 → 100644

+176 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2023 Axiom-Team
			//
			// This file is part of Duniter-v2S.
			//
			// Duniter-v2S is free software: you can redistribute it and/or modify
			// it under the terms of the GNU Affero General Public License as published by
			// the Free Software Foundation, version 3 of the License.
			//
			// Duniter-v2S is distributed in the hope that it will be useful,
			// but WITHOUT ANY WARRANTY; without even the implied warranty of
			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			// GNU Affero General Public License for more details.
			//
			// You should have received a copy of the GNU Affero General Public License
			// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.

			#![allow(clippy::type_complexity)]

			use crate::runtime;
			use log::debug;

			pub type Client = subxt::OnlineClient<crate::RuntimeConfig>;
			pub type AccountId = subxt::utils::AccountId32;
			pub type IdtyIndex = u32;
			pub type EvaluationPool =
			runtime::runtime_types::pallet_distance::types::EvaluationPool<AccountId, IdtyIndex>;
			pub type H256 = subxt::utils::H256;

			pub async fn client(rpc_url: impl AsRef<str>) -> Client {
			Client::from_insecure_url(rpc_url)
			.await
			.expect("Cannot create RPC client")
			}

			pub async fn parent_hash(client: &Client) -> H256 {
			client
			.blocks()
			.at_latest()
			.await
			.expect("Cannot fetch latest block hash")
			.hash()
			}

			pub async fn current_period_index(client: &Client, parent_hash: H256) -> u32 {
			client
			.storage()
			.at(parent_hash)
			.fetch(&runtime::storage().distance().current_period_index())
			.await
			.expect("Cannot fetch current pool index")
			.unwrap_or_default()
			}

			pub async fn current_pool(
			client: &Client,
			parent_hash: H256,
			current_pool_index: u32,
			) -> Option<EvaluationPool> {
			client
			.storage()
			.at(parent_hash)
			.fetch(&match current_pool_index {
			0 => {
			debug!("Looking at Pool1 for pool index {}", current_pool_index);
			runtime::storage().distance().evaluation_pool1()
			}
			1 => {
			debug!("Looking at Pool2 for pool index {}", current_pool_index);
			runtime::storage().distance().evaluation_pool2()
			}
			2 => {
			debug!("Looking at Pool0 for pool index {}", current_pool_index);
			runtime::storage().distance().evaluation_pool0()
			}
			_ => unreachable!("n<3"),
			})
			.await
			.expect("Cannot fetch current pool")
			}

			pub async fn evaluation_block(client: &Client, parent_hash: H256) -> H256 {
			client
			.storage()
			.at(parent_hash)
			.fetch(&runtime::storage().distance().evaluation_block())
			.await
			.expect("Cannot fetch evaluation block")
			.expect("No evaluation block")
			}

			pub async fn max_referee_distance(client: &Client) -> u32 {
			client
			.constants()
			.at(&runtime::constants().distance().max_referee_distance())
			.expect("Cannot fetch referee distance")
			}

			pub async fn member_iter(client: &Client, evaluation_block: H256) -> MemberIter {
			MemberIter(
			client
			.storage()
			.at(evaluation_block)
			.iter(runtime::storage().membership().membership_iter())
			.await
			.expect("Cannot fetch memberships"),
			)
			}

			pub struct MemberIter(
			subxt::backend::StreamOfResults<
			subxt::storage::StorageKeyValuePair<
			subxt::storage::StaticAddress<
			(),
			runtime::runtime_types::sp_membership::MembershipData<u32>,
			(),
			(),
			subxt::utils::Yes,
			>,
			>,
			>,
			);

			impl MemberIter {
			pub async fn next(&mut self) -> Result<Option<IdtyIndex>, subxt::error::Error> {
			self.0
			.next()
			.await
			.transpose()
			.map(\|i\| i.map(\|j\| idty_id_from_storage_key(&j.key_bytes)))
			}
			}

			pub async fn cert_iter(client: &Client, evaluation_block: H256) -> CertIter {
			CertIter(
			client
			.storage()
			.at(evaluation_block)
			.iter(runtime::storage().certification().certs_by_receiver_iter())
			.await
			.expect("Cannot fetch certifications"),
			)
			}

			pub struct CertIter(
			subxt::backend::StreamOfResults<
			subxt::storage::StorageKeyValuePair<
			subxt::storage::StaticAddress<
			(),
			Vec<(u32, u32)>,
			(),
			subxt::utils::Yes,
			subxt::utils::Yes,
			>,
			>,
			>,
			);

			impl CertIter {
			pub async fn next(
			&mut self,
			) -> Result<Option<(IdtyIndex, Vec<(IdtyIndex, u32)>)>, subxt::error::Error> {
			self.0
			.next()
			.await
			.transpose()
			.map(\|i\| i.map(\|j\| (idty_id_from_storage_key(&j.key_bytes), j.value)))
			}
			}

			fn idty_id_from_storage_key(storage_key: &[u8]) -> IdtyIndex {
			u32::from_le_bytes(
			storage_key[40..44]
			.try_into()
			.expect("Cannot convert StorageKey to IdtyIndex"),
			)
			}

distance-oracle/src/lib.rs

0 → 100644

+416 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2023 Axiom-Team
			//
			// This file is part of Duniter-v2S.
			//
			// Duniter-v2S is free software: you can redistribute it and/or modify
			// it under the terms of the GNU Affero General Public License as published by
			// the Free Software Foundation, version 3 of the License.
			//
			// Duniter-v2S is distributed in the hope that it will be useful,
			// but WITHOUT ANY WARRANTY; without even the implied warranty of
			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			// GNU Affero General Public License for more details.
			//
			// You should have received a copy of the GNU Affero General Public License
			// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.

			//! # Distance Oracle
			//!
			//! The Distance Oracle is a standalone program designed to calculate the distances between identities in the Duniter Web of Trust (WoT). This process is computationally intensive and is therefore decoupled from the main runtime. It allows smith users to choose whether to run the oracle and provide results to the network.
			//!
			//! The oracle works in conjunction with the Inherent Data Provider and the Distance Pallet in the runtime to deliver periodic computation results. The Inherent Data Provider fetches and supplies these results to the runtime, ensuring that the necessary data for distance evaluations is available to be processed at the appropriate time in the runtime lifecycle.
			//!
			//! ## Structure
			//!
			//! The Distance Oracle is organized into the following modules:
			//!
			//! 1. `/distance-oracle/`: Contains the main binary for executing the distance computation.
			//! 2. `/primitives/distance/`: Defines primitive types shared between the client and runtime.
			//! 3. `/client/distance/`: Exposes the `create_distance_inherent_data_provider`, which feeds data into the runtime through the Inherent Data Provider.
			//! 4. `/pallets/distance/`: A pallet that handles distance-related types, traits, storage, and hooks in the runtime, coordinating the interaction between the oracle, inherent data provider, and runtime.
			//!
			//! ## How it works
			//! - The Distance Pallet adds an evaluation request at period `i` in the runtime.
			//! - The Distance Oracle evaluates this request at period `i + 1`, computes the necessary results and stores them on disk.
			//! - The Inherent Data Provider reads this evaluation result from disk at period `i + 2` and provides it to the runtime to perform the required operations.
			//!
			//! ## Usage
			//!
			//! ### Docker Integration
			//!
			//! To run the Distance Oracle, use the provided Docker setup. Refer to the [docker-compose.yml](../docker-compose.yml) file for an example configuration.
			//!
			//! Example Output:
			//! ```text
			//! 2023-12-09T14:45:05.942Z INFO [distance_oracle] Nothing to do: Pool does not exist
			//! Waiting 1800 seconds before next execution...
			//! ```

			#[cfg(not(test))]
			pub mod api;
			#[cfg(test)]
			pub mod mock;
			#[cfg(test)]
			mod tests;

			#[cfg(test)]
			pub use mock as api;

			use api::{AccountId, EvaluationPool, IdtyIndex, H256};

			use codec::Encode;
			use fnv::{FnvHashMap, FnvHashSet};
			use log::{debug, info, warn};
			use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
			use std::{io::Write, path::PathBuf};

			/// The file version must match the version used by the inherent data provider.
			/// This ensures that the smith avoids accidentally submitting invalid data
			/// in case there are changes in logic between the runtime and the oracle,
			/// thereby preventing potential penalties.
			const VERSION_PREFIX: &str = "001-";

			#[cfg(feature = "gdev")]
			#[subxt::subxt(runtime_metadata_path = "../resources/metadata.scale")]
			pub mod runtime {}
			#[cfg(feature = "gtest")]
			#[subxt::subxt(runtime_metadata_path = "../resources/gtest_metadata.scale")]
			pub mod runtime {}

			pub enum RuntimeConfig {}
			impl subxt::config::Config for RuntimeConfig {
			type AccountId = AccountId;
			type Address = sp_runtime::MultiAddress<Self::AccountId, u32>;
			type AssetId = ();
			type ExtrinsicParams = subxt::config::substrate::SubstrateExtrinsicParams<Self>;
			type Hash = subxt::utils::H256;
			type Hasher = subxt::config::substrate::BlakeTwo256;
			type Header =
			subxt::config::substrate::SubstrateHeader<u32, subxt::config::substrate::BlakeTwo256>;
			type Signature = sp_runtime::MultiSignature;
			}

			/// Represents a tipping amount.
			#[derive(Copy, Clone, Debug, Default, Encode)]
			pub struct Tip {
			#[codec(compact)]
			tip: u64,
			}

			impl Tip {
			pub fn new(amount: u64) -> Self {
			Tip { tip: amount }
			}
			}

			impl From<u64> for Tip {
			fn from(n: u64) -> Self {
			Self::new(n)
			}
			}

			/// Represents configuration parameters.
			pub struct Settings {
			pub evaluation_result_dir: PathBuf,
			pub rpc_url: String,
			}

			impl Default for Settings {
			fn default() -> Self {
			Self {
			evaluation_result_dir: PathBuf::from("/tmp/duniter/chains/gdev/distance"),
			rpc_url: String::from("ws://127.0.0.1:9944"),
			}
			}
			}

			/// Runs the evaluation process, saves the results, and cleans up old files.
			///
			/// This function performs the following steps:
			/// 1. Runs the evaluation task by invoking `compute_distance_evaluation`, which provides:
			/// - The evaluation results.
			/// - The current period index.
			/// - The file path where the results should be stored.
			/// 2. Saves the evaluation results to a file in the specified directory.
			/// 3. Cleans up outdated evaluation files.
			pub async fn run(client: &api::Client, settings: &Settings) {
			let Some((evaluation, current_period_index, evaluation_result_path)) =
			compute_distance_evaluation(client, settings).await
			else {
			return;
			};

			debug!("Saving distance evaluation result to file `{evaluation_result_path:?}`");
			let mut evaluation_result_file = std::fs::OpenOptions::new()
			.write(true)
			.create_new(true)
			.open(&evaluation_result_path)
			.unwrap_or_else(\|e\| {
			panic!(
			"Cannot open distance evaluation result file `{evaluation_result_path:?}`: {e:?}"
			)
			});
			evaluation_result_file
			.write_all(
			&sp_distance::ComputationResult {
			distances: evaluation,
			}
			.encode(),
			)
			.unwrap_or_else(\|e\| {
			panic!(
			"Cannot write distance evaluation result to file `{evaluation_result_path:?}`: {e:?}"
			)
			});

			// When a new result is written, remove old results except for the current period used by the inherent logic and the next period that was just generated.
			settings
			.evaluation_result_dir
			.read_dir()
			.unwrap_or_else(\|e\| {
			panic!(
			"Cannot read distance evaluation result directory `{:?}`: {:?}",
			settings.evaluation_result_dir, e
			)
			})
			.flatten()
			.filter_map(\|entry\| {
			entry
			.file_name()
			.to_str()
			.and_then(\|name\| {
			name.split('-').last()?.parse::<u32>().ok().filter(\|&pool\| {
			pool != current_period_index && pool != current_period_index + 1
			})
			})
			.map(\|_\| entry.path())
			})
			.for_each(\|path\| {
			std::fs::remove_file(&path)
			.unwrap_or_else(\|e\| warn!("Cannot remove file `{:?}`: {:?}", path, e));
			});
			}

			/// Evaluates distance for the current period and prepares results for storage.
			///
			/// This function performs the following steps:
			/// 1. Prepares the evaluation context using `prepare_evaluation_context`. If the context is not
			/// ready (e.g., no pending evaluations, or results already exist), it returns `None`.
			/// 2. Evaluates distances for all identities in the evaluation pool.
			/// 3. Returns the evaluation results, the current period index, and the path to store the results.
			///
			pub async fn compute_distance_evaluation(
			client: &api::Client,
			settings: &Settings,
			) -> Option<(Vec<sp_runtime::Perbill>, u32, PathBuf)> {
			let (evaluation_block, current_period_index, evaluation_pool, evaluation_result_path) =
			prepare_evaluation_context(client, settings).await?;

			info!("Evaluating distance for period {}", current_period_index);

			let max_depth = api::max_referee_distance(client).await;

			// member idty -> issued certs
			let mut members = FnvHashMap::<IdtyIndex, u32>::default();

			let mut members_iter = api::member_iter(client, evaluation_block).await;
			while let Some(member_idty) = members_iter
			.next()
			.await
			.expect("Cannot fetch next members")
			{
			members.insert(member_idty, 0);
			}

			let min_certs_for_referee = (members.len() as f32).powf(1. / (max_depth as f32)).ceil() as u32;

			// idty -> received certs
			let mut received_certs = FnvHashMap::<IdtyIndex, Vec<IdtyIndex>>::default();

			let mut certs_iter = api::cert_iter(client, evaluation_block).await;
			while let Some((receiver, issuers)) = certs_iter
			.next()
			.await
			.expect("Cannot fetch next certification")
			{
			if (issuers.len() as u32) < min_certs_for_referee {
			// This member is not referee
			members.remove(&receiver);
			}
			for (issuer, _removable_on) in issuers.iter() {
			if let Some(issued_certs) = members.get_mut(issuer) {
			*issued_certs += 1;
			}
			}
			received_certs.insert(
			receiver,
			issuers
			.into_iter()
			.map(\|(issuer, _removable_on)\| issuer)
			.collect(),
			);
			}

			// Only retain referees
			members.retain(\|_idty, issued_certs\| *issued_certs >= min_certs_for_referee);
			let referees = members;

			let evaluation = evaluation_pool
			.evaluations
			.0
			.as_slice()
			.par_iter()
			.map(\|(idty, _)\| distance_rule(&received_certs, &referees, max_depth, *idty))
			.collect();

			Some((evaluation, current_period_index, evaluation_result_path))
			}

			/// Prepares the context for the next evaluation task.
			///
			/// This function performs the following steps:
			/// 1. Fetches the parent hash of the latest block from the API.
			/// 2. Determines the current period index.
			/// 3. Retrieves the evaluation pool for the current period.
			/// - If the pool does not exist or is empty, it returns `None`.
			/// 4. Checks if the evaluation result file for the next period already exists.
			/// - If it exists, the task has already been completed, so the function returns `None`.
			/// 5. Ensures the evaluation result directory is available, creating it if necessary.
			/// 6. Retrieves the block number of the evaluation.
			///
			async fn prepare_evaluation_context(
			client: &api::Client,
			settings: &Settings,
			) -> Option<(H256, u32, EvaluationPool, PathBuf)> {
			let parent_hash = api::parent_hash(client).await;

			let current_period_index = api::current_period_index(client, parent_hash).await;

			// Fetch the pending identities
			let Some(evaluation_pool) =
			api::current_pool(client, parent_hash, current_period_index % 3).await
			else {
			info!("Nothing to do: Pool does not exist");
			return None;
			};

			// Stop if nothing to evaluate
			if evaluation_pool.evaluations.0.is_empty() {
			info!("Nothing to do: Pool is empty");
			return None;
			}

			// The result is saved in a file named `current_period_index + 1`.
			// It will be picked up during the next period by the inherent.
			let evaluation_result_path = settings
			.evaluation_result_dir
			.join(VERSION_PREFIX.to_owned() + &(current_period_index + 1).to_string());

			// Stop if already evaluated
			if evaluation_result_path
			.try_exists()
			.expect("Result path unavailable")
			{
			info!("Nothing to do: File already exists");
			return None;
			}

			#[cfg(not(test))]
			std::fs::create_dir_all(&settings.evaluation_result_dir).unwrap_or_else(\|e\| {
			panic!(
			"Cannot create distance evaluation result directory `{0:?}`: {e:?}",
			settings.evaluation_result_dir
			);
			});

			Some((
			api::evaluation_block(client, parent_hash).await,
			current_period_index,
			evaluation_pool,
			evaluation_result_path,
			))
			}

			/// Recursively explores the certification graph to identify referees accessible within a given depth.
			fn distance_rule_recursive(
			received_certs: &FnvHashMap<IdtyIndex, Vec<IdtyIndex>>,
			referees: &FnvHashMap<IdtyIndex, u32>,
			idty: IdtyIndex,
			accessible_referees: &mut FnvHashSet<IdtyIndex>,
			known_idties: &mut FnvHashMap<IdtyIndex, u32>,
			depth: u32,
			) {
			// Do not re-explore identities that have already been explored at least as deeply
			match known_idties.entry(idty) {
			std::collections::hash_map::Entry::Occupied(mut entry) => {
			if *entry.get() >= depth {
			return;
			} else {
			*entry.get_mut() = depth;
			}
			}
			std::collections::hash_map::Entry::Vacant(entry) => {
			entry.insert(depth);
			}
			}

			// If referee, add it to the list
			if referees.contains_key(&idty) {
			accessible_referees.insert(idty);
			}

			// If reached the maximum distance, stop exploring
			if depth == 0 {
			return;
			}

			// Explore certifiers
			for &certifier in received_certs.get(&idty).unwrap_or(&vec![]).iter() {
			distance_rule_recursive(
			received_certs,
			referees,
			certifier,
			accessible_referees,
			known_idties,
			depth - 1,
			);
			}
			}

			/// Calculates the fraction of accessible referees to total referees for a given identity.
			fn distance_rule(
			received_certs: &FnvHashMap<IdtyIndex, Vec<IdtyIndex>>,
			referees: &FnvHashMap<IdtyIndex, u32>,
			depth: u32,
			idty: IdtyIndex,
			) -> sp_runtime::Perbill {
			debug!("Evaluating distance for idty {}", idty);
			let mut accessible_referees =
			FnvHashSet::<IdtyIndex>::with_capacity_and_hasher(referees.len(), Default::default());
			let mut known_idties =
			FnvHashMap::<IdtyIndex, u32>::with_capacity_and_hasher(referees.len(), Default::default());
			distance_rule_recursive(
			received_certs,
			referees,
			idty,
			&mut accessible_referees,
			&mut known_idties,
			depth,
			);
			let result = if referees.contains_key(&idty) {
			sp_runtime::Perbill::from_rational(
			accessible_referees.len() as u32 - 1,
			referees.len() as u32 - 1,
			)
			} else {
			sp_runtime::Perbill::from_rational(accessible_referees.len() as u32, referees.len() as u32)
			};
			info!(
			"Distance for idty {}: {}/{} = {}%",
			idty,
			accessible_referees.len(),
			referees.len(),
			result.deconstruct() as f32 / 1_000_000_000f32 * 100f32
			);
			result
			}

distance-oracle/src/main.rs

0 → 100644

+60 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2023-2024 Axiom-Team
			//
			// This file is part of Duniter-v2S.
			//
			// Duniter-v2S is free software: you can redistribute it and/or modify
			// it under the terms of the GNU Affero General Public License as published by
			// the Free Software Foundation, version 3 of the License.
			//
			// Duniter-v2S is distributed in the hope that it will be useful,
			// but WITHOUT ANY WARRANTY; without even the implied warranty of
			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			// GNU Affero General Public License for more details.
			//
			// You should have received a copy of the GNU Affero General Public License
			// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.

			use clap::Parser;

			#[derive(Debug, clap::Parser)]
			struct Cli {
			#[clap(short = 'd', long, default_value = "/tmp/duniter/chains/gdev/distance")]
			evaluation_result_dir: String,
			/// Number of seconds between two evaluations (oneshot if absent)
			#[clap(short = 'i', long)]
			interval: Option<u64>,
			/// Node used for fetching state
			#[clap(short = 'u', long, default_value = "ws://127.0.0.1:9944")]
			rpc_url: String,
			/// Log level (off, error, warn, info, debug, trace)
			#[clap(short = 'l', long, default_value = "info")]
			log: log::LevelFilter,
			}

			#[tokio::main]
			async fn main() {
			let cli = Cli::parse();

			simple_logger::SimpleLogger::new()
			.with_level(cli.log)
			.init()
			.unwrap();

			let client = distance_oracle::api::client(&cli.rpc_url).await;

			let settings = distance_oracle::Settings {
			evaluation_result_dir: cli.evaluation_result_dir.into(),
			rpc_url: cli.rpc_url,
			};

			if let Some(duration) = cli.interval {
			let mut interval = tokio::time::interval(std::time::Duration::from_secs(duration));
			interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
			loop {
			distance_oracle::run(&client, &settings).await;
			interval.tick().await;
			}
			} else {
			distance_oracle::run(&client, &settings).await;
			}
			}

distance-oracle/src/mock.rs

0 → 100644

+128 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2023 Axiom-Team
			//
			// This file is part of Duniter-v2S.
			//
			// Duniter-v2S is free software: you can redistribute it and/or modify
			// it under the terms of the GNU Affero General Public License as published by
			// the Free Software Foundation, version 3 of the License.
			//
			// Duniter-v2S is distributed in the hope that it will be useful,
			// but WITHOUT ANY WARRANTY; without even the implied warranty of
			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			// GNU Affero General Public License for more details.
			//
			// You should have received a copy of the GNU Affero General Public License
			// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.

			use crate::runtime::runtime_types::{
			pallet_distance::median::MedianAcc, sp_arithmetic::per_things::Perbill,
			};

			use dubp_wot::{data::rusty::RustyWebOfTrust, WebOfTrust, WotId};
			use std::collections::BTreeSet;

			pub struct Client {
			wot: RustyWebOfTrust,
			pub pool_len: usize,
			}
			pub type AccountId = sp_runtime::AccountId32;
			pub type IdtyIndex = u32;
			pub type H256 = subxt::utils::H256;

			pub struct EvaluationPool {
			pub evaluations: (Vec<(IdtyIndex, MedianAcc<Perbill>)>,),
			pub evaluators: BTreeSet<AccountId>,
			}

			pub async fn client(_rpc_url: impl AsRef<str>) -> Client {
			unimplemented!()
			}

			pub fn client_from_wot(wot: RustyWebOfTrust) -> Client {
			Client { wot, pool_len: 1 }
			}

			pub async fn parent_hash(_client: &Client) -> H256 {
			Default::default()
			}

			pub async fn current_period_index(_client: &Client, _parent_hash: H256) -> u32 {
			0
			}

			pub async fn current_pool(
			client: &Client,
			_parent_hash: H256,
			_current_session: u32,
			) -> Option<EvaluationPool> {
			Some(EvaluationPool {
			evaluations: (client
			.wot
			.get_enabled()
			.into_iter()
			.chain(client.wot.get_disabled().into_iter())
			.zip(0..client.pool_len)
			.map(\|(wot_id, _)\| {
			(wot_id.0 as IdtyIndex, unsafe {
			std::mem::transmute::<
			(std::vec::Vec<()>, std::option::Option<u32>, i32),
			MedianAcc<Perbill>,
			>((Vec::<()>::new(), Option::<u32>::None, 0))
			})
			})
			.collect(),),
			evaluators: BTreeSet::new(),
			})
			}

			pub async fn evaluation_block(_client: &Client, _parent_hash: H256) -> H256 {
			Default::default()
			}

			pub async fn max_referee_distance(_client: &Client) -> u32 {
			5
			}

			pub async fn member_iter(client: &Client, _evaluation_block: H256) -> MemberIter {
			MemberIter(client.wot.get_enabled().into_iter())
			}

			pub struct MemberIter(std::vec::IntoIter<WotId>);

			impl MemberIter {
			pub async fn next(&mut self) -> Result<Option<IdtyIndex>, subxt::error::Error> {
			Ok(self.0.next().map(\|wot_id\| wot_id.0 as u32))
			}
			}

			pub async fn cert_iter(client: &Client, _evaluation_block: H256) -> CertIter {
			CertIter(
			client
			.wot
			.get_enabled()
			.iter()
			.chain(client.wot.get_disabled().iter())
			.map(\|wot_id\| {
			(
			wot_id.0 as IdtyIndex,
			client
			.wot
			.get_links_source(*wot_id)
			.unwrap_or_default()
			.into_iter()
			.map(\|wot_id\| (wot_id.0 as IdtyIndex, 0))
			.collect::<Vec<(IdtyIndex, u32)>>(),
			)
			})
			.collect::<Vec<_>>()
			.into_iter(),
			)
			}

			pub struct CertIter(std::vec::IntoIter<(IdtyIndex, Vec<(IdtyIndex, u32)>)>);

			impl CertIter {
			pub async fn next(&mut self) -> Result<Option<(u32, Vec<(u32, u32)>)>, subxt::error::Error> {
			Ok(self.0.next())
			}
			}

distance-oracle/src/tests.rs

0 → 100644

+101 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright 2023 Axiom-Team
			//
			// This file is part of Duniter-v2S.
			//
			// Duniter-v2S is free software: you can redistribute it and/or modify
			// it under the terms of the GNU Affero General Public License as published by
			// the Free Software Foundation, version 3 of the License.
			//
			// Duniter-v2S is distributed in the hope that it will be useful,
			// but WITHOUT ANY WARRANTY; without even the implied warranty of
			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			// GNU Affero General Public License for more details.
			//
			// You should have received a copy of the GNU Affero General Public License
			// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.

			use dubp_wot::{
			data::rusty::RustyWebOfTrust, operations::distance::DistanceCalculator, WebOfTrust,
			};
			use flate2::read::ZlibDecoder;
			use sp_runtime::Perbill;
			use std::{fs::File, io::Read};

			#[tokio::test]
			#[ignore = "long to execute"]
			async fn test_distance_against_v1() {
			let wot = wot_from_v1_file();
			let n = wot.size();
			let min_certs_for_referee = (wot.get_enabled().len() as f32).powf(1. / 5.).ceil() as u32;

			// Reference implementation
			let ref_calculator = dubp_wot::operations::distance::RustyDistanceCalculator;
			let t_a = std::time::Instant::now();
			let ref_results: Vec<Perbill> = wot
			.get_enabled()
			.into_iter()
			.chain(wot.get_disabled().into_iter())
			.zip(0..n)
			.map(\|(i, _)\| {
			let result = ref_calculator
			.compute_distance(
			&wot,
			dubp_wot::operations::distance::WotDistanceParameters {
			node: i,
			sentry_requirement: min_certs_for_referee,
			step_max: 5,
			x_percent: 0.8,
			},
			)
			.unwrap();
			Perbill::from_rational(result.success, result.sentries)
			})
			.collect();
			println!("ref time: {}", t_a.elapsed().as_millis());

			// Our implementation
			let mut client = crate::api::client_from_wot(wot);
			client.pool_len = n;

			let t_a = std::time::Instant::now();
			let results = crate::compute_distance_evaluation(&client, &Default::default())
			.await
			.unwrap();
			println!("new time: {}", t_a.elapsed().as_millis());
			assert_eq!(results.0.len(), n);

			let mut errors: Vec<_> = results
			.0
			.iter()
			.zip(ref_results.iter())
			.map(\|(r, r_ref)\| r.deconstruct() as i64 - r_ref.deconstruct() as i64)
			.collect();
			errors.sort_unstable();
			println!(
			"Error: {:?} / {:?} / {:?} / {:?} / {:?} (min / 1Q / med / 3Q / max)",
			errors[0],
			errors[errors.len() / 4],
			errors[errors.len() / 2],
			errors[errors.len() * 3 / 4],
			errors[errors.len() - 1]
			);

			let correct_results = results
			.0
			.iter()
			.zip(ref_results.iter())
			.map(\|(r, r_ref)\| (r == r_ref) as usize)
			.sum::<usize>();
			println!("Correct results: {correct_results} / {n}");
			assert_eq!(correct_results, n);
			}

			fn wot_from_v1_file() -> RustyWebOfTrust {
			let file = File::open("wot.deflate").expect("Cannot open wot.deflate");
			let mut decompressor = ZlibDecoder::new(file);
			let mut decompressed_bytes = Vec::new();
			decompressor
			.read_to_end(&mut decompressed_bytes)
			.expect("Cannot decompress wot.deflate");
			bincode::deserialize::<RustyWebOfTrust>(&decompressed_bytes).expect("Cannot decode wot.deflate")
			}

distance-oracle/wot.deflate

0 → 100644

+225 KiB

File added.

No diff preview for this file type.

View file

docker-compose.yml

+16 −13

Original line number	Original line	Diff line number	Diff line
	version: "3.5"		# This is a minimal docker-compose.yml template for running a Duniter mirror node
			# For more detailed examples, look at docker/compose folder
	services:		services:
	duniter-v2s:		duniter-v2s-mirror:
	container_name: duniter-v2s		container_name: duniter-v2s-mirror
	image: duniter/duniter-v2s:v0.1.0		# the image tells which network you are connecting to
			# here it is gdev network
			image: duniter/duniter-v2s-gdev-800:latest
	ports:		ports:
	# telemetry		# prometheus telemetry to monitor resource use
	- 9615:9615		- 9615:9615
	# rpc		# RPC API (ws and http)
	- 9933:9933
	# rpc-ws
	- 9944:9944		- 9944:9944
	# p2p		# public p2p endpoint
	- 30333:30333		- 30333:30333
	environment:		environment:
	DUNITER_INSTANCE_NAME: "duniter_local"		# read https://duniter.org/wiki/duniter-v2/configure-docker/
	DUNITER_CHAIN_NAME: "dev"		# to configure these
	#DUNITER_DISABLE_PROMETHEUS: "false"		DUNITER_NODE_NAME: duniter_local
			DUNITER_CHAIN_NAME: gdev
			DUNITER_PUBLIC_ADDR: /dns/your.domain.name/tcp/30333
			DUNITER_LISTEN_ADDR: /ip4/0.0.0.0/tcp/30333
	volumes:		volumes:
	- duniter-local-data:/var/lib/duniter		- duniter-local-data:/var/lib/duniter

docker/Dockerfile

+74 −30

Original line number	Original line	Diff line number	Diff line
			# Workaround for https://github.com/containers/buildah/issues/4742
			FROM debian:bullseye-slim AS target

	# ------------------------------------------------------------------------------		# ------------------------------------------------------------------------------
	# Build Stage		# Build Stage
	# ------------------------------------------------------------------------------		# ------------------------------------------------------------------------------

	# Building for Debian buster because we need the binary to be compatible		# When building for a foreign arch, use cross-compilation
	# with the image paritytech/ci-linux:production (currently based on		# https://www.docker.com/blog/faster-multi-platform-builds-dockerfile-cross-compilation-guide/
	# debian:buster-slim) used by the gitlab CI		FROM --platform=$BUILDPLATFORM rust:1-bullseye AS build
	FROM rust:1-buster as build		ARG BUILDPLATFORM
			ARG TARGETPLATFORM

			# Debug
			RUN echo "BUILDPLATFORM = $BUILDPLATFORM"
			RUN echo "TARGETPLATFORM = $TARGETPLATFORM"

			# We need the target arch triplet in both Debian and rust flavor
			RUN echo "DEBIAN_ARCH_TRIPLET='$(dpkg-architecture -A${TARGETPLATFORM#linux/} -qDEB_TARGET_MULTIARCH)'" >>/root/dynenv
			RUN . /root/dynenv && \
			echo "RUST_ARCH_TRIPLET='$(echo "$DEBIAN_ARCH_TRIPLET" \| sed -E 's/-linux-/-unknown&/')'" >>/root/dynenv
			RUN cat /root/dynenv

	WORKDIR /root		WORKDIR /root

	# Copy source tree		# Copy source tree
	COPY . .		COPY . .

	RUN test -x build/duniter \|\| \		RUN apt-get update && \
	( \		DEBIAN_FRONTEND=noninteractive apt-get install -y clang cmake protobuf-compiler
	apt-get update && \
	DEBIAN_FRONTEND=noninteractive apt-get install -y clang \
	)

	# build duniter		# build duniter
	ARG threads=1		ARG debug=0
	RUN test -x build/duniter \|\| \		RUN if [ "$debug" = 0 ]; then \
	( \		echo "CARGO_OPTIONS=--release" >>/root/dynenv && \
	CARGO_PROFILE_RELEASE_LTO="true" \		echo "TARGET_FOLDER=release" >>/root/dynenv; \
	cargo build --release -j $threads && \		else \
	mkdir -p build && \		echo "TARGET_FOLDER=debug" >>/root/dynenv; \
	mv target/release/duniter build/ \		fi
	)

	# Create fake duniter-cucumber if is not exist		# Configure cross-build environment if need be
	# The goal is to avoid error later, this binary is optional		RUN set -x && \
	RUN test -x build/duniter-cucumber \|\| \		if [ "$TARGETPLATFORM" != "$BUILDPLATFORM" ]; then \
	( \		. /root/dynenv && \
			apt install -y gcc-$DEBIAN_ARCH_TRIPLET binutils-$DEBIAN_ARCH_TRIPLET && \
			rustup target add "$RUST_ARCH_TRIPLET" && \
			: https://github.com/rust-lang/cargo/issues/4133 && \
			echo "RUSTFLAGS='-C linker=$DEBIAN_ARCH_TRIPLET-gcc'; export RUSTFLAGS" >>/root/dynenv; \
			fi

			# Build
			ARG chain="gdev"
			RUN set -x && \
			cat /root/dynenv && \
			. /root/dynenv && \
			cargo build -Zgit=shallow-deps --locked $CARGO_OPTIONS --no-default-features $BENCH_OPTIONS --features $chain --target "$RUST_ARCH_TRIPLET" && \
			cargo build -Zgit=shallow-deps --locked $CARGO_OPTIONS --target "$RUST_ARCH_TRIPLET" --package distance-oracle && \
	mkdir -p build && \		mkdir -p build && \
	touch build/duniter-cucumber \		mv target/$RUST_ARCH_TRIPLET/$TARGET_FOLDER/duniter build/ && \
	)		mv target/$RUST_ARCH_TRIPLET/$TARGET_FOLDER/distance-oracle build/

			# Run tests if requested, except when cross-building
			ARG cucumber=0
			RUN if [ "$cucumber" != 0 ] && [ "$TARGETPLATFORM" = "$BUILDPLATFORM" ]; then \
			cargo ta && \
			cargo test -Zgit=shallow-deps --workspace --exclude duniter-end2end-tests --exclude duniter-live-tests --features=runtime-benchmarks,constant-fees \
			cd target/debug/deps/ && \
			rm cucumber_tests-*.d && \
			mv cucumber_tests* ../../../build/duniter-cucumber; \
			fi

	# ------------------------------------------------------------------------------		# ------------------------------------------------------------------------------
	# Final Stage		# Final Stage
	# ------------------------------------------------------------------------------		# ------------------------------------------------------------------------------

	FROM debian:buster-slim		FROM target

	LABEL maintainer="Gilles Filippini <gilles.filippini@pini.fr>"		LABEL maintainer="Gilles Filippini <gilles.filippini@pini.fr>"
	LABEL version="0.0.0"		LABEL version="0.0.0"
	LABEL description="Crypto-currency software (based on Substrate framework) to operate Ğ1 libre currency"		LABEL description="Crypto-currency software (based on Substrate framework) to operate Ğ1 libre currency"

			# Required certificates for RPC connections
			RUN apt-get update \
			&& apt-get install -y --no-install-recommends ca-certificates
			RUN update-ca-certificates
			RUN apt-get clean && rm -rf /var/lib/apt/lists/*

	RUN adduser --home /var/lib/duniter duniter		RUN adduser --home /var/lib/duniter duniter

	# Configuration		# Configuration
	# rpc, rpc-ws, p2p, telemetry		# rpc, p2p, telemetry
	EXPOSE 9933 9944 30333 9615		EXPOSE 9944 30333 9615
	VOLUME /var/lib/duniter		VOLUME /var/lib/duniter
	ENTRYPOINT ["docker-entrypoint"]		ENTRYPOINT ["docker-entrypoint"]
	USER duniter		USER duniter

	# Intall		# Intall
	COPY --from=build /root/build/duniter /usr/local/bin/duniter		COPY --from=build /root/build /usr/local/bin/
	COPY --from=build /root/build/duniter-cucumber /usr/local/bin/duniter-cucumber		COPY --from=build /root/dynenv /var/lib/duniter
	COPY docker/docker-entrypoint /usr/local/bin/		COPY docker/docker-entrypoint /usr/local/bin/
			COPY docker/docker-distance-entrypoint /usr/local/bin/

			# Debug
			RUN cat /var/lib/duniter/dynenv

docker/README.md

0 → 100644

+101 −0

Original line number	Original line	Diff line number	Diff line
			# duniter/duniter-v2s

			Duniter is the software that supports the [Ğ1 libre-currency blockchain](https://duniter.org/).

			[Duniter v2s](https://git.duniter.org/nodes/rust/duniter-v2s) is a complete rewrite of Duniter based on the Substrate / Polkadot framework. This is alpha state work in progress.

			## Minimal docker-compose file for an mirror node

			```
			version: "3.5"

			services:
			duniter-mirror:
			image: duniter/duniter-v2s-gdev:latest
			restart: unless-stopped
			ports:
			# Prometheus endpoint
			- 9615:9615
			# rpc
			- 9944:9944
			# p2p
			- 30333:30333
			volumes:
			- data-mirror:/var/lib/duniter/
			environment:
			- DUNITER_CHAIN_NAME=gdev
			- DUNITER_NODE_NAME=<my-node-name>

			volumes:
			data-mirror:
			```

			## Minimal docker-compose file for a validator node

			```
			version: "3.5"

			services:
			duniter-validator:
			image: duniter/duniter-v2s-gdev:latest
			restart: unless-stopped
			ports:
			# Prometheus endpoint
			- 9615:9615
			# p2p
			- 30333:30333
			volumes:
			- data-validator:/var/lib/duniter/
			environment:
			- DUNITER_CHAIN_NAME=gdev
			- DUNITER_VALIDATOR=true
			- DUNITER_NODE_NAME=<my-validator-node-name>

			volumes:
			data-validator:
			```

			## Environment variables

			\| Name \| Description \| Default \|
			\| ---------------------------- \| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- \| ------------------------------------------------------------------------------------------- \|
			\| `DUNITER_NODE_NAME` \| The node name. This name will appear on the Substrate telemetry server when telemetry is enabled. \| Random name \|
			\| `DUNITER_CHAIN_NAME` \| The currency to process. "gdev" uses the embeded chainspec. A path allows to use a local json raw chainspec. \| `dev` (development mode) \|
			\| `DUNITER_PUBLIC_ADDR` \| The libp2p public address base. See [libp2p documentation](https://docs.libp2p.io/concepts/fundamentals/addressing/). This variable is useful when the node is behind a reverse proxy with its ports not directly exposed.<br>Note: the `p2p/<peer_id>` part of the address shouldn't be set in this variable. It is automatically added by Duniter. \| duniter-v2s guesses one from the node's IPv4 address. \|
			\| `DUNITER_LISTEN_ADDR` \| The libp2p listen address. See [libp2p documentation](https://docs.libp2p.io/concepts/fundamentals/addressing/). This variable is useful when running a validator node behind a reverse proxy, to force the P2P end point in websocket mode with:<br> `DUNITER_LISTEN_ADDR=/ip4/0.0.0.0/tcp/30333/ws` \| Non validator node: `/ip4/0.0.0.0/tcp/30333/ws`<br>Validator node: `/ip4/0.0.0.0/tcp/30333` \|
			\| `DUNITER_RPC_CORS` \| Value of the polkadot `--rpc-cors` option. \| `all` \|
			\| `DUNITER_VALIDATOR` \| Boolean (`true` / `false`) to run the node in validator mode. Configure the polkadot options `--validator --rpc-methods Unsafe`. \| `false` \|
			\| `DUNITER_DISABLE_PROMETHEUS` \| Boolean to disable the Prometheus endpoint on port 9615. \| `false` \|
			\| `DUNITER_DISABLE_TELEMETRY` \| Boolean to disable connecting to the Substrate telemetry server. \| `false` \|
			\| `DUNITER_PRUNING_PROFILE` \| _ `default`<br> _ `archive`: keep all blocks and state blocks<br> \* `light`: keep only last 256 state blocks and last 14400 blocks (one day duration) \| `default` \|
			\| `DUNITER_PUBLIC_RPC` \| The public RPC endpoint to gossip on the network and make available in the apps. \| None \|
			\| `DUNITER_PUBLIC_SQUID` \| The public Squid graphql endpoint to gossip on the network and make available in the apps. \| None \|
			\| `DUNITER_PUBLIC_ENDPOINTS` \| Path to a JSON file containing public endpoints to gossip on the network. The file should use the following format:<br>```{"endpoints": [ { "protocol": "rpc", "address": "wss://gdev.example.com" }, { "protocol": "squid", "address": "gdev.example.com/graphql/v1" }]}``` \| None \|

			## Other Duniter options

			You can pass any other option to Duniter using the `command` docker-compose element:

			```
			command:
			# workaround for substrate issue #12073
			# https://github.com/paritytech/substrate/issues/12073
			- "--wasm-execution=interpreted-i-know-what-i-do"
			```

			## Start Duniter

			Once you are happy with your `docker-compose.yml` file, run in the same folder:

			```bash
			docker compose up -d
			```

			## Running duniter subcommands or custom set of options

			To run duniter from the command line without the default configuration detailed in the "Environment variables" section use `--` as the first argument. For example:

			```
			$ docker run --rm duniter/duniter-v2s-gdev:latest -- key generate
			$ docker run --rm duniter/duniter-v2s-gdev:latest -- --chain gdev ...
			```

docker/build-deb.Dockerfile

0 → 100644

+37 −0

Original line number	Original line	Diff line number	Diff line
			FROM paritytech/ci-linux:production

			# Set the working directory
			WORKDIR /app/

			# Copy the toolchain
			COPY rust-toolchain.toml ./

			# Install toolchain, substrate and cargo-deb with cargo cache
			RUN --mount=type=cache,target=/root/.cargo \
			cargo install cargo-deb

			# Create a dummy project to cache dependencies
			COPY Cargo.toml .
			COPY rust-toolchain.toml ./
			RUN --mount=type=cache,target=/app/target \
			--mount=type=cache,target=/root/.cargo/registry \
			mkdir src && \
			sed -i '/git = \\|version = /!d' Cargo.toml && \
			sed -i 's/false/true/' Cargo.toml && \
			sed -i '1s/^/\[package\]\nname\=\"Dummy\"\n\[dependencies\]\n/' Cargo.toml && \
			echo "fn main() {}" > src/main.rs && \
			cargo build -Zgit=shallow-deps --release && \
			rm -rf src Cargo.lock Cargo.toml

			# Copy the entire project
			COPY . .

			# Build the project and create Debian packages
			RUN --mount=type=cache,target=/app/target \
			--mount=type=cache,target=/root/.cargo/registry \
			cargo build -Zgit=shallow-deps --release && \
			cargo deb --no-build -p duniter && \
			cp -r ./target/debian/ ./

			# Clean up unnecessary files to reduce image size
			RUN rm -rf /app/target/release /root/.cargo/registry

docker/compose/docker-compose.smith.yml

0 → 100644

+37 −0

Original line number	Original line	Diff line number	Diff line
			# docker-compose.yml template for running a Duniter smith node
			# for more doc, see https://duniter.org/wiki/duniter-v2/
			services:
			# duniter smith node
			duniter-v2s-smith:
			container_name: duniter-v2s-smith
			image: duniter/duniter-v2s-gdev-800:latest
			ports:
			# RPC API of a smith node should not be exposed publicly!
			- 127.0.0.1:9944:9944
			# public p2p endpoint
			- 30333:30333
			environment:
			DUNITER_NODE_NAME: duniter_smith
			DUNITER_CHAIN_NAME: gdev
			DUNITER_VALIDATOR: true
			DUNITER_PRUNING_PROFILE: light
			DUNITER_PUBLIC_ADDR: /dns/your.domain.name/tcp/30333
			DUNITER_LISTEN_ADDR: /ip4/0.0.0.0/tcp/30333
			volumes:
			- duniter-smith-data:/var/lib/duniter
			# distance oracle
			distance-oracle:
			container_name: distance-oracle
			# choose the version of the image here
			image: duniter/duniter-v2s-gdev:latest
			entrypoint: docker-distance-entrypoint
			environment:
			ORACLE_RPC_URL: ws://duniter-v2s-smith:9944
			ORACLE_RESULT_DIR: /var/lib/duniter/chains/gdev/distance/
			ORACLE_EXECUTION_INTERVAL: 1800
			ORACLE_LOG_LEVEL: info
			volumes:
			- duniter-smith-data:/var/lib/duniter

			volumes:
			duniter-smith-data:

docker/compose/gdev-mirror.docker-compose.yml

deleted100644 → 0

+0 −36

Original line number	Original line	Diff line number	Diff line
	version: "3.4"

	services:
	duniter-rpc:
	image: duniter/duniter-v2s:v0.1.0
	restart: unless-stopped
	ports:
	# telemetry
	- 127.0.0.1:9615:9615
	# rpc
	- 127.0.0.1:9933:9933
	# rpc-ws
	- 127.0.0.1:9944:9944
	# p2p
	- 30333:30333
	volumes:
	- ./node.key:/etc/duniter/node.key
	- duniter-rpc-data:/var/lib/duniter/
	environment:
	- DUNITER_CHAIN_NAME=gdev
	command:
	- "--execution"
	- "Wasm"
	- "--node-key-file"
	- "/var/lib/duniter/node.key"
	- "--public-addr"
	# SERVER_DOMAIN should be replaced by a domain name that point on your server
	#
	# The PEER_ID should be replaced by the output of this command:
	# docker run --rm -it --entrypoint duniter -v $PWD:/var/lib/duniter/ duniter/duniter-v2s:v0.1.0 key generate-node-key --file /var/lib/duniter/node.key
	- "/dns/${SERVER_DOMAIN?SERVER_DOMAIN should be set}/tcp/30333/p2p/${PEER_ID?PEER_ID should be set}"
	- "--rpc-cors"
	- "all"

	volumes:
	duniter-rpc-data:

docker/compose/gdev-validator.docker-compose.yml

deleted100644 → 0

+0 −60

Original line number	Original line	Diff line number	Diff line
	version: "3.4"

	services:
	duniter-rpc:
	image: duniter/duniter-v2s:v0.1.0
	restart: unless-stopped
	ports:
	# telemetry
	- 127.0.0.1:9615:9615
	# rpc
	- 127.0.0.1:9933:9933
	# rpc-ws
	- 127.0.0.1:9944:9944
	# p2p
	- 30333:30333
	volumes:
	- ./node.key:/etc/duniter/validator-node.key
	- duniter-rpc-data:/var/lib/duniter/
	environment:
	- DUNITER_CHAIN_NAME=gdev
	command:
	- "--execution=Wasm"
	- "--node-key-file=/var/lib/duniter/node.key"
	- "--public-addr"
	# SERVER_DOMAIN should be replaced by a domain name that point on your server
	#
	# The PEER_ID should be replaced by the output of this command:
	# docker run --rm -it --entrypoint -v $PWD/duniter-rpc/:/var/lib/duniter/ duniter duniter/duniter-v2s:v0.1.0 key generate-node-key --file /var/lib/duniter/node-key.txt
	- "/dns/${SERVER_DOMAIN?SERVER_DOMAIN should be set}/tcp/30333/p2p/${PEER_ID?PEER_ID should be set}"
	- "--rpc-cors=all"

	duniter-validator:
	image: duniter/duniter-v2s:v0.1.0
	restart: unless-stopped
	ports:
	# telemetry
	- 127.0.0.1:9616:9615
	# rpc
	- 127.0.0.1:9934:9933
	# rpc-ws
	- 127.0.0.1:9945:9944
	# p2p
	- 30334:30333
	volumes:
	- ./node.key:/etc/duniter/validator-node.key
	- duniter-validator-data:/var/lib/duniter/
	environment:
	- DUNITER_CHAIN_NAME=gdev
	command:
	- "--execution=Wasm"
	- "--node-key-file=/var/lib/duniter/node.key"
	- "--public-addr"
	# SERVER_DOMAIN should be replaced by a domain name that point on your server
	#
	# The PEER_ID should be replaced by the output of this command:
	# docker run --rm -it --entrypoint -v $PWD/duniter-rpc/:/var/lib/duniter/ duniter duniter/duniter-v2s:v0.1.0 key generate-node-key --file /var/lib/duniter/node-key.txt
	- "/dns/${SERVER_DOMAIN?SERVER_DOMAIN should be set}/tcp/30333/p2p/${VALIDATOR_PEER_ID?VALIDATOR_PEER_ID should be set}"
	- "--rpc-cors=all"
	- "--rpc-methods=Unsafe"
	- "--validator"

docker/compose/live-template.docker-compose.yml

deleted100644 → 0

+0 −40

Original line number	Original line	Diff line number	Diff line
	version: "3.4"

	services:
	duniter-rpc:
	image: duniter/duniter-v2s:DUNITER_IMAGE_TAG
	restart: unless-stopped
	ports:
	- "9944:9944"
	- "30333:30333"
	volumes:
	- ./duniter-rpc/:/var/lib/duniter/
	environment:
	- DUNITER_CHAIN_NAME=/var/lib/duniter/CURRENCY-raw.json
	command:
	- "--bootnodes"
	- "/dns/duniter-validator/tcp/30333/p2p/VALIDATOR_NODE_KEY"
	- "--node-key-file"
	- "/var/lib/duniter/node-key"
	- "--rpc-cors"
	- "all"

	duniter-validator:
	image: duniter/duniter-v2s:DUNITER_IMAGE_TAG
	restart: unless-stopped
	ports:
	- "127.0.0.1:9945:9944"
	- "30334:30333"
	volumes:
	- ./duniter-validator/:/var/lib/duniter/
	environment:
	- DUNITER_CHAIN_NAME=/var/lib/duniter/CURRENCY-raw.json
	command:
	- "--bootnodes"
	- "/dns/duniter-rpc/tcp/30333/p2p/RPC_NODE_KEY"
	- "--node-key-file"
	- "/var/lib/duniter/node-key"
	- "--rpc-methods=Unsafe"
	- "--validator"
	- "--rpc-cors"
	- "all"

docker/cross-arm.Dockerfile

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -15,12 +15,12 @@ RUN dpkg --add-architecture armhf && \
	libssl-dev:armhf		libssl-dev:armhf

	# Install nightly with armv7 and w32-u-u		# Install nightly with armv7 and w32-u-u
	RUN rustup install nightly-2021-11-12-x86_64-unknown-linux-gnu && \		RUN rustup install nightly-2022-04-20-x86_64-unknown-linux-gnu && \
	rustup target add armv7-unknown-linux-gnueabihf --toolchain \		rustup target add armv7-unknown-linux-gnueabihf --toolchain \
	nightly-2021-11-12-x86_64-unknown-linux-gnu && \		nightly-2022-04-20-x86_64-unknown-linux-gnu && \
	rustup target add wasm32-unknown-unknown --toolchain \		rustup target add wasm32-unknown-unknown --toolchain \
	nightly-2021-11-12-x86_64-unknown-linux-gnu && \		nightly-2022-04-20-x86_64-unknown-linux-gnu && \
	cargo +nightly-2021-11-12-x86_64-unknown-linux-gnu install --git \		cargo +nightly-2022-04-20-x86_64-unknown-linux-gnu install --git \
	https://github.com/alexcrichton/wasm-gc --force		https://github.com/alexcrichton/wasm-gc --force

	ENV CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER arm-linux-gnueabihf-gcc		ENV CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER arm-linux-gnueabihf-gcc

docker/docker-distance-entrypoint

0 → 100755

+20 −0

Original line number	Original line	Diff line number	Diff line
			#!/bin/bash

			# Custom startup if a first argument is present and is equal to '--'
			# then we just run duniter with the provided arguments (but the '--')
			# without applying all the automated configuration below
			if [ "$1" = -- ]; then
			shift
			distance-oracle "$@"
			else
			ORACLE_RESULT_DIR="${ORACLE_RESULT_DIR:-/distance}"
			ORACLE_EXECUTION_INTERVAL="${ORACLE_EXECUTION_INTERVAL:-1800}"
			ORACLE_RPC_URL="${ORACLE_RPC_URL:-ws://127.0.0.1:9944}"
			ORACLE_LOG_LEVEL="${ORACLE_LOG_LEVEL:-info}"

			while [ true ]; do
			distance-oracle --evaluation-result-dir "$ORACLE_RESULT_DIR" --rpc-url "$ORACLE_RPC_URL" --log "$ORACLE_LOG_LEVEL"
			echo "Waiting $ORACLE_EXECUTION_INTERVAL seconds before next execution..."
			sleep $ORACLE_EXECUTION_INTERVAL
			done
			fi

docker/docker-entrypoint

+96 −8

Original line number	Original line	Diff line number	Diff line
	#!/bin/bash		#!/bin/bash

			# Custom startup if a first argument is present and is equal to '--'
			# then we just run duniter with the provided arguments (but the '--')
			# without applying all the automated configuration below
			if [ "$1" = -- ]; then
			shift
			exec duniter "$@"
			fi

			# Normal startup
	function boolean () {		function boolean () {
	echo "$1" \| sed -E 's/^(true\|yes\|1)$/true/i'		echo "$1" \| sed -E 's/^(true\|yes\|1)$/true/i'
	}		}
	@@ -12,12 +21,8 @@ function ternary () {
	fi		fi
	}		}

	if [ -n "$DUNITER_INSTANCE_NAME" ]; then		# Define chain name at the beginning
	set -- "$@" --name "$DUNITER_INSTANCE_NAME"		# with #274 we could have default given in network branch
	fi

	DUNITER_DISABLE_PROMETHEUS=$(boolean "${DUNITER_DISABLE_PROMETHEUS:-false}")

	DUNITER_CHAIN_NAME="${DUNITER_CHAIN_NAME:-dev}"		DUNITER_CHAIN_NAME="${DUNITER_CHAIN_NAME:-dev}"
	case "$DUNITER_CHAIN_NAME" in		case "$DUNITER_CHAIN_NAME" in
	dev)		dev)
	@@ -28,10 +33,93 @@ case "$DUNITER_CHAIN_NAME" in
	;;		;;
	esac		esac

			# Node name will appear on network
			DUNITER_NODE_NAME="${DUNITER_NODE_NAME:-$DUNITER_INSTANCE_NAME}"
			if [ -n "$DUNITER_NODE_NAME" ]; then
			set -- "$@" --name "$DUNITER_NODE_NAME"
			fi

			# Path of key file. Should be generated below if not present before starting Duniter
			_DUNITER_KEY_FILE=/var/lib/duniter/node.key
			set -- "$@" --node-key-file "$_DUNITER_KEY_FILE"

			# Generate node.key if not existing (chain name is required)
			if [ ! -f "$_DUNITER_KEY_FILE" ]; then
			echo "Generating node key file '$_DUNITER_KEY_FILE'..."
			duniter key generate-node-key --file "$_DUNITER_KEY_FILE" "${chain[@]}"
			else
			echo "Node key file '$_DUNITER_KEY_FILE' exists."
			fi
			# Log peer ID
			_DUNITER_PEER_ID="$(duniter key inspect-node-key --file "$_DUNITER_KEY_FILE")"
			echo "Node peer ID is '$_DUNITER_PEER_ID'."

			# Define public address (with dns, correct port and protocol for instance)
			if [ -n "$DUNITER_PUBLIC_ADDR" ]; then
			set -- "$@" --public-addr "$DUNITER_PUBLIC_ADDR"
			fi

			# Define public RPC endpoint (gossiped on the network)
			if [ -n "$DUNITER_PUBLIC_RPC" ]; then
			set -- "$@" --public-rpc "$DUNITER_PUBLIC_RPC"
			fi

			# Define public Squid endpoint (gossiped on the network)
			if [ -n "$DUNITER_PUBLIC_SQUID" ]; then
			set -- "$@" --public-squid "$DUNITER_PUBLIC_SQUID"
			fi

			# Define public endpoints from JSON file (gossiped on the network)
			if [ -n "$DUNITER_PUBLIC_ENDPOINTS" ]; then
			set -- "$@" --public-endpoints "$DUNITER_PUBLIC_ENDPOINTS"
			fi

			# Define listen address (inside docker)
			if [ -n "$DUNITER_LISTEN_ADDR" ]; then
			set -- "$@" --listen-addr "$DUNITER_LISTEN_ADDR"
			fi

			DUNITER_RPC_CORS="${DUNITER_RPC_CORS:-all}"
			set -- "$@" --rpc-cors "$DUNITER_RPC_CORS"

			# In case of validator, unsafe rpc methods are needed (like rotate_key) and should not be exposed publicly
			DUNITER_VALIDATOR=$(boolean "${DUNITER_VALIDATOR:-false}")
			if [ "$DUNITER_VALIDATOR" = true ]; then
			set -- "$@" --rpc-methods Unsafe --validator
			fi

			DUNITER_DISABLE_PROMETHEUS=$(boolean "${DUNITER_DISABLE_PROMETHEUS:-false}")
			if [ "$DUNITER_DISABLE_PROMETHEUS" = true ]; then
			set -- "$@" --no-prometheus
			fi

			DUNITER_DISABLE_TELEMETRY=$(boolean "${DUNITER_DISABLE_TELEMETRY:-false}")
			if [ "$DUNITER_DISABLE_TELEMETRY" = true ]; then
			set -- "$@" --no-telemetry
			fi

			# Set pruning profile
			DUNITER_PRUNING_PROFILE="${DUNITER_PRUNING_PROFILE:-default}"
			case "$DUNITER_PRUNING_PROFILE" in
			default)
			;;
			archive)
			set -- "$@" --state-pruning archive --blocks-pruning archive
			;;
			light)
			set -- "$@" --blocks-pruning 14400
			;;
			*)
			echo "ERROR: ignoring unknown DUNITER_PRUNING_PROFILE value '$DUNITER_PRUNING_PROFILE'" >&2
			;;
			esac

			# Set main command
			# Since we are inside docker, we can bind to all interfaces.
			# User will bind port to host interface or set reverse proxy when needed.
	set -- "$@" \		set -- "$@" \
	"${chain[@]}" \		"${chain[@]}" \
	$(ternary "$DUNITER_DISABLE_PROMETHEUS" --no-prometheus) \		-d /var/lib/duniter --unsafe-rpc-external
	-d /var/lib/duniter --unsafe-rpc-external --unsafe-ws-external

	echo "Starting duniter with parameters:" "$@"		echo "Starting duniter with parameters:" "$@"
	exec duniter "$@"		exec duniter "$@"

docs/api/manual.md

+34 −9

Original line number	Original line	Diff line number	Diff line
	# Manual for wallet developers		# Manual for wallet developers

	This functionnal documentation presents how wallets can interact with the blockchain.		This functional documentation presents how wallets can interact with the blockchain.
	It is intended to complete the [runtime calls documentation](./runtime-calls.md) in a runtime-specific way to fit the real needs of wallet developers.		It is intended to complete the [runtime calls documentation](./runtime-calls.md) in a runtime-specific way to fit the real needs of wallet developers.

	Only ĞDev is covered for now.		NOTE : a more detailed doc is available at <https://duniter.org/wiki/duniter-v2/doc/>

	## Notations		## Notations

	@@ -11,27 +11,52 @@ Only ĞDev is covered for now.

	## Account existence		## Account existence

	An account exists if and only if it contains at least the existential deposit (2 ĞD).		An account exists if and only if it contains at least the existential deposit (`balances.existentialDeposit` = 1 ĞD).

	## Become member		## Become member

	Only use `identity` pallet. The `membership` calls are disabled.		Only use `identity` pallet.

	1. The account that wants to gain membership needs to exists.		1. The account that wants to gain membership needs to exists.
	1. Any account that already has membership and respects the identity creation period can create an identity for another account, using `identity.createIdentity`.		1. Any account that already has membership and respects the identity creation period can create an identity for another account, using `identity.createIdentity`.
	1. The account has to confirm its identity with a name, using `identity.confirmIdentity`. The name must be ASCII alphanumeric, punctuation or space characters: `` /^[-!"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~a-zA-Z0-9 ]{3,64}$/ `` (additionally, trailing spaces and double spaces are forbidden, as a phishing countermeasure). If the name is already used, the call will fail.		1. The account has to confirm its identity with a name, using `identity.confirmIdentity`. The name must be ASCII alphanumeric, punctuation or space characters: `` /^[-!"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~a-zA-Z0-9 ]{3,64}$/ `` (additionally, trailing spaces and double spaces are forbidden, as a phishing countermeasure). If the name is already used, the call will fail.
			1. 4 different member accounts must certify the account using `cert.addCert`.
			1. The distance evaluation must be requested for the pending identity using `distance.requestDistanceEvaluation`.
			1. 3 distance sessions later, if the distance rule is respected, identity is validated automatically.

			## Change key

			A member can request a key change via the `identity.change_onwner_key` call. It needs the following SCALE encoded (see SCALE encoding section below) payload:

			- The new owner key payload prefix (rust definition: `b"icok"`)
			- the genesis block hash. (rust type `[u8; 32]` (`H256`))
			- The identity index (rust type `u64`)
			- The old key (rust type `u64`)

			This payload must be signed with the new key.

	## Revoke an identity		## Revoke an identity

	Revoking an identity makes it lose its membership, hence UD creation and governance rights. Orher data such as balance will remain.		Revoking an identity makes it lose its membership, hence UD creation and governance rights. Other data such as balance will remain.

	This feature is useful in case the user has lost their private key.		This feature is useful in case the user has lost their private key since the revocation document can be made in advance.

	### Generate the revocation payload		### Generate the revocation payload

	1. Scale-encode the revocation payload, that is the concatenation of the 32-bits public key and the genesis block hash.		The revocation needs this SCALE encoded (see SCALE encoding section below) payload:
	2. Store this payload and its signature.
			- The revocation payload prefix (rust definition: `b"revo"`)
			- The identity index (rust type `u64`)
			- the genesis block hash. (rust type `[u8; 32]` (`H256`))

			This payload must be signed with the corresponding revocation key.

	### Effectively revoke the identity		### Effectively revoke the identity

	1. From any origin that can pay the fee, use `identity.revokeIdentity` with the revocation payload.		1. From any origin that can pay the fee, use `identity.revokeIdentity` with the revocation payload.

			## SCALE encoding

			SCALE codec documentation: https://docs.substrate.io/reference/scale-codec/.

			At the end of this documentation you'll find links to SCALE codec implementation for other languages.

docs/api/runtime-calls.md

+749 −1271

File changed.

Preview size limit exceeded, changes collapsed.

docs/api/runtime-constants.md

0 → 100644

+1280 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/api/runtime-errors.md

0 → 100644

+1497 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/api/runtime-errors.po

0 → 100644

+391 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/api/runtime-events.md

0 → 100644

+1959 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/api/runtime-storages.md

0 → 100644

+2359 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/dev/beginner-walkthrough.md

0 → 100644

+87 −0

Original line number	Original line	Diff line number	Diff line
			# Beginner walkthrough

			This is a beginner tutorial for those who do not have a previous experience with Rust ecosystem or need guidance to get familiar with Duniter v2s project. You'll need a development machine with an internet connection, at least 20 GB of free storage, and an hour or two depending on your computing power.

			This walkthrough is based on the following video (french), don't hesitate to record an english voiceover if you feel so.

			[![preview](https://tube.p2p.legal/lazy-static/previews/654006dc-66c0-4e37-a32f-b7b5a1c13213.jpg)](https://tube.p2p.legal/w/n4TXxQ4SqxzpHPY4TNMXFu)

			> video walkthrough on peertube https://tube.p2p.legal/w/n4TXxQ4SqxzpHPY4TNMXFu

			## Requirements

			If you are on a debian based system, you can install the required packages with:

			```bash
			sudo apt install cmake pkg-config libssl-dev git build-essential clang libclang-dev curl protobuf-compiler
			```

			Else, look at the corresponding section in the [system setup documentation](./setup.md).

			Rust recommended installation method is through the rustup script that you can run with:

			```bash
			curl https://sh.rustup.rs -sSf \| sh
			```

			If you reopen your terminal, it will give you access to the `rustup`, `rustc` and `cargo` commands. You can then install the required Rust toolchains with:

			```bash
			rustup default stable
			rustup update nightly
			rustup update stable
			rustup target add wasm32-unknown-unknown --toolchain nightly
			```

			This can take about 2 minutes.

			## Build project

			After cloning wherever you want the `duniter-v2s` repo with:

			```bash
			git clone https://git.duniter.org/nodes/rust/duniter-v2s.git
			```

			you can go to the root folder and build the substrate client and default runtime with:

			```bash
			cargo build
			```

			This will take about 2 minutes to download dependencies plus between 5 and 15 minutes to build in debug mode depending on the power of your processor. At this point, you built the substrate client (a kind of "shell" in which lies the runtime) and the default runtime itself. You can run a local blockchain with:

			```bash
			cargo run -- --dev --tmp # here, --dev means --chain=dev which selects the gdev runtime
			```

			When you see the logs, the blockchain is running and you can connect to it with polkadotjs app: [https://polkadot.js.org/apps/?rpc=ws://127.0.0.1:9944](https://polkadot.js.org/apps/?rpc=ws%3A%2F%2F127.0.0.1%3A9944). You should see blocks being added every 6 seconds. You can use Alice, Bob, etc test accounts to submit extrinsics.

			## Autocompletion

			When using Duniter commands, you will benefit a lot from commands autocompletion. This can be achieved by following [autocompletion documentation](../user/autocompletion.md) for you shell. If you use bash the commands are:

			```bash
			# create local dir to store completion script
			mkdir -p ~/.local/share/duniter
			# export the bash completion file
			cargo run -- completion --generator bash > ~/.local/share/duniter/completion.bash
			# add the following line to your ~/.bashrc to automatically load completion on startup
			[[ -f $HOME/.local/share/duniter/completion.bash ]] && source $HOME/.local/share/duniter/completion.bash
			```

			You will then benefit from completion using `<Tab>` key and `*`.

			## End-to-end tests using cucumber

			Cucumber end2end tests are a good way to dive in Duniter's business procedure. They work by spawning a local blockchain and submitting extrinsics to it. You can build and run the cucumber tests by running:

			```bash
			cargo cucumber
			```

			which should take about 4 minutes to build and run the tests. A highly detailed documentation about the end2end tests is available [in the dedicated folder](../../end2end-tests/README.md), you will learn how to read and modify the tests.

			## Get in touch with us

			Wether you are stuck and need help or have sucessfully completed this tutorial, don't hesitate to get in touch with us on the Duniter forum! If you found this walkthrough useful, please 🙏 let us know on the [walkthrough topic](https://forum.duniter.org/t/contribuer-a-duniter-tutoriel-video/9770) on the forum 😊.
			No newline at end of file

docs/dev/compilation.md

0 → 100644

+26 −0

Original line number	Original line	Diff line number	Diff line
			# Compilation

			Duniter is compiled using the Rust compiler. For a general overview, refer to the [Rustc Dev Guide](https://rustc-dev-guide.rust-lang.org/overview.html).

			Substrate and Duniter provide a set of features enabling or disabling parts of the code using conditional compilation. More information on conditional compilation can be found [here](https://doc.rust-lang.org/reference/conditional-compilation.html), or by enabling or disabling compilation of packages. Below is a list of all available features:

			## External

			- runtime-benchmarks: Compiles the runtime with benchmarks for extrinsics benchmarking.
			- try-runtime: Compiles the runtime for tests and verifies operations in a simulated environment.
			- std: Enables the Rust standard library.

			## Duniter

			- gdev: Sets `gdev-runtime` and `std` used to build the development chain.
			- gtest: Sets `gtest-runtime` and `std` used to build the test chain.
			- g1: Sets `g1-runtime` and `std` used to build the production chain.
			- constant-fees: Uses a constant and predictable weight-to-fee conversion only for testing.
			- embed: Enables hardcoded live chainspecs loaded from "../specs/gtest-raw.json" file.
			- native: Compiles the runtime into native-platform executable only for debugging purposes.

			Note: By default, Duniter will be compiled using the `gdev` feature and including the compilation of the distance oracle. Since the three Duniter chains are mutually exclusive, it is mandatory to disable the default feature to compile `gtest` and `g1` as follows:

			- `cargo build --no-default-features --features gtest`
			- `cargo build --no-default-features --features g1`
			- `cargo build --no-default-features -p distance-oracle --features std`

docs/dev/git-conventions.md

+22 −22

Original line number	Original line	Diff line number	Diff line
	@@ -15,10 +15,10 @@ The summary gives an overview of the rules described below. Reading it will help

	## Naming commits		## Naming commits

	Every commit must follow [conventional commit specification v1.0.0].		Every commit must comply with [conventional commit specification v1.0.0].

	The commit name hase to be meaningful in the context of commit history reread. It should not make reference to a specific MR or discussion.		The commit name has to be meaningful in the context of commit history reread. It should not make reference to a specific MR or discussion.
	Among other, commit history is used in changlogs and to follow the project progress, that's why it has to be self-explanatory.		Among other, commit history is used in changlogs and to track the project progress, that's why it has to be self-explanatory.
	If you have a new need, please contact the main developers to add a type together.		If you have a new need, please contact the main developers to add a type together.

	## Update strategy		## Update strategy
	@@ -28,18 +28,13 @@ We only use rebases, merges are strictly fordbidden !
	Every time the `master` branch is updated, you must rebase each of your working branch on it. For each of them:		Every time the `master` branch is updated, you must rebase each of your working branch on it. For each of them:

	1. Go on your branch		1. Go on your branch
	2. Run a rebase on master:		1. Rebase on master with `git rebase master`
			1. If you see conflicts, fix them by editing the sources. Once it is done, you must:
			1. commit the files that were in conflict
			1. continue the rebase with `git rebase --continue`
			1. Keep doing until you don't have any more conflict after `git rebase --continue`.

	git rebase master		To prevent accidental merge commits, we recommend to force the `--ff-only` option on the merge command:

	3. If you see conflicts, fix them by editing the sources. Once it is done, you must:
	a. commit the files that were in conflict
	b. continue the rebase with `git rebase --continue`
	c. Do 3. again for each commit that will be in conflict.

	4. When you don't have any conflict anymore after `git rebase --continue`, then the rebase succeeded. Then rebase a remaning branch.

	To prevent accidental merge commits, we recommend that force the `--ff-only` option on the merge command:

	git config --global merge.ff only		git config --global merge.ff only

	@@ -58,20 +53,24 @@ any problem with your material.

	After complying with the above criteria in your commits, you should check that your branch is up to date with the target branch (`master` in this example). As this branch is moving forward frequently, it is possible that new commits may have occurred while you were working on your branch (named YOUR_BRANCH, here). If this is the case or in case of doubt, to update your branch with respect to `master`, do the following:		After complying with the above criteria in your commits, you should check that your branch is up to date with the target branch (`master` in this example). As this branch is moving forward frequently, it is possible that new commits may have occurred while you were working on your branch (named YOUR_BRANCH, here). If this is the case or in case of doubt, to update your branch with respect to `master`, do the following:

			```bash
	git checkout master # switch to master branch		git checkout master # switch to master branch
	git pull # updates the remote branch based on remote		git pull # updates the remote branch based on remote
	git checkout YOU_BRANCH # switch back to your branch		git checkout YOU_BRANCH # switch back to your branch
	git rebase master # rebase you work on master branch		git rebase master # rebase you work on master branch
			```

	In case of conflict during rebase that you can not solve, contact a lead developer telling them the hash of the commit on which YOUR_BRANCH is currently based so they can reproduce the rebase and see the conflicts. While waiting for their answer, you can cancel the rebase and work on YOUR_BRANCH without updating:		In case of conflict during rebase that you can not solve, contact a lead developer telling them the hash of the commit on which YOUR_BRANCH is currently based so they can reproduce the rebase and see the conflicts. While waiting for their answer, you can cancel the rebase and work on YOUR_BRANCH without updating:

			```
	git rebase --abort		git rebase --abort
			```

	It is better to take your time before integrating a new contribution because the history of the master branch cannot be modified: it is a protected branch. Each commit on this branch remains there ad vitam aeternam that is why we make sure to keep a clear and understandable commit history.		It is better to take your time before integrating a new contribution because the history of the master branch cannot be modified: it is a protected branch. Each commit on this branch remains there ad vitam aeternam that is why we make sure to keep a clear and understandable commit history.

	## Discussion in a merge request		## Discussion in a merge request

	On Gitlab, a discussion is opened for each merge request. It will allow you to discuss the changes you have made. Feel free to identify someone by writing @pseudo so that they are notified of your request. Don't be impatient, the review of your contribution may take more or less time depending on its content!		On Gitlab, a discussion is opened for each merge request. It will allow you to discuss the changes you have made. Feel free to tag someone by writing @pseudo so that they are notified of your request. Don't be impatient, the review of your contribution may take more or less time depending on its content!

	The general discussion is used to comment on the merge request as a whole, for example to tag a developer for a proofreading request. When it comes to discussing a specific change in the code, you should go to the "Changes" tab of the merge request and comment under the code extract involved. This makes it easier to break down the resolution of problems raised by the merge request via the "comment resolution" feature. Each segment can be marked as resolved, but only the reviewer is allowed to do so!		The general discussion is used to comment on the merge request as a whole, for example to tag a developer for a proofreading request. When it comes to discussing a specific change in the code, you should go to the "Changes" tab of the merge request and comment under the code extract involved. This makes it easier to break down the resolution of problems raised by the merge request via the "comment resolution" feature. Each segment can be marked as resolved, but only the reviewer is allowed to do so!

	@@ -81,7 +80,8 @@ When you finished developing, you must compile, run linter and run all tests:

	cargo fmt		cargo fmt
	cargo clippy		cargo clippy
	cd tests && npm test		cargo tu
			cargo cucumber

	Then commit everything.		Then commit everything.

	@@ -93,7 +93,7 @@ If you have a pile of commits, use the useful interactive rebase to clean up you

	There you can rename the `wip:` commits, you can "fixup" commits that go together, you can rename and re-order commits,...		There you can rename the `wip:` commits, you can "fixup" commits that go together, you can rename and re-order commits,...

	After an interactive rebase, your local git history is different that yours in Gitlab, so you need a force push to make it to Gitlab:		After an interactive rebase, your local git history differs from Gitlab's version, so you need a force push to make it to Gitlab:

	git push -f		git push -f

docs/dev/img/release-pipeline.png

0 → 100644

+44.1 KiB

44.14 KiB

docs/dev/launch-a-live-network.md

+66 −19

File changed.

Preview size limit exceeded, changes collapsed.

docs/dev/pallet_conventions.md

0 → 100644

+35 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/dev/release-new-runtime.md

0 → 100644

+58 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/test/replay-block.md→docs/dev/replay-block.md

+5 −3

File changed and moved.

Preview size limit exceeded, changes collapsed.

docs/dev/setup.md

+14 −1

File changed.

Preview size limit exceeded, changes collapsed.

docs/dev/upgrade-substrate.md

0 → 100644

+35 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/dev/verify-runtime-code.md

+9 −2

File changed.

Preview size limit exceeded, changes collapsed.

docs/dev/weights-benchmarking.md

0 → 100644

+93 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/packaging/build-deb.md

0 → 100644

+29 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/user/build-for-arm.md→docs/packaging/build-for-arm.md

+36 −0

File changed and moved.

Preview size limit exceeded, changes collapsed.

docs/packaging/build-rpm.md

0 → 100644

+20 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/user/autocompletion.md

+17 −3

File changed.

Preview size limit exceeded, changes collapsed.

docs/user/distance.md

0 → 100644

+21 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/user/fees.md

0 → 100644

+35 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/user/installation_debian.md

0 → 100644

+26 −0

File added.

Preview size limit exceeded, changes collapsed.

docs/user/rpc.md

deleted100644 → 0

+0 −72

File deleted.

Preview size limit exceeded, changes collapsed.

docs/user/smith.md

deleted100644 → 0

+0 −99

File deleted.

Preview size limit exceeded, changes collapsed.

end2end-tests/Cargo.toml

+46 −23

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/README.md

+41 −15

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/account_creation.feature

+19 −17

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/certification.feature

0 → 100644

+8 −0

Original line number	Original line	Diff line number	Diff line
			@genesis.wot

			Feature: Certification

			Scenario: Dave certifies Alice
			When 2 blocks later
			When dave certifies alice
			Then alice should be certified by dave

end2end-tests/cucumber-features/distance_fail.feature

0 → 100644

+52 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/identity_creation.feature

0 → 100644

+38 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/monetary_mass.feature

+2 −2

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/oneshot_account.feature

0 → 100644

+28 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/transfer_all.feature

+8 −5

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-features/universal_dividend.feature

0 → 100644

+15 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-genesis/bad_distance.json

0 → 100644

+162 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-genesis/default.json

+66 −31

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/cucumber-genesis/wot.json

0 → 100644

+132 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/src/lib.rs

+4 −4

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/common/balances.rs

+61 −61

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/common/cert.rs

0 → 100644

+61 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/common/distance.rs

0 → 100644

+93 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/common/identity.rs

0 → 100644

+107 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/common/mod.rs

+258 −85

File changed.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/common/oneshot.rs

0 → 100644

+128 −0

File added.

Preview size limit exceeded, changes collapsed.

end2end-tests/tests/cucumber_tests.rs

+453 −80

File changed.

Preview size limit exceeded, changes collapsed.

file_header.txt

0 → 100644

+15 −0

File added.

Preview size limit exceeded, changes collapsed.

live-tests/Cargo.toml

0 → 100644

+25 −0

File added.

Preview size limit exceeded, changes collapsed.

live-tests/README.md

0 → 100644

+36 −0

File added.

Preview size limit exceeded, changes collapsed.

runtime/common/src/weights.rs→live-tests/src/lib.rs

+4 −7

File changed and moved.

Preview size limit exceeded, changes collapsed.

live-tests/tests/sanity_gdev.rs

0 → 100644

+502 −0

File added.

Preview size limit exceeded, changes collapsed.

node/Cargo.toml

0 → 100644

+242 −0

File added.

Preview size limit exceeded, changes collapsed.

Admin message

Source

Target

Files

Some changes are not shown.