chia-blockchain 1.8.2rc5__tar.gz → 2.0.0b3__tar.gz

chia-blockchain-2.0.0b3/.coveragerc

@@ -0,0 +1,20 @@
+[run]
+branch=True
+relative_files=True
+source_pkgs=
+  chia
+  tests
+omit=
+  tests/**/config.py
+concurrency=multiprocessing, thread
+parallel=True
+
+[report]
+precision = 1
+exclude_lines =
+  pragma: no cover
+  abc\.abstractmethod
+  typing\.overload
+  ^\s*\.\.\.\s*$
+  if typing.TYPE_CHECKING:
+  if TYPE_CHECKING:

chia-blockchain-2.0.0b3/.github/workflows/require-labels.yml

@@ -0,0 +1,25 @@
+name: 🚨 Check PR Labels
+on:
+  pull_request:
+    types: [opened, labeled, unlabeled, synchronize]
+jobs:
+  check-labels:
+    runs-on: ubuntu-latest
+    permissions:
+      checks: write
+      pull-requests: read
+      statuses: write
+    outputs:
+      status: ${{ steps.check-labels.outputs.status }}
+    steps:
+      - id: check-labels
+        uses: mheap/github-action-required-labels@v5
+        with:
+          mode: exactly
+          count: 1
+          labels: "Added, Changed, Fixed"
+          exit_type: success
+      - run: echo SUCCESS
+        if: steps.check-labels.outputs.status == 'success'
+      - run: echo FAILURE && exit 1
+        if: steps.check-labels.outputs.status == 'failure'

