Skip to content

Latest commit

 

History

History
239 lines (182 loc) · 8.88 KB

README.md

File metadata and controls

239 lines (182 loc) · 8.88 KB

Contents

This directory contains tools for developers working on this repository.

clang-format-diff.py

A script to format unified git diffs according to .clang-format.

Requires clang-format, installed e.g. via brew install clang-format on macOS, or sudo apt install clang-format on Debian/Ubuntu.

For instance, to format the last commit with 0 lines of context, the script should be called from the git root folder as follows.

git diff -U0 HEAD~1.. | ./contrib/devtools/clang-format-diff.py -p1 -i -v

copyright_header.py

Provides utilities for managing copyright headers of The Dash Core developers in repository source files. It has three subcommands:

$ ./copyright_header.py report <base_directory> [verbose]
$ ./copyright_header.py update <base_directory>
$ ./copyright_header.py insert <file>

Running these subcommands without arguments displays a usage string.

copyright_header.py report <base_directory> [verbose]

Produces a report of all copyright header notices found inside the source files of a repository. Useful to quickly visualize the state of the headers. Specifying verbose will list the full filenames of files of each category.

copyright_header.py update <base_directory> [verbose]

Updates all the copyright headers of The Dash Core developers which were changed in a year more recent than is listed. For example:

// Copyright (c) <firstYear>-<lastYear> The Dash Core developers

will be updated to:

// Copyright (c) <firstYear>-<lastModifiedYear> The Dash Core developers

where <lastModifiedYear> is obtained from the git log history.

This subcommand also handles copyright headers that have only a single year. In those cases:

// Copyright (c) <year> The Dash Core developers

will be updated to:

// Copyright (c) <year>-<lastModifiedYear> The Dash Core developers

where the update is appropriate.

copyright_header.py insert <file>

Inserts a copyright header for The Dash Core developers at the top of the file in either Python or C++ style as determined by the file extension. If the file is a Python file and it has #! starting the first line, the header is inserted in the line below it.

The copyright dates will be set to be <year_introduced>-<current_year> where <year_introduced> is according to the git log history. If <year_introduced> is equal to <current_year>, it will be set as a single year rather than two hyphenated years.

If the file already has a copyright for The Dash Core developers, the script will exit.

gen-manpages.py

A small script to automatically create manpages in ../../doc/man by running the release binaries with the -help option. This requires help2man which can be found at: https://www.gnu.org/software/help2man/

This tool can be run from any directory within the repository. It looks for the binaries in build/; to use another build directory set BUILDDIR. For example:

BUILDDIR=$PWD/build contrib/devtools/gen-manpages.py

gen-dash-conf.sh

Generates a dash.conf file in contrib/debian/examples/ by parsing the output from dashd --help. This script is run during the release process to include a dash.conf with the release binaries and can also be run by users to generate a file locally. When generating a file as part of the release process, make sure to commit the changes after running the script.

This tool can be run from any directory within the repository. It looks for the binaries in build/; to use another build directory set BUILDDIR. For example:

BUILDDIR=$PWD/build contrib/devtools/gen-dash-conf.sh

github-merge.py

A small script to automate merging pull-requests securely and sign them with GPG.

For example:

./github-merge.py 3077

(in any git repository) will help you merge pull request #3077 for the dashpay/dash repository.

What it does:

  • Fetch the target branch (the pull request's base by default) and the pull request.
  • Locally construct a merge commit.
  • Show the diff that merge results in.
  • Ask you to verify the resulting source tree (so you can do a make check or whatever).
  • Ask you whether to GPG sign the merge commit.
  • Ask you whether to push the result upstream.

This means that there are no potential race conditions (where a pullreq gets updated while you're reviewing it, but before you click merge), and when using GPG signatures, that even a compromised GitHub couldn't mess with the sources.

Setup

Configuring the github-merge tool for the Dash Core repository is done in the following way:

git config githubmerge.repository dashpay/dash
git config githubmerge.testcmd "make -j4 check" (adapt to whatever you want to use for testing)
git config --global user.signingkey mykeyid

Authentication (optional)

The API request limit for unauthenticated requests is quite low, but the limit for authenticated requests is much higher. If you start running into rate limiting errors it can be useful to set an authentication token so that the script can authenticate requests.

If user.ghtoken is not set and the GitHub CLI is installed and logged in (gh auth login), the script uses the GitHub CLI token automatically and no further setup is needed. A configured user.ghtoken always takes precedence. Otherwise, or to use a different token:

  • First, go to Personal access tokens.
  • Click 'Generate new token'.
  • Fill in an arbitrary token description. No further privileges are needed.
  • Click the Generate token button at the bottom of the form.
  • Copy the generated token (should be a hexadecimal string)

Then do:

git config --global user.ghtoken "pasted token"

Create and verify timestamps of merge commits

To create or verify timestamps on the merge commits, install the OpenTimestamps client via pip3 install opentimestamps-client. Then, download the gpg wrapper ots-git-gpg-wrapper.sh and set it as git's gpg.program. See the ots git integration documentation for further details.

optimize-pngs.py

A script to optimize png files in the dash repository (requires pngcrush and zopflipng).

./contrib/devtools/optimize-pngs.py src/qt/res/animation/ src/qt/res/icons/ src/qt/res/images/ share/pixmaps/

update-translations.py

Run this script from the root of the repository to update all translations from transifex. It will do the following automatically:

  • remove current translations
  • fetch all translations
  • post-process them into valid and committable format
  • drop untranslated languages
  • update git for added translations
  • update build system

See doc/translation_process.md for more information.

circular-dependencies.py

Run this script from the root of the source tree (src/) to find circular dependencies in the source code. This looks only at which files include other files, treating the .cpp and .h file as one unit.

Example usage:

cd .../src
../contrib/devtools/circular-dependencies.py {*,*/*,*/*/*}.{h,cpp}

update-rust-hashes.py

Refreshes the sha256 pins of the prebuilt Rust toolchain (depends/packages/native_rust.mk) and of the per-host standard libraries (depends/packages/rust_stdlib.mk) after the version in native_rust.mk was changed; each downloaded archive must match the .sha256 file published next to it. --check compares the pins with the published .sha256 files instead of rewriting them.

platform-bundle.sh

Produces the crate bundle from which depends/packages/platform_cxx.mk builds dash-sdk-cxx (the C++ binding of the Dash Platform SDK) for a given dashpay/platform commit, and prints the hashes to pin in platform_cxx.mk. The bundle includes the Tenderdash source archive for the tag the commit's Cargo.lock pins, so the two cannot disagree. Requires the Cargo version pinned in native_rust.mk, GNU tar, GNU gzip (set TAR and GZIP_PROG if they are installed under other names) and a TMPDIR with no .cargo/config.toml in any parent directory. The output is reproducible: rerunning it for the same commit yields the same bundle hash on any machine. The Platform tarball and the bundle are then uploaded to the depends sources mirror.

contrib/devtools/platform-bundle.sh <platform-commit>

check-no-rust.py

Fails if any of the given executables contain Rust code. Run by the linux64 CI job, which builds against depends with PLATFORM_GUI=1, on dashd, the command-line tools, bench_dash and the fuzz binary, which must never link dash-sdk-cxx.