chia-blockchain-2.0.0b3/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.1
+Name: chia-blockchain
+Version: 2.0.0b3
+Summary: Chia blockchain full node, farmer, timelord, and wallet.
+Home-page: https://chia.net/
+Author: Mariano Sorgente
+Author-email: mariano@chia.net
+License: Apache License
+Project-URL: Source, https://github.com/Chia-Network/chia-blockchain/
+Project-URL: Changelog, https://github.com/Chia-Network/chia-blockchain/blob/main/CHANGELOG.md
+Keywords: chia blockchain node
+Requires-Python: >=3.7, <4
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Provides-Extra: upnp
+Provides-Extra: legacy_keyring
+License-File: LICENSE
+
+# chia-blockchain
+
+[![Chia Network logo](https://www.chia.net/wp-content/uploads/2022/09/chia-logo.svg "Chia logo")](https://www.chia.net/)
+
+| Current Release/main | Development Branch/dev |
+|         :---:          |          :---:         |
+| [![Ubuntu Core Tests](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-ubuntu-core.yml/badge.svg)](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-ubuntu-core.yml) [![MacOS Core Tests](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-macos-core.yml/badge.svg)](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-macos-core.yml) [![Windows Installer on Windows 10 and Python 3.7](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-windows-installer.yml/badge.svg)](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-windows-installer.yml)  |  [![Ubuntu Core Tests](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-ubuntu-core.yml/badge.svg?branch=dev)](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-ubuntu-core.yml) [![MacOS Core Tests](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-macos-core.yml/badge.svg?branch=dev)](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-test-macos-core.yml) [![Windows Installer on Windows 10 and Python 3.7](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-windows-installer.yml/badge.svg?branch=dev)](https://github.com/Chia-Network/chia-blockchain/actions/workflows/build-windows-installer.yml) |
+
+![GitHub contributors](https://img.shields.io/github/contributors/Chia-Network/chia-blockchain?logo=GitHub)
+
+Chia is a modern cryptocurrency built from scratch, designed to be efficient, decentralized, and secure. Here are some of the features and benefits:
+* [Proof of space and time](https://docs.google.com/document/d/1tmRIb7lgi4QfKkNaxuKOBHRmwbVlGL4f7EsBDr_5xZE/edit) based consensus which allows anyone to farm with commodity hardware
+* Very easy to use full node and farmer GUI and cli (thousands of nodes active on mainnet)
+* [Chia seeder](https://github.com/Chia-Network/chia-blockchain/wiki/Chia-Seeder-User-Guide), which maintains a list of reliable nodes within the Chia network via a built-in DNS server.
+* Simplified UTXO based transaction model, with small on-chain state
+* Lisp-style Turing-complete functional [programming language](https://chialisp.com/) for money related use cases
+* BLS keys and aggregate signatures (only one signature per block)
+* [Pooling protocol](https://github.com/Chia-Network/chia-blockchain/wiki/Pooling-User-Guide) that allows farmers to have control of making blocks
+* Support for light clients with fast, objective syncing
+* A growing community of farmers and developers around the world
+
+Please check out the [Chia website](https://www.chia.net/), the [wiki](https://github.com/Chia-Network/chia-blockchain/wiki), and [FAQ](https://github.com/Chia-Network/chia-blockchain/wiki/FAQ) for
+information on this project.
+
+Python 3.7+ is required. Make sure your default python version is >=3.7
+by typing `python3`.
+
+If you are behind a NAT, it can be difficult for peers outside your subnet to
+reach you when they start up. You can enable
+[UPnP](https://www.homenethowto.com/ports-and-nat/upnp-automatic-port-forward/)
+on your router or add a NAT (for IPv4 but not IPv6) and firewall rules to allow
+TCP port 8444 access to your peer.
+These methods tend to be router make/model specific.
+
+Most users should only install harvesters, farmers, plotter, full nodes, and wallets.
+Setting up a seeder is best left to more advanced users.
+Building Timelords and VDFs is for sophisticated users, in most environments.
+Chia Network and additional volunteers are running sufficient Timelords
+for consensus.
+
+## Installing
+
+Install instructions are available in the
+[INSTALL](https://github.com/Chia-Network/chia-blockchain/wiki/INSTALL)
+section of the
+[chia-blockchain repository wiki](https://github.com/Chia-Network/chia-blockchain/wiki).
+
+## Running
+
+Once installed, a
+[Quick Start Guide](https://github.com/Chia-Network/chia-blockchain/wiki/Quick-Start-Guide)
+is available from the repository
+[wiki](https://github.com/Chia-Network/chia-blockchain/wiki).

chia-blockchain-2.0.0b3/benchmarks/mempool.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import asyncio
+import cProfile
+import sys
+from contextlib import contextmanager
+from dataclasses import dataclass
+from subprocess import check_call
+from time import monotonic
+from typing import Dict, Iterator, List, Optional, Tuple
+
+from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
+from chia.consensus.cost_calculator import NPCResult
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.full_node.mempool_manager import MempoolManager
+from chia.simulator.wallet_tools import WalletTool
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_record import CoinRecord
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.types.spend_bundle import SpendBundle
+from chia.types.spend_bundle_conditions import Spend, SpendBundleConditions
+from chia.util.ints import uint32, uint64
+from chia.util.misc import to_batches
+
+NUM_ITERS = 200
+NUM_PEERS = 5
+
+
+@contextmanager
+def enable_profiler(profile: bool, name: str) -> Iterator[None]:
+    if sys.version_info < (3, 8):
+        raise Exception(f"Python 3.8 or higher required, running with: {sys.version}")
+
+    if not profile:
+        yield
+        return
+
+    with cProfile.Profile() as pr:
+        yield
+
+    pr.create_stats()
+    output_file = f"mempool-{name}"
+    pr.dump_stats(output_file + ".profile")
+    check_call(["gprof2dot", "-f", "pstats", "-o", output_file + ".dot", output_file + ".profile"])
+    with open(output_file + ".png", "w+") as f:
+        check_call(["dot", "-T", "png", output_file + ".dot"], stdout=f)
+    print("  output written to: %s.png" % output_file)
+
+
+def make_hash(height: int) -> bytes32:
+    return bytes32(height.to_bytes(32, byteorder="big"))
+
+
+@dataclass(frozen=True)
+class BenchBlockRecord:
+    """
+    This is a subset of BlockRecord that the mempool manager uses for peak.
+    """
+
+    header_hash: bytes32
+    height: uint32
+    timestamp: Optional[uint64]
+    prev_transaction_block_height: uint32
+    prev_transaction_block_hash: Optional[bytes32]
+
+    @property
+    def is_transaction_block(self) -> bool:
+        return self.timestamp is not None
+
+
+def fake_block_record(block_height: uint32, timestamp: uint64) -> BenchBlockRecord:
+    this_hash = make_hash(block_height)
+    prev_hash = make_hash(block_height - 1)
+    return BenchBlockRecord(
+        header_hash=this_hash,
+        height=block_height,
+        timestamp=timestamp,
+        prev_transaction_block_height=uint32(block_height - 1),
+        prev_transaction_block_hash=prev_hash,
+    )
+
+
+async def run_mempool_benchmark() -> None:
+    all_coins: Dict[bytes32, CoinRecord] = {}
+
+    async def get_coin_record(coin_id: bytes32) -> Optional[CoinRecord]:
+        return all_coins.get(coin_id)
+
+    wt = WalletTool(DEFAULT_CONSTANTS)
+
+    spend_bundles: List[List[SpendBundle]] = []
+
+    # these spend the same coins as spend_bundles but with a higher fee
+    replacement_spend_bundles: List[List[SpendBundle]] = []
+
+    # these spend the same coins as spend_bundles, but they are organized in
+    # much larger bundles
+    large_spend_bundles: List[List[SpendBundle]] = []
+
+    timestamp = uint64(1631794488)
+
+    height = uint32(1)
+
+    print("Building SpendBundles")
+    for peer in range(NUM_PEERS):
+        print(f"  peer {peer}")
+        print("     reward coins")
+        unspent: List[Coin] = []
+        for idx in range(NUM_ITERS):
+            height = uint32(height + 1)
+
+            # 19 seconds per block
+            timestamp = uint64(timestamp + 19)
+
+            # farm rewards
+            farmer_coin = create_farmer_coin(
+                height, wt.get_new_puzzlehash(), uint64(250000000), DEFAULT_CONSTANTS.GENESIS_CHALLENGE
+            )
+            pool_coin = create_pool_coin(
+                height, wt.get_new_puzzlehash(), uint64(1750000000), DEFAULT_CONSTANTS.GENESIS_CHALLENGE
+            )
+            all_coins[farmer_coin.name()] = CoinRecord(farmer_coin, height, uint32(0), True, timestamp)
+            all_coins[pool_coin.name()] = CoinRecord(pool_coin, height, uint32(0), True, timestamp)
+            unspent.extend([farmer_coin, pool_coin])
+
+        print("     spend bundles")
+        bundles: List[SpendBundle] = []
+        for coin in unspent:
+            tx: SpendBundle = wt.generate_signed_transaction(
+                uint64(coin.amount // 2), wt.get_new_puzzlehash(), coin, fee=peer + idx
+            )
+            bundles.append(tx)
+        spend_bundles.append(bundles)
+
+        bundles = []
+        print("     replacement spend bundles")
+        for coin in unspent:
+            tx = wt.generate_signed_transaction(
+                uint64(coin.amount // 2), wt.get_new_puzzlehash(), coin, fee=peer + idx + 10000000
+            )
+            bundles.append(tx)
+        replacement_spend_bundles.append(bundles)
+
+        bundles = []
+        print("     large spend bundles")
+        for batch in to_batches(unspent, 200):
+            print(f"{len(batch.entries)} coins")
+            tx = SpendBundle.aggregate(
+                [
+                    wt.generate_signed_transaction(uint64(c.amount // 2), wt.get_new_puzzlehash(), c, fee=peer + idx)
+                    for c in batch.entries
+                ]
+            )
+            bundles.append(tx)
+        large_spend_bundles.append(bundles)
+
+    start_height = height
+    for single_threaded in [False, True]:
+        if single_threaded:
+            print("\n== Single-threaded")
+        else:
+            print("\n== Multi-threaded")
+
+        mempool = MempoolManager(get_coin_record, DEFAULT_CONSTANTS, single_threaded=single_threaded)
+
+        height = start_height
+        rec = fake_block_record(height, timestamp)
+        await mempool.new_peak(rec, None)
+
+        async def add_spend_bundles(spend_bundles: List[SpendBundle]) -> None:
+            for tx in spend_bundles:
+                spend_bundle_id = tx.name()
+                npc = await mempool.pre_validate_spendbundle(tx, None, spend_bundle_id)
+                assert npc is not None
+                _, status, error = await mempool.add_spend_bundle(tx, npc, spend_bundle_id, height)
+                assert status == MempoolInclusionStatus.SUCCESS
+                assert error is None
+
+        suffix = "st" if single_threaded else "mt"
+
+        print("\nProfiling add_spend_bundle() with large bundles")
+        total_bundles = 0
+        tasks = []
+        with enable_profiler(True, f"add-large-{suffix}"):
+            start = monotonic()
+            for peer in range(NUM_PEERS):
+                total_bundles += len(large_spend_bundles[peer])
+                tasks.append(asyncio.create_task(add_spend_bundles(large_spend_bundles[peer])))
+            await asyncio.gather(*tasks)
+            stop = monotonic()
+        print(f"  time: {stop - start:0.4f}s")
+        print(f"  per call: {(stop - start) / total_bundles * 1000:0.2f}ms")
+
+        mempool = MempoolManager(get_coin_record, DEFAULT_CONSTANTS, single_threaded=single_threaded)
+
+        height = start_height
+        rec = fake_block_record(height, timestamp)
+        await mempool.new_peak(rec, None)
+
+        print("\nProfiling add_spend_bundle()")
+        total_bundles = 0
+        tasks = []
+        with enable_profiler(True, f"add-{suffix}"):
+            start = monotonic()
+            for peer in range(NUM_PEERS):
+                total_bundles += len(spend_bundles[peer])
+                tasks.append(asyncio.create_task(add_spend_bundles(spend_bundles[peer])))
+            await asyncio.gather(*tasks)
+            stop = monotonic()
+        print(f"  time: {stop - start:0.4f}s")
+        print(f"  per call: {(stop - start) / total_bundles * 1000:0.2f}ms")
+
+        print("\nProfiling add_spend_bundle() with replace-by-fee")
+        total_bundles = 0
+        tasks = []
+        with enable_profiler(True, f"replace-{suffix}"):
+            start = monotonic()
+            for peer in range(NUM_PEERS):
+                total_bundles += len(replacement_spend_bundles[peer])
+                tasks.append(asyncio.create_task(add_spend_bundles(replacement_spend_bundles[peer])))
+            await asyncio.gather(*tasks)
+            stop = monotonic()
+        print(f"  time: {stop - start:0.4f}s")
+        print(f"  per call: {(stop - start) / total_bundles * 1000:0.2f}ms")
+
+        print("\nProfiling create_bundle_from_mempool()")
+        with enable_profiler(True, f"create-{suffix}"):
+            start = monotonic()
+            for _ in range(500):
+                mempool.create_bundle_from_mempool(rec.header_hash)
+            stop = monotonic()
+        print(f"  time: {stop - start:0.4f}s")
+        print(f"  per call: {(stop - start) / 500 * 1000:0.2f}ms")
+
+        print("\nProfiling new_peak() (optimized)")
+        blocks: List[Tuple[BenchBlockRecord, NPCResult]] = []
+        for coin_id in all_coins.keys():
+            height = uint32(height + 1)
+            timestamp = uint64(timestamp + 19)
+            rec = fake_block_record(height, timestamp)
+            npc_result = NPCResult(
+                None,
+                SpendBundleConditions(
+                    [Spend(coin_id, bytes32(b" " * 32), None, None, None, None, None, None, [], [], 0)],
+                    0,
+                    0,
+                    0,
+                    None,
+                    None,
+                    [],
+                    0,
+                    0,
+                    0,
+                ),
+                uint64(1000000000),
+            )
+            blocks.append((rec, npc_result))
+
+        with enable_profiler(True, f"new-peak-{suffix}"):
+            start = monotonic()
+            for rec, npc_result in blocks:
+                await mempool.new_peak(rec, npc_result)
+            stop = monotonic()
+        print(f"  time: {stop - start:0.4f}s")
+        print(f"  per call: {(stop - start) / len(blocks) * 1000:0.2f}ms")
+
+        print("\nProfiling new_peak() (reorg)")
+        blocks = []
+        for coin_id in all_coins.keys():
+            height = uint32(height + 2)
+            timestamp = uint64(timestamp + 28)
+            rec = fake_block_record(height, timestamp)
+            npc_result = NPCResult(
+                None,
+                SpendBundleConditions(
+                    [Spend(coin_id, bytes32(b" " * 32), None, None, None, None, None, None, [], [], 0)],
+                    0,
+                    0,
+                    0,
+                    None,
+                    None,
+                    [],
+                    0,
+                    0,
+                    0,
+                ),
+                uint64(1000000000),
+            )
+            blocks.append((rec, npc_result))
+
+        with enable_profiler(True, f"new-peak-reorg-{suffix}"):
+            start = monotonic()
+            for rec, npc_result in blocks:
+                await mempool.new_peak(rec, npc_result)
+            stop = monotonic()
+        print(f"  time: {stop - start:0.4f}s")
+        print(f"  per call: {(stop - start) / len(blocks) * 1000:0.2f}ms")
+
+
+if __name__ == "__main__":
+    import logging
+
+    logger = logging.getLogger()
+    logger.addHandler(logging.StreamHandler())
+    logger.setLevel(logging.WARNING)
+    asyncio.run(run_mempool_benchmark())

chia-blockchain-2.0.0b3/build_scripts/build_license_directory.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+# PULL IN LICENSES USING NPM - LICENSE CHECKER
+npm install -g license-checker
+
+cd ../chia-blockchain-gui || exit 1
+
+npm ci
+
+sum=$(license-checker --summary)
+printf "%s\n" "$sum"
+
+license_list=$(license-checker --json | jq -r '.[].licenseFile' | grep -v null)
+
+# Split the license list by newline character into an array
+IFS=$'\n' read -rd '' -a licenses_array <<< "$license_list"
+
+#print the contents of the array
+printf '%s\n' "${licenses_array[@]}"
+
+for i in "${licenses_array[@]}"; do
+    dirname="licenses/$(dirname "$i" | awk -F'/' '{print $NF}')"
+    mkdir -p "$dirname"
+    echo "$dirname"
+    cp "$i" "$dirname"
+done
+
+mv licenses/ ../build_scripts/dist/daemon
+cd ../build_scripts || exit 1
+
+
+# PULL IN THE LICENSES FROM PIP-LICENSE
+pip install pip-licenses || pip3 install pip-licenses
+
+# capture the output of the command in a variable
+output=$(pip-licenses -l -f json | jq -r '.[].LicenseFile' | grep -v UNKNOWN)
+
+# initialize an empty array
+license_path_array=()
+
+# read the output line by line into the array
+while IFS= read -r line; do
+    license_path_array+=("$line")
+done <<< "$output"
+
+# create a dir for each license and copy the license file over
+for i in "${license_path_array[@]}"; do
+  dirname="dist/daemon/licenses/$(dirname "$i" | awk -F'/' '{print $NF}')"
+  echo "$dirname"
+  mkdir -p "$dirname"
+  cp "$i" "$dirname"
+  echo "$i"
+done
+
+ls -lah dist/daemon

chia-blockchain-2.0.0b3/build_scripts/build_linux_deb-2-installer.sh

@@ -0,0 +1,134 @@
+#!/bin/bash
+
+set -o errexit
+
+if [ ! "$1" ]; then
+  echo "This script requires either amd64 of arm64 as an argument"
+	exit 1
+elif [ "$1" = "amd64" ]; then
+	PLATFORM="amd64"
+else
+	PLATFORM="arm64"
+fi
+export PLATFORM
+
+git status
+git submodule
+
+# If the env variable NOTARIZE and the username and password variables are
+# set, this will attempt to Notarize the signed DMG
+
+if [ ! "$CHIA_INSTALLER_VERSION" ]; then
+	echo "WARNING: No environment variable CHIA_INSTALLER_VERSION set. Using 0.0.0."
+	CHIA_INSTALLER_VERSION="0.0.0"
+fi
+echo "Chia Installer Version is: $CHIA_INSTALLER_VERSION"
+export CHIA_INSTALLER_VERSION
+
+echo "Installing npm and electron packagers"
+cd npm_linux || exit 1
+npm ci
+PATH=$(npm bin):$PATH
+cd .. || exit 1
+
+echo "Create dist/"
+rm -rf dist
+mkdir dist
+
+echo "Create executables with pyinstaller"
+SPEC_FILE=$(python -c 'import chia; print(chia.PYINSTALLER_SPEC_PATH)')
+pyinstaller --log-level=INFO "$SPEC_FILE"
+LAST_EXIT_CODE=$?
+if [ "$LAST_EXIT_CODE" -ne 0 ]; then
+	echo >&2 "pyinstaller failed!"
+	exit $LAST_EXIT_CODE
+fi
+
+# Creates a directory of licenses
+echo "Building pip and NPM license directory"
+pwd
+bash ./build_license_directory.sh
+
+
+# Builds CLI only .deb
+# need j2 for templating the control file
+pip install j2cli
+CLI_DEB_BASE="chia-blockchain-cli_$CHIA_INSTALLER_VERSION-1_$PLATFORM"
+mkdir -p "dist/$CLI_DEB_BASE/opt/chia"
+mkdir -p "dist/$CLI_DEB_BASE/usr/bin"
+mkdir -p "dist/$CLI_DEB_BASE/DEBIAN"
+j2 -o "dist/$CLI_DEB_BASE/DEBIAN/control" assets/deb/control.j2
+cp -r dist/daemon/* "dist/$CLI_DEB_BASE/opt/chia/"
+
+ln -s ../../opt/chia/chia "dist/$CLI_DEB_BASE/usr/bin/chia"
+dpkg-deb --build --root-owner-group "dist/$CLI_DEB_BASE"
+# CLI only .deb done
+
+cp -r dist/daemon ../chia-blockchain-gui/packages/gui
+
+# Change to the gui package
+cd ../chia-blockchain-gui/packages/gui || exit 1
+
+# sets the version for chia-blockchain in package.json
+cp package.json package.json.orig
+jq --arg VER "$CHIA_INSTALLER_VERSION" '.version=$VER' package.json > temp.json && mv temp.json package.json
+
+echo "Building Linux(deb) Electron app"
+PRODUCT_NAME="chia"
+if [ "$PLATFORM" = "arm64" ]; then
+  # electron-builder does not work for arm64 as of Aug 16, 2022.
+  # This is a temporary fix.
+  # https://github.com/jordansissel/fpm/issues/1801#issuecomment-919877499
+  # @TODO Consolidates the process to amd64 if the issue of electron-builder is resolved
+  sudo apt -y install ruby ruby-dev
+  # `sudo gem install public_suffix -v 4.0.7` is required to fix the error below.
+  #   ERROR:  Error installing fpm:
+  #   The last version of public_suffix (< 6.0, >= 2.0.2) to support your Ruby & RubyGems was 4.0.7. Try installing it with `gem install public_suffix -v 4.0.7` and then running the current command again
+  #   public_suffix requires Ruby version >= 2.6. The current ruby version is 2.5.0.
+  # @TODO Maybe versions of sub dependencies should be managed by gem lock file.
+  # @TODO Once ruby 2.6 can be installed on `apt install ruby`, installing public_suffix below should be removed.
+  sudo gem install public_suffix -v 4.0.7
+  sudo gem install fpm
+  echo USE_SYSTEM_FPM=true electron-builder build --linux deb --arm64 \
+    --config.extraMetadata.name=chia-blockchain \
+    --config.productName="$PRODUCT_NAME" --config.linux.desktop.Name="Chia Blockchain" \
+    --config.deb.packageName="chia-blockchain"
+  USE_SYSTEM_FPM=true electron-builder build --linux deb --arm64 \
+    --config.extraMetadata.name=chia-blockchain \
+    --config.productName="$PRODUCT_NAME" --config.linux.desktop.Name="Chia Blockchain" \
+    --config.deb.packageName="chia-blockchain"
+  LAST_EXIT_CODE=$?
+else
+  echo electron-builder build --linux deb --x64 \
+    --config.extraMetadata.name=chia-blockchain \
+    --config.productName="$PRODUCT_NAME" --config.linux.desktop.Name="Chia Blockchain" \
+    --config.deb.packageName="chia-blockchain"
+  electron-builder build --linux deb --x64 \
+    --config.extraMetadata.name=chia-blockchain \
+    --config.productName="$PRODUCT_NAME" --config.linux.desktop.Name="Chia Blockchain" \
+    --config.deb.packageName="chia-blockchain"
+  LAST_EXIT_CODE=$?
+fi
+ls -l dist/linux*-unpacked/resources
+
+# reset the package.json to the original
+mv package.json.orig package.json
+
+if [ "$LAST_EXIT_CODE" -ne 0 ]; then
+	echo >&2 "electron-builder failed!"
+	exit $LAST_EXIT_CODE
+fi
+
+GUI_DEB_NAME=chia-blockchain_${CHIA_INSTALLER_VERSION}_${PLATFORM}.deb
+mv "dist/${PRODUCT_NAME}-${CHIA_INSTALLER_VERSION}.deb" "../../../build_scripts/dist/${GUI_DEB_NAME}"
+cd ../../../build_scripts || exit 1
+
+echo "Create final installer"
+rm -rf final_installer
+mkdir final_installer
+
+mv "dist/${GUI_DEB_NAME}" final_installer/
+# Move the cli only deb into final installers as well, so it gets uploaded as an artifact
+mv "dist/${CLI_DEB_BASE}.deb" final_installer/
+
+ls -l final_installer/