diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 8c36e89..07f74b0 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -1,7 +1,9 @@
-name: Build & publish
+name: Build & publish image
 
 on:
   workflow_dispatch:
+  release:
+    types: [published]
 
 jobs:
   push_to_registry:
diff --git a/.github/workflows/run_long_integration_tests.yml b/.github/workflows/run_long_integration_tests.yml
new file mode 100644
index 0000000..acbe245
--- /dev/null
+++ b/.github/workflows/run_long_integration_tests.yml
@@ -0,0 +1,25 @@
+name: Long integration tests
+
+on:
+  workflow_dispatch:
+  pull_request:
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Build image
+        run: |
+          docker buildx build --output type=docker --no-cache . -t sdk-rust-contract-builder:next -f ./Dockerfile
+
+      - name: Build
+        run: |
+          export PYTHONPATH=.
+          python ./integration_tests/test_previous_builds_are_reproducible.py --selected-builds "a.1" "a.2" "a.3" "b.1" "b.2" "b.3" "c.1" "c.2" "c.3" "c.4" "c.5" "d.1" "e.1"
diff --git a/.github/workflows/run_regular_integration_tests.yml b/.github/workflows/run_regular_integration_tests.yml
new file mode 100644
index 0000000..6ba7a62
--- /dev/null
+++ b/.github/workflows/run_regular_integration_tests.yml
@@ -0,0 +1,25 @@
+name: Regular integration tests
+
+on:
+  workflow_dispatch:
+  pull_request:
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Build image
+        run: |
+          docker buildx build --output type=docker --no-cache . -t sdk-rust-contract-builder:next -f ./Dockerfile
+
+      - name: Build
+        run: |
+          export PYTHONPATH=.
+          python ./integration_tests/test_project_folder_and_packaged_src_are_equivalent.py
diff --git a/.gitignore b/.gitignore
index a356615..df9b3cd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -132,4 +132,6 @@ dmypy.json
 typings/**
 
 # Test data
-testdata/**/output
+testdata/input/extracted
+testdata/output
+testdata/rust
diff --git a/Dockerfile b/Dockerfile
index c3ef430..548e5b0 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,18 +1,22 @@
 FROM ubuntu:22.04
 
 # Constants
-ARG VERSION_RUST="nightly-2022-12-08"
+ARG VERSION_RUST="nightly-2022-10-16"
 ARG VERSION_BINARYEN="105-1"
 ARG VERSION_WABT="1.0.27-1"
+# Normally, this should be "multiversx/sdk-rust-contract-builder:{{pyproject.toml:project:version}}"
+ARG CONTEXT="multiversx/sdk-rust-contract-builder:v4.1.0"
 
 # Install dependencies (including binaryen and wabt)
 RUN apt-get update && apt-get install -y \
     wget \ 
     build-essential \
-    python3.10 python-is-python3 \
+    python3.11 python-is-python3 python3-pip \
     binaryen=${VERSION_BINARYEN} \
     wabt=${VERSION_WABT}
 
+RUN pip3 install tomlkit==0.11.6
+
 # Install rust
 RUN wget -O rustup.sh https://sh.rustup.rs && \
     chmod +x rustup.sh && \
@@ -25,6 +29,7 @@ COPY "multiversx_sdk_rust_contract_builder" "/multiversx_sdk_rust_contract_build
 ENV PATH="/rust/bin:${PATH}"
 ENV CARGO_HOME="/rust"
 ENV RUSTUP_HOME="/rust"
+ENV CONTEXT=${CONTEXT}
 ENV PYTHONPATH=/
 
 # Additional arguments (must be provided at "docker run"):
diff --git a/README.md b/README.md
index 601465f..05da2b2 100644
--- a/README.md
+++ b/README.md
@@ -1,56 +1,66 @@
-# mx-sdk-build-contract
+# mx-sdk-rust-contract-builder
 
 Docker image (and wrappers) for reproducible contract builds (Rust). See [docs.multiversx.com](https://docs.multiversx.com/developers/reproducible-contract-builds/).
 
 ## Build the Docker image
 
+We use `docker buildx` to build the image:
+
+```
+docker buildx build --output type=docker --no-cache . -t sdk-rust-contract-builder:next -f ./Dockerfile
 ```
-docker buildx build --no-cache . -t sdk-rust-contract-builder:experimental -f ./Dockerfile
+
+Maintainers can publish the image as follows:
+
+```
+docker buildx create --name multiarch --use
+
+docker buildx build --no-cache --push --platform=linux/amd64,linux/arm64 . -t multiversx/sdk-rust-contract-builder:next -f ./Dockerfile
+
+docker buildx rm multiarch
 ```
 
+For the above to work properly, make sure to install `tonistiigi/binfmt` beforehand. Please follow the official Docker documentation [here](https://docs.docker.com/build/building/multi-platform/).
+
+Though, note that currently (January 2023) we recommend against using the `linux/arm64` image for performing reproducible contract builds. This is because, in some (possibly rare) circumstances, a WASM binary generated on the `linux/amd64` image _might_ differ (at the bytecode level) from one generated on the `linux/arm64` image - probably due to distinct (unfortunate) bytecode-emitting logic in the Rust compiler.
+
 ## Build contract using the wrapper
 
-Without providing `cargo-target-dir`:
+If you are using a Mac with ARM64, we _recommend_ setting the following variable beforehand (contract builds will be slower, but this eliminates the risk of not being able to reproduce the build on Linux):
 
 ```
-python3 ./build_with_docker.py --image=sdk-rust-contract-builder:experimental \
-    --project=~/contracts/reproducible-contract-build-example \
-    --output=~/contracts/output-from-docker
+export DOCKER_DEFAULT_PLATFORM=linux/amd64
 ```
 
-With providing `cargo-target-dir`:
+Building from a project folder:
 
 ```
-python3 ./build_with_docker.py --image=sdk-rust-contract-builder:experimental \
-    --project=~/contracts/reproducible-contract-build-example \
-    --output=~/contracts/output-from-docker \
-    --cargo-target-dir=~/cargo-target-dir-docker
+python3 ./build_with_docker.py --image=sdk-rust-contract-builder:next \
+    --project=~/contracts/example \
+    --output=~/contracts/output-from-docker
 ```
 
 Building from a packaged source code:
 
 ```
-python3 ./build_with_docker.py --image=sdk-rust-contract-builder:experimental \
+python3 ./build_with_docker.py --image=sdk-rust-contract-builder:next \
     --packaged-src=~/contracts/example-0.0.0.source.json \
     --output=~/contracts/output-from-docker
 ```
 
-## Build contract using the Docker inner script
-
-This is useful for useful for testing, debugging and reviewing the script.
+## Run unit tests (without Docker)
 
 ```
-export PROJECT=${HOME}/contracts/reproducible-contract-build-example
-export OUTPUT=${HOME}/contracts/output
-export CARGO_TARGET_DIR=${HOME}/cargo-target-dir
 export PATH=${HOME}/multiversx-sdk/vendor-rust/bin:${HOME}/multiversx-sdk/wabt/latest/bin:${PATH}
 export RUSTUP_HOME=${HOME}/multiversx-sdk/vendor-rust
 export CARGO_HOME=${HOME}/multiversx-sdk/vendor-rust
+
+pytest .
 ```
 
-Build a project:
+## Run integration tests (with Docker)
 
 ```
-python3 ./build_within_docker.py --project=${PROJECT} --output=${OUTPUT} \
-    --cargo-target-dir=${CARGO_TARGET_DIR}
+python3 ./integration_tests/test_previous_builds_are_reproducible.py --selected-builds "a.1" [...]
+python3 ./integration_tests/test_project_folder_and_packaged_src_are_equivalent.py
 ```
diff --git a/build_with_docker.py b/build_with_docker.py
index d7d539f..0057a74 100644
--- a/build_with_docker.py
+++ b/build_with_docker.py
@@ -75,7 +75,7 @@ def run_docker(
         docker_mount_args.extend(["--volume", f"{packaged_src_path}:/packaged-src.json"])
 
     if cargo_target_dir:
-        docker_mount_args += ["--volume", f"{cargo_target_dir}:/cargo-target-dir"]
+        docker_mount_args += ["--volume", f"{cargo_target_dir}:/rust/cargo-target-dir"]
 
     docker_args = ["docker", "run"]
 
diff --git a/integration_tests/__init__.py b/integration_tests/__init__.py
new file mode 100644
index 0000000..a9a2c5b
--- /dev/null
+++ b/integration_tests/__init__.py
@@ -0,0 +1 @@
+__all__ = []
diff --git a/integration_tests/config.py b/integration_tests/config.py
new file mode 100644
index 0000000..b2eb57f
--- /dev/null
+++ b/integration_tests/config.py
@@ -0,0 +1,9 @@
+from pathlib import Path
+
+DOWNLOADS_FOLDER = Path("./testdata/downloads").resolve()
+EXTRACTED_FOLDER = Path("./testdata/input/extracted").resolve()
+PARENT_OUTPUT_FOLDER = Path("./testdata/output").resolve()
+CARGO_TARGET_DIR = Path("./testdata/rust/cargo_target_dir").resolve()
+RUST_REGISTRY = Path("./testdata/rust/registry").resolve()
+RUST_GIT = Path("./testdata/rust/git").resolve()
+RUST_TMP = Path("./testdata/rust/tmp").resolve()
diff --git a/integration_tests/previous_builds.py b/integration_tests/previous_builds.py
new file mode 100644
index 0000000..0bfcf13
--- /dev/null
+++ b/integration_tests/previous_builds.py
@@ -0,0 +1,263 @@
+
+from typing import Dict, List, Optional
+
+
+class PreviousBuild:
+    def __init__(self, name: str,
+                 project_archive_url: Optional[str],
+                 project_relative_path_in_archive: Optional[str],
+                 packaged_src_url: Optional[str],
+                 contract_name: Optional[str],
+                 expected_code_hashes: Dict[str, str],
+                 docker_image: str) -> None:
+        self.name = name
+        self.project_zip_url = project_archive_url
+        self.project_relative_path_in_archive = project_relative_path_in_archive
+        self.packaged_src_url = packaged_src_url
+        self.contract_name = contract_name
+        self.expected_code_hashs = expected_code_hashes
+        self.docker_image = docker_image
+
+
+previous_builds: List[PreviousBuild] = [
+    PreviousBuild(
+        name="a.1",
+        project_archive_url="https://github.com/multiversx/mx-reproducible-contract-build-example-sc/archive/refs/tags/v0.1.5.zip",
+        project_relative_path_in_archive=None,
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "adder": "58c6e78f40bd6ccc30d8a01f952b34a13ebfdad796a2526678be17c5d7820174"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="a.2",
+        project_archive_url="https://github.com/multiversx/mx-reproducible-contract-build-example-sc/archive/refs/tags/v0.1.5.zip",
+        project_relative_path_in_archive=None,
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "adder": "58c6e78f40bd6ccc30d8a01f952b34a13ebfdad796a2526678be17c5d7820174"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="a.3",
+        project_archive_url="https://github.com/multiversx/mx-reproducible-contract-build-example-sc/archive/refs/tags/v0.1.5.zip",
+        project_relative_path_in_archive=None,
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "adder": "58c6e78f40bd6ccc30d8a01f952b34a13ebfdad796a2526678be17c5d7820174"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="b.1",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/tags/v1.5.4-metabonding-unbond.zip",
+        project_relative_path_in_archive="mx-exchange-sc-1.5.4-metabonding-unbond",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "metabonding-staking": "4a9b2afa13eca738b1804c48b82a961afd67adcbbf2aa518052fa124ac060bea"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="b.2",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/tags/v1.5.4-metabonding-unbond.zip",
+        project_relative_path_in_archive="mx-exchange-sc-1.5.4-metabonding-unbond",
+        packaged_src_url=None,
+        contract_name="metabonding-staking",
+        expected_code_hashes={
+            "metabonding-staking": "4a9b2afa13eca738b1804c48b82a961afd67adcbbf2aa518052fa124ac060bea"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="b.3",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/tags/v1.5.4-metabonding-unbond.zip",
+        project_relative_path_in_archive="mx-exchange-sc-1.5.4-metabonding-unbond",
+        packaged_src_url=None,
+        contract_name="metabonding-staking",
+        expected_code_hashes={
+            "metabonding-staking": "4a9b2afa13eca738b1804c48b82a961afd67adcbbf2aa518052fa124ac060bea"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="c.1",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/heads/reproducible-v2.1.1-staking-upgrade.zip",
+        project_relative_path_in_archive="mx-exchange-sc-reproducible-v2.1.1-staking-upgrade",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "distribution": "17a30ad44291af84f6dbd84fdaf0a9a56ed7145d544c54fd74088bb544c4f98f",
+            "energy-factory": "241600c055df605cafd85b75d40b21316a6b35713485201b156d695b23c66a2f",
+            "energy-factory-mock": "83b2f26a52e3fe74953f2a8cfd81f169664a4e59dae4e5d5bb1d89956fd81d43",
+            "energy-update": "8523bf84ac56626c70c31342487445bf8123e3ef5f906dcb39e8b5f16c4145b7",
+            "factory": "df06465b651594605466e817bfe9d8d7c68eef0f87df4a8d3266bcfb1bef6d83",
+            "farm": "931ca233826ff9dacd889967365db1cde9ed8402eb553de2a3b9d58b6ff1098d",
+            "farm-staking": "6dc7c587b2cc4b177a192b709c092f3752b3dcf9ce1b484e69fe64dc333a9e0a",
+            "farm-staking-proxy": "56468a6ae726693a71edcf96cf44673466dd980412388e1e4b073a0b4ee592d7",
+            "farm-with-locked-rewards": "437b2a665e643b5885cf50ee865c467371ca6faa20a8ff14a4b626c775f49971",
+            "fees-collector": "c46767232cd8551f8b0f4aa94dc419ddefc13eaaa5aa4b422749a300621149f3",
+            "governance": "959388eadaf71ff106252c601ae2767a5c62d7bd0ab119381c28dc679975685e",
+            "governance-v2": "786a6cf08f1d961814ebb062f149c9a943d39d7db93d8f53aa1fc42b8e652f49",
+            "lkmex-transfer": "995311e0dbd75ddc51a5c0c71ab896245c996b9b3993d3118a153bfb5531e123",
+            "locked-token-wrapper": "f9ee63d96163e3fac52a164c76d91c85fd77968393a50d4a96a7080e648d0a6c",
+            "metabonding-staking": "f508c5643b3d5f5e79b68762a9ca9e247c753acd305a29009328c5ec5d153bdd",
+            "pair": "f3f08ebd758fada871c113c18017d9761f157d00b19c4d3beaba530e6c53afc2",
+            "pair-mock": "a54495375db964cf924391433605d602940174d4d28111b89b8689564d90e662",
+            "pause-all": "2ad8aa911555b41e397541eb46cd1a7fa87186146f8c2b295e3916303833f3cd",
+            "price-discovery": "6df095b15272b189c2e7b3628a21e17c1a6b26e5ed03e9a7bddac61be29d162f",
+            "proxy-deployer": "5108e7419546872d235f0b7db5e01c5d04fec243bfa599c666629ead13bab0aa",
+            "proxy_dex": "988dd8b632e1b4bb9b43e5636ef4c363dd4066186f64f6f783f9cd043aa906c1",
+            "router": "c21ab56ef24b0719c101677170557e5aa61e1d17c1052ed7b2290cb26a5bdcd6",
+            "simple-lock": "303290b7a08b091c29315dd6979c1f745fc05467467d7de64e252592074890a7",
+            "simple-lock-whitelist": "c576c6106234e5f7978efb1885afe36c5d6da6a13c12b459fd7fe95967646d13",
+            "token-unstake": "463e49892f64726450d0df5ab4ba26559ad882525ce5e93173a26fde8437266e",
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="c.2",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/heads/reproducible-v2.0-rc6.zip",
+        project_relative_path_in_archive="mx-exchange-sc-reproducible-v2.0-rc6",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "distribution": "17a30ad44291af84f6dbd84fdaf0a9a56ed7145d544c54fd74088bb544c4f98f",
+            "energy-factory": "62d60c8dec649614dd9cf04fb20b884c7658b12759fa14bf7e9c7be3880a5edd",
+            "energy-factory-mock": "83b2f26a52e3fe74953f2a8cfd81f169664a4e59dae4e5d5bb1d89956fd81d43",
+            "energy-update": "8523bf84ac56626c70c31342487445bf8123e3ef5f906dcb39e8b5f16c4145b7",
+            "factory": "df06465b651594605466e817bfe9d8d7c68eef0f87df4a8d3266bcfb1bef6d83",
+            "farm": "69f95b5f9a4d5b6bb101d5d2cf7495264a4d04de2b36653e0c8088cf6fad492a",
+            "farm-staking": "ca0a8ceed8b8807b0fb078153c15167a3a235a61a76edc5023dfcacae0446125",
+            "farm-staking-proxy": "56468a6ae726693a71edcf96cf44673466dd980412388e1e4b073a0b4ee592d7",
+            "farm-with-locked-rewards": "c18d75ea788ece457788ad8849722a42dd4a12e6e23ab87f0cdffcc0116b61be",
+            "fees-collector": "c46767232cd8551f8b0f4aa94dc419ddefc13eaaa5aa4b422749a300621149f3",
+            "governance": "959388eadaf71ff106252c601ae2767a5c62d7bd0ab119381c28dc679975685e",
+            "governance-v2": "786a6cf08f1d961814ebb062f149c9a943d39d7db93d8f53aa1fc42b8e652f49",
+            "lkmex-transfer": "995311e0dbd75ddc51a5c0c71ab896245c996b9b3993d3118a153bfb5531e123",
+            "locked-token-wrapper": "f9ee63d96163e3fac52a164c76d91c85fd77968393a50d4a96a7080e648d0a6c",
+            "metabonding-staking": "f508c5643b3d5f5e79b68762a9ca9e247c753acd305a29009328c5ec5d153bdd",
+            "pair": "23ce1e8910c105410b4a417153e4b38c550ab78b38b899ea786f0c78500caf21",
+            "pair-mock": "a54495375db964cf924391433605d602940174d4d28111b89b8689564d90e662",
+            "pause-all": "2ad8aa911555b41e397541eb46cd1a7fa87186146f8c2b295e3916303833f3cd",
+            "price-discovery": "6df095b15272b189c2e7b3628a21e17c1a6b26e5ed03e9a7bddac61be29d162f",
+            "proxy-deployer": "5108e7419546872d235f0b7db5e01c5d04fec243bfa599c666629ead13bab0aa",
+            "proxy_dex": "988dd8b632e1b4bb9b43e5636ef4c363dd4066186f64f6f783f9cd043aa906c1",
+            "router": "8429d332fb62b557b3549d3f509a55d6aff8638f53a5ee876358a831107102cf",
+            "simple-lock": "303290b7a08b091c29315dd6979c1f745fc05467467d7de64e252592074890a7",
+            "simple-lock-whitelist": "c576c6106234e5f7978efb1885afe36c5d6da6a13c12b459fd7fe95967646d13",
+            "token-unstake": "463e49892f64726450d0df5ab4ba26559ad882525ce5e93173a26fde8437266e",
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="c.3",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/heads/reproducible-v2.1.3-price-discovery-comp-upgrade.zip",
+        project_relative_path_in_archive="mx-exchange-sc-reproducible-v2.1.3-price-discovery-comp-upgrade",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "distribution": "c8f6a78ca4007608905484952c88b680afe450203ca89a9e176ff36472eb4e3c",
+            "energy-factory": "1d444aaae54ab41c04ecf6147cfba16b03e5841382d69c65decb5fbd3bef6b25",
+            "energy-factory-mock": "a55835cd6992f0c02331ee1b8a21b3163c0efc1a8c1c3fdb1b5e34944a358d66",
+            "energy-update": "5ecde1bde66e1ccc10ac4bf8dcabfabf0d314ecaac51c72c3a19037256557885",
+            "factory": "3bcee411030c9426500178f1e92b3a1d7c31a7ed2bbb29ab05d15a4eaac3a955",
+            "farm": "4029cd4df87f2be4b7d1ed96161c9c3ab6fa44c090a574de4e6f1926ff302ea0",
+            "farm-staking": "89833609549b085f258b8fac6272014d874918883cf5643b071fb097993cdf03",
+            "farm-staking-proxy": "afe66cd648e293a98939af01a6b75180f0545ac3049ef26dfd6cfcdc7fcea51c",
+            "farm-with-locked-rewards": "c1dcd37f29dbc5a810ef1893c07cd3d7af765cb5d7b0c7ac92f5a601df73e033",
+            "fees-collector": "44a90c28bf35386cd533d22046243e02dc38cec00db948ef0c85392779c20593",
+            "governance": "956d520e05e97327ce2b8d05872a758c0e88ddce15a298b3fb8b7e0cf4a5ef1c",
+            "governance-v2": "995add2c509c29f4a8f875019f46831a0f5702fa21ea7a69e6fdad19bb6fda04",
+            "lkmex-transfer": "1c776af3ec771aba18c1cb2bb567a583ed179d91c8765bfbdc2dd4ddcca65790",
+            "locked-token-wrapper": "086a9baf3d89a54c2fccd066e36872d75406ac30ff1ed7c5ac9aae3a98b83284",
+            "metabonding-staking": "c2c5bbed7f35767315c574dedbabdfbd5f18bf6cd2a561e3df08fc46637ef1a8",
+            "pair": "c5c373155de76e6dfa040386947459d8cbdb4e7cc28d3dfe907922032a05e626",
+            "pair-mock": "7a631dbc9e2ba07932c21d923292234110859d2ce5335851f0265aeaa37b7687",
+            "pause-all": "2ad8aa911555b41e397541eb46cd1a7fa87186146f8c2b295e3916303833f3cd",
+            "price-discovery": "96b51ec9df3eb7a8e72f297aac2c8e4e609e39ac5a5f6d861c0819d010b87fde",
+            "proxy-deployer": "17e225e07b2ec759c86d70f6b61342f603135ac399b36bc48acab89f0bcfa483",
+            "proxy_dex": "3cac5e915b9c8f8dfa711b1f4b1cf213380660cbd0afe3695cc73d4989abe301",
+            "router": "5383bf12ad1ff9134782bd9aa9638bd16260ae7800434d01f853117e3db15c42",
+            "simple-lock": "4f2747e6952b0e0aaa275e57dbd87afe63b1caf353ba25ff002b1a85185f3927",
+            "simple-lock-whitelist": "3bc3cecbee78958e65efdaa077974d95d743d962254788d9280839362dc4da8b",
+            "token-unstake": "2b0f59073bd697d75ec2009a3bf3c350b74ff9b10d6a7bfe1e13f653732ddb1a",
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="c.4",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/heads/reproducible-v2.1.4-locked-token-wrapper.zip",
+        project_relative_path_in_archive="mx-exchange-sc-reproducible-v2.1.4-locked-token-wrapper",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "distribution": "51c9b6961443e67429ff6206fbb687427f8de739b50f02fb570269569e2c825d",
+            "energy-factory": "04483a0014d8c633d3966b38a96f2ea85d462cdde84cc3f0ee9ed28932c392ec",
+            "energy-factory-mock": "e5e95496bbfad534764eb67b3424ccae648353b39f89e41ba6874af6012a059f",
+            "energy-update": "31fec2ec88c778bb7157519b8f5757ce3aefc8334c7c93834f5c4e1d667bf4b5",
+            "factory": "91ef660172515fa6c5985f5cea06e96d9dfaae672e17a3cad6b2f4ad82ff2f0e",
+            "farm": "b406b586b8124a6cb577b91cf970b5acdfee41bbe5e21b87201a27a2f9772fb7",
+            "farm-staking": "7915b8e7c96f748afdd1a03a53d9c5377b1b11fcd59d4e6070094a5a0d7bff31",
+            "farm-staking-proxy": "99ad18a0bb49ab45ee5a860ebab10dc964796fd0218752bca38b5666c916c0a2",
+            "farm-with-locked-rewards": "a79baa1470a6b6232de6279417da046e753f7b9a4b9ae0e7e74f4f62da80a608",
+            "fees-collector": "fb4f1f63a5bd33184afde0241cb69b9e9d172ed936263d688c65ab96a7fd2d0c",
+            "governance": "e38189852ed794a6bd408c1147f90b4c47a9c6381c3a84b1b378ab6bfc9f74aa",
+            "governance-v2": "192570f6866fd109371580f04a1ef7553a98c5603ebd1afd55a42f983c03df3c",
+            "lkmex-transfer": "f850f9c7f70d3e198fa08e0d64538456b8e8ccdd6a5b8929f7faedd7cca85413",
+            "locked-token-wrapper": "256d7144713e6875eacde2aaefdf222895bf024f4ab2ea4c7dfb02e60d1efba3",
+            "metabonding-staking": "5cbcaaa8821db2a902477bce67a18a6f238f933863dded4c66bc5a5c9677dda7",
+            "pair": "dfb32db0afeb85bdf7bcc02d823a818bf27ce217513ecf6c92f5ccb25425a191",
+            "pair-mock": "a54495375db964cf924391433605d602940174d4d28111b89b8689564d90e662",
+            "pause-all": "2ad8aa911555b41e397541eb46cd1a7fa87186146f8c2b295e3916303833f3cd",
+            "price-discovery": "23deb3a6515a1a524fae6fb03613c042e2225d253da1e04532c66544167ac353",
+            "proxy-deployer": "9224eb8803a2aba700ec24ad8447ebc55010cb0c200cc55042d9b97dadc0668b",
+            "proxy_dex": "504f267a114cb46a6f3ba873dcfde43bd92d46fec61c830d45dfda2e368f52dc",
+            "router": "0a1ce2edc277cd36098e0a44aab618ef30a048db60eb9c67bac251fb43b54aa6",
+            "simple-lock": "74413279b467b72df4086efecfa0a773de284bfade1d9000106d13d47441daff",
+            "simple-lock-whitelist": "b8f14e78635ad3894cb78f7d24302d17ee2059b353d1017e4b84f3beef2abc1a",
+            "token-unstake": "3059ffec6f44259b8f2be56b9e1c67c72342f93c0c6f4b5cadc24364f2ee95e7",
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="c.5",
+        project_archive_url="https://github.com/multiversx/mx-exchange-sc/archive/refs/heads/reproducible-v2.1.6-energy-factory-convert-for-scs.zip",
+        project_relative_path_in_archive="mx-exchange-sc-reproducible-v2.1.6-energy-factory-convert-for-scs",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "energy-factory": "529fd987e7702b90044757073f36024d24cbe5cc8810d5abe93c6c5176a0ec53",
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    ),
+    PreviousBuild(
+        name="d.1",
+        project_archive_url="https://github.com/multiversx/mx-nft-marketplace-sc/archive/refs/heads/reproducible-v2.0.1.zip",
+        project_relative_path_in_archive="mx-nft-marketplace-sc-reproducible-v2.0.1",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "esdt-nft-marketplace": "aed8f014c914d2910cbb68b61adb757f8dbc8385842e717127482e1a66828bbe",
+            "seller-contract-mock": "d3f42ae77ec60878ba62146a4209ef08a9400aecf083c96888ede316069985c0"
+        },
+        docker_image="multiversx/sdk-rust-contract-builder:v4.0.3"
+    ),
+    PreviousBuild(
+        name="e.1",
+        project_archive_url="https://github.com/multiversx/mx-metabonding-sc/archive/refs/heads/reproducible-v1.1.1.zip",
+        project_relative_path_in_archive="mx-metabonding-sc-reproducible-v1.1.1",
+        packaged_src_url=None,
+        contract_name=None,
+        expected_code_hashes={
+            "metabonding": "897b19e1990f7c487c99c12f50722febe1ee4468bcd3a7405641966dfff2791d"
+        },
+        docker_image="sdk-rust-contract-builder:next"
+    )
+]
diff --git a/integration_tests/shared.py b/integration_tests/shared.py
new file mode 100644
index 0000000..964aaf2
--- /dev/null
+++ b/integration_tests/shared.py
@@ -0,0 +1,77 @@
+import os
+import shutil
+import subprocess
+import urllib.request
+from pathlib import Path
+from typing import List, Optional
+
+from integration_tests.config import (CARGO_TARGET_DIR, DOWNLOADS_FOLDER,
+                                      EXTRACTED_FOLDER, RUST_GIT,
+                                      RUST_REGISTRY, RUST_TMP)
+
+
+def download_project_repository(zip_archive_url: str, name: str) -> Path:
+    DOWNLOADS_FOLDER.mkdir(parents=True, exist_ok=True)
+    EXTRACTED_FOLDER.mkdir(parents=True, exist_ok=True)
+
+    download_to_path = DOWNLOADS_FOLDER / f"{name}.zip"
+    extract_to_path = EXTRACTED_FOLDER / name
+
+    urllib.request.urlretrieve(zip_archive_url, download_to_path)
+    shutil.rmtree(extract_to_path, ignore_errors=True)
+    shutil.unpack_archive(download_to_path, extract_to_path)
+    return extract_to_path
+
+
+def download_packaged_src(json_url: str, name: str) -> Path:
+    downloaded_packaged_src = DOWNLOADS_FOLDER / f"{name}.source.json"
+    urllib.request.urlretrieve(json_url, downloaded_packaged_src)
+    return downloaded_packaged_src
+
+
+def run_docker(
+    project_path: Optional[Path],
+    packaged_src_path: Optional[Path],
+    contract_name: Optional[str],
+    image: str,
+    output_folder: Path,
+):
+    CARGO_TARGET_DIR.mkdir(parents=True, exist_ok=True)
+    RUST_REGISTRY.mkdir(parents=True, exist_ok=True)
+    RUST_GIT.mkdir(parents=True, exist_ok=True)
+    RUST_TMP.mkdir(parents=True, exist_ok=True)
+
+    docker_mount_args: List[str] = ["--volume", f"{output_folder}:/output"]
+
+    if project_path:
+        docker_mount_args.extend(["--volume", f"{project_path}:/project"])
+
+    if packaged_src_path:
+        docker_mount_args.extend(["--volume", f"{packaged_src_path}:/packaged-src.json"])
+
+    docker_mount_args += ["--volume", f"{CARGO_TARGET_DIR}:/rust/cargo-target-dir"]
+    docker_mount_args += ["--volume", f"{RUST_REGISTRY}:/rust/registry"]
+    docker_mount_args += ["--volume", f"{RUST_GIT}:/rust/git"]
+    docker_mount_args += ["--volume", f"{RUST_TMP}:/rust/tmp"]
+
+    docker_args = ["docker", "run"]
+    docker_args += docker_mount_args
+    docker_args += ["--user", f"{str(os.getuid())}:{str(os.getgid())}"]
+    docker_args += ["--rm", image]
+
+    entrypoint_args: List[str] = []
+
+    if project_path:
+        entrypoint_args.extend(["--project", "project"])
+
+    if packaged_src_path:
+        entrypoint_args.extend(["--packaged-src", "packaged-src.json"])
+
+    if contract_name:
+        entrypoint_args.extend(["--contract", contract_name])
+
+    args = docker_args + entrypoint_args
+    result = subprocess.run(args)
+    returncode = result.returncode
+    if returncode != 0:
+        raise Exception(f"Docker exited with return code {returncode}.")
diff --git a/integration_tests/test_previous_builds_are_reproducible.py b/integration_tests/test_previous_builds_are_reproducible.py
new file mode 100644
index 0000000..7f37b54
--- /dev/null
+++ b/integration_tests/test_previous_builds_are_reproducible.py
@@ -0,0 +1,72 @@
+import json
+import shutil
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from integration_tests.config import (CARGO_TARGET_DIR, DOWNLOADS_FOLDER,
+                                      EXTRACTED_FOLDER, PARENT_OUTPUT_FOLDER)
+from integration_tests.previous_builds import PreviousBuild, previous_builds
+from integration_tests.shared import (download_packaged_src,
+                                      download_project_repository, run_docker)
+
+
+def main(cli_args: List[str]):
+    parser = ArgumentParser()
+    parser.add_argument("--selected-builds", nargs='+')
+    parsed_args = parser.parse_args(cli_args)
+    selected_builds = parsed_args.selected_builds
+
+    shutil.rmtree(DOWNLOADS_FOLDER, ignore_errors=True)
+    shutil.rmtree(EXTRACTED_FOLDER, ignore_errors=True)
+    shutil.rmtree(PARENT_OUTPUT_FOLDER, ignore_errors=True)
+
+    DOWNLOADS_FOLDER.mkdir(parents=True, exist_ok=True)
+    EXTRACTED_FOLDER.mkdir(parents=True, exist_ok=True)
+    CARGO_TARGET_DIR.mkdir(parents=True, exist_ok=True)
+
+    for build in previous_builds:
+        if not build.name in selected_builds:
+            continue
+
+        print("Reproducing build", build.name, "...")
+
+        project_path, packaged_src_path = fetch_source_code(build)
+        output_folder = PARENT_OUTPUT_FOLDER / build.name
+        output_folder.mkdir(parents=True, exist_ok=True)
+
+        if project_path and build.project_relative_path_in_archive:
+            project_path = project_path / build.project_relative_path_in_archive
+
+        run_docker(project_path, packaged_src_path, build.contract_name, build.docker_image, output_folder)
+        check_code_hashes(build, output_folder)
+
+
+def fetch_source_code(build: PreviousBuild) -> Tuple[Optional[Path], Optional[Path]]:
+    print("Fetching source code for", build.name, "...")
+
+    if build.project_zip_url:
+        return download_project_repository(build.project_zip_url, build.name), None
+    if build.packaged_src_url:
+        return None, download_packaged_src(build.packaged_src_url, build.name)
+
+    raise Exception("No source code provided")
+
+
+def check_code_hashes(build: PreviousBuild, output_folder: Path):
+    artifacts_path = output_folder / "artifacts.json"
+    artifacts_json = artifacts_path.read_text()
+    artifacts = json.loads(artifacts_json)
+
+    for contract_name, expected_code_hash in build.expected_code_hashs.items():
+        print(f"For contract {contract_name}, expecting code hash {expected_code_hash} ...")
+
+        codehash = artifacts[contract_name]["codehash"]
+        if codehash != expected_code_hash:
+            raise Exception(f"{build.name}: codehash mismatch for contract {contract_name}! Expected {expected_code_hash}, got {codehash}")
+        print("OK, codehashes match:", codehash)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/integration_tests/test_project_folder_and_packaged_src_are_equivalent.py b/integration_tests/test_project_folder_and_packaged_src_are_equivalent.py
new file mode 100644
index 0000000..48f2245
--- /dev/null
+++ b/integration_tests/test_project_folder_and_packaged_src_are_equivalent.py
@@ -0,0 +1,58 @@
+import shutil
+import sys
+from typing import List
+
+from integration_tests.config import PARENT_OUTPUT_FOLDER
+from integration_tests.shared import download_project_repository, run_docker
+
+
+def main(cli_args: List[str]):
+    project_path = download_project_repository("https://github.com/multiversx/mx-exchange-sc/archive/refs/heads/main.zip", "mx-exchange-sc-main")
+    output_using_project = PARENT_OUTPUT_FOLDER / "using-project"
+    output_using_packaged_src = PARENT_OUTPUT_FOLDER / "using-packaged-src"
+
+    shutil.rmtree(output_using_project, ignore_errors=True)
+    shutil.rmtree(output_using_packaged_src, ignore_errors=True)
+
+    output_using_project.mkdir(parents=True)
+    output_using_packaged_src.mkdir(parents=True)
+
+    contracts = ['distribution', 'energy-factory', 'energy-update', 'factory', 'farm', 'farm-staking', 'farm-staking-proxy', 'farm-with-locked-rewards', 'fees-collector', 'governance', 'governance-v2', 'lkmex-transfer', 'locked-token-wrapper', 'metabonding-staking', 'pair', 'pause-all', 'price-discovery', 'proxy-deployer', 'proxy_dex', 'router', 'simple-lock', 'simple-lock-whitelist', 'token-unstake']
+
+    for contract in contracts:
+        run_docker(
+            project_path=project_path,
+            packaged_src_path=None,
+            contract_name=contract,
+            image="sdk-rust-contract-builder:next",
+            output_folder=output_using_project
+        )
+
+        packaged_src_path = output_using_project / f"{contract}/{contract}-0.0.0.source.json"
+
+        run_docker(
+            project_path=None,
+            packaged_src_path=packaged_src_path,
+            contract_name=contract,
+            image="sdk-rust-contract-builder:next",
+            output_folder=output_using_packaged_src
+        )
+
+        # Check that output folders are identical
+        using_project_output_files = sorted((output_using_project / contract).rglob("*"))
+        using_packaged_src_output_files = sorted((output_using_packaged_src / contract).rglob("*"))
+
+        assert len(using_project_output_files) == len(using_packaged_src_output_files)
+
+        for index, file in enumerate(using_project_output_files):
+            if not file.is_file() or file.suffix == ".zip":
+                continue
+            using_project_file_content = file.read_bytes()
+            using_packaged_src_file_content = using_packaged_src_output_files[index].read_bytes()
+
+            if using_project_file_content != using_packaged_src_file_content:
+                raise Exception(f"Files differ ({contract}): {file.name}")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/multiversx_sdk_rust_contract_builder/build_outcome.py b/multiversx_sdk_rust_contract_builder/build_outcome.py
index 42154f6..3736a40 100644
--- a/multiversx_sdk_rust_contract_builder/build_outcome.py
+++ b/multiversx_sdk_rust_contract_builder/build_outcome.py
@@ -9,11 +9,12 @@
 
 
 class BuildOutcome:
-    def __init__(self):
+    def __init__(self, context: str):
+        self.context = context
         self.contracts: Dict[str, BuildOutcomeEntry] = dict()
 
-    def gather_artifacts(self, contract_name: str, build_directory: Path, output_subdirectory: Path):
-        self.contracts[contract_name] = BuildOutcomeEntry.from_directories(build_directory, output_subdirectory)
+    def gather_artifacts(self, contract_name: str, build_folder: Path, output_subfolder: Path):
+        self.contracts[contract_name] = BuildOutcomeEntry.from_folders(build_folder, output_subfolder)
 
     def get_entry(self, contract_name: str) -> 'BuildOutcomeEntry':
         return self.contracts[contract_name]
@@ -25,7 +26,7 @@ def save_to_file(self, file: Path):
             json.dump(data, f, indent=4)
 
     def to_dict(self) -> Dict[str, Any]:
-        data: Dict[str, Any] = dict()
+        data: Dict[str, Any] = {"context": self.context}
 
         for key, value in self.contracts.items():
             data[key] = value.to_dict()
@@ -41,14 +42,11 @@ def __init__(self) -> None:
         self.artifacts = BunchOfBuildArtifacts()
 
     @classmethod
-    def from_directories(cls, build_directory: Path, output_directory: Path) -> 'BuildOutcomeEntry':
+    def from_folders(cls, build_folder: Path, output_folder: Path) -> 'BuildOutcomeEntry':
         entry = BuildOutcomeEntry()
-        _, entry.version = get_contract_name_and_version(build_directory)
-
-        with open(find_file_in_folder(output_directory, "*.codehash.txt")) as file:
-            entry.codehash = file.read()
-
-        entry.artifacts = BunchOfBuildArtifacts.from_output_directory(output_directory)
+        _, entry.version = get_contract_name_and_version(build_folder)
+        entry.codehash = find_file_in_folder(output_folder, "*.codehash.txt").read_text()
+        entry.artifacts = BunchOfBuildArtifacts.from_output_folder(output_folder)
         return entry
 
     def to_dict(self) -> Dict[str, Any]:
@@ -67,19 +65,16 @@ def __init__(self) -> None:
         self.abi = BuildArtifact(Path(""))
         self.imports = BuildArtifact(Path(""))
         self.src_package = BuildArtifact(Path(""))
-        self.src_archive = BuildArtifact(Path(""))
         self.output_archive = BuildArtifact(Path(""))
 
     @classmethod
-    def from_output_directory(cls, output_directory: Path) -> 'BunchOfBuildArtifacts':
+    def from_output_folder(cls, output_folder: Path) -> 'BunchOfBuildArtifacts':
         artifacts = BunchOfBuildArtifacts()
-        artifacts.bytecode = BuildArtifact.find_in_output("*.wasm", output_directory)
-        artifacts.text = BuildArtifact.find_in_output("*.wat", output_directory)
-        artifacts.abi = BuildArtifact.find_in_output("*.abi.json", output_directory)
-        artifacts.imports = BuildArtifact.find_in_output("*.imports.json", output_directory)
-        artifacts.src_package = BuildArtifact.find_in_output("*.source.json", output_directory)
-        artifacts.src_archive = BuildArtifact.find_in_output("*-src-*.zip", output_directory)
-        artifacts.src_archive = BuildArtifact.find_in_output("*-output-*.zip", output_directory)
+        artifacts.bytecode = BuildArtifact.find_in_output("*.wasm", output_folder)
+        artifacts.text = BuildArtifact.find_in_output("*.wat", output_folder)
+        artifacts.abi = BuildArtifact.find_in_output("*.abi.json", output_folder)
+        artifacts.imports = BuildArtifact.find_in_output("*.imports.json", output_folder)
+        artifacts.src_package = BuildArtifact.find_in_output("*.source.json", output_folder)
 
         return artifacts
 
@@ -90,7 +85,6 @@ def to_dict(self) -> Dict[str, str]:
             "abi": self.abi.path.name,
             "imports": self.imports.path.name,
             "srcPackage": self.src_package.path.name,
-            "srcArchive": self.src_archive.path.name,
             "outputArchive": self.output_archive.path.name
         }
 
@@ -100,8 +94,8 @@ def __init__(self, path: Path) -> None:
         self.path = path
 
     @classmethod
-    def find_in_output(cls, name_pattern: str, output_directory: Path) -> 'BuildArtifact':
-        path = find_file_in_folder(output_directory, name_pattern)
+    def find_in_output(cls, name_pattern: str, output_folder: Path) -> 'BuildArtifact':
+        path = find_file_in_folder(output_folder, name_pattern)
         return BuildArtifact(path)
 
     def read(self) -> bytes:
diff --git a/multiversx_sdk_rust_contract_builder/builder.py b/multiversx_sdk_rust_contract_builder/builder.py
index 9e58bf5..ab014ef 100644
--- a/multiversx_sdk_rust_contract_builder/builder.py
+++ b/multiversx_sdk_rust_contract_builder/builder.py
@@ -1,106 +1,109 @@
 import logging
-import os
 import shutil
 import subprocess
 from pathlib import Path
-from typing import List, Union
+from typing import List, Optional
 
+from multiversx_sdk_rust_contract_builder import cargo_toml, source_code
 from multiversx_sdk_rust_contract_builder.build_outcome import BuildOutcome
 from multiversx_sdk_rust_contract_builder.cargo_toml import (
-    get_contract_name_and_version, promote_cargo_lock_to_contract_directory)
+    get_contract_name_and_version, promote_cargo_lock_to_contract_folder)
 from multiversx_sdk_rust_contract_builder.codehash import \
     generate_code_hash_artifact
 from multiversx_sdk_rust_contract_builder.constants import (
-    HARDCODED_BUILD_DIRECTORY, MAX_OUTPUT_ARTIFACTS_ARCHIVE_SIZE,
-    MAX_SOURCE_CODE_ARCHIVE_SIZE)
+    CONTRACT_CONFIG_FILENAME, HARDCODED_BUILD_FOLDER,
+    MAX_OUTPUT_ARTIFACTS_ARCHIVE_SIZE, MAX_PACKAGED_SOURCE_CODE_SIZE,
+    OLD_CONTRACT_CONFIG_FILENAME)
+from multiversx_sdk_rust_contract_builder.errors import ErrKnown
 from multiversx_sdk_rust_contract_builder.filesystem import (
-    archive_directory, find_file_in_folder)
+    archive_folder, find_file_in_folder)
 from multiversx_sdk_rust_contract_builder.packaged_source_code import \
     PackagedSourceCode
-from multiversx_sdk_rust_contract_builder.source_code import \
-    is_source_code_file
 from multiversx_sdk_rust_contract_builder.wabt import generate_wabt_artifacts
 
 
 def build_project(
-        project_path: Path,
-        parent_output_directory: Path,
-        specific_contract: Union[Path, None],
+        project_folder: Path,
+        parent_output_folder: Path,
+        specific_contract: Optional[str],
         cargo_target_dir: Path,
-        no_wasm_opt: bool) -> BuildOutcome:
-    project_path = project_path.expanduser().resolve()
-    parent_output_directory = parent_output_directory.expanduser().resolve()
+        no_wasm_opt: bool,
+        context: str) -> BuildOutcome:
+    project_folder = project_folder.expanduser().resolve()
+    parent_output_folder = parent_output_folder.expanduser().resolve()
     cargo_target_dir = cargo_target_dir.expanduser().resolve()
 
-    outcome = BuildOutcome()
-    contracts_directories = get_contracts_directories(project_path)
+    outcome = BuildOutcome(context)
+    contracts_folders = get_contracts_folders(project_folder)
 
     # We copy the whole project folder to the build path, to ensure that all local dependencies are available.
-    project_within_build_directory = copy_project_directory_to_build_directory(project_path)
+    project_within_build_folder = copy_project_folder_to_build_folder(project_folder)
 
-    for contract_directory in sorted(contracts_directories):
-        contract_name, contract_version = get_contract_name_and_version(contract_directory)
-        logging.info(f"Contract = {contract_name}, version = {contract_version}")
-
-        output_subdirectory = parent_output_directory / f"{contract_name}"
-        output_subdirectory.mkdir(parents=True, exist_ok=True)
+    cargo_toml.remove_dev_dependencies_sections_from_all(project_within_build_folder)
+    source_code.replace_all_test_content_with_noop(project_within_build_folder)
 
-        relative_contract_directory = contract_directory.relative_to(project_path)
-        build_directory = project_within_build_directory / relative_contract_directory
+    for contract_folder in sorted(contracts_folders):
+        contract_name, contract_version = get_contract_name_and_version(contract_folder)
+        logging.info(f"Contract = {contract_name}, version = {contract_version}")
 
         if specific_contract and contract_name != specific_contract:
             logging.info(f"Skipping {contract_name}.")
             continue
 
-        # Clean directory - useful if it contains externally-generated build artifacts
-        clean_contract(build_directory)
-        build_contract(build_directory, output_subdirectory, cargo_target_dir, no_wasm_opt)
+        output_subfolder = parent_output_folder / f"{contract_name}"
+        output_subfolder.mkdir(parents=True, exist_ok=True)
+
+        relative_contract_folder = contract_folder.relative_to(project_folder)
+        contract_build_subfolder = project_within_build_folder / relative_contract_folder
+
+        # Clean folder - it may contain externally-generated build artifacts
+        clean_contract(contract_build_subfolder)
+        build_contract(contract_build_subfolder, output_subfolder, cargo_target_dir, no_wasm_opt)
 
         # We do not clean the "output" folder, since it will be included in one of the generated archives.
-        clean_contract(build_directory, clean_output=False)
+        clean_contract(contract_build_subfolder, clean_output=False)
 
-        promote_cargo_lock_to_contract_directory(build_directory, contract_directory)
+        promote_cargo_lock_to_contract_folder(contract_build_subfolder, contract_folder)
 
         # The archives are created after build, so that Cargo.lock files are included (if previously missing).
-        create_archives(contract_name, contract_version, build_directory, output_subdirectory)
-        create_packaged_source_code(contract_name, contract_version, build_directory, output_subdirectory)
+        create_archives(contract_name, contract_version, contract_build_subfolder, output_subfolder)
+        create_packaged_source_code(project_within_build_folder, contract_name, contract_version, contract_build_subfolder, output_subfolder)
 
-        outcome.gather_artifacts(contract_name, build_directory, output_subdirectory)
+        outcome.gather_artifacts(contract_name, contract_build_subfolder, output_subfolder)
 
     return outcome
 
 
-def get_contracts_directories(project_path: Path) -> List[Path]:
-    directories = [project_config_json.parent for project_config_json in project_path.glob("**/elrond.json")]
-    return sorted(directories)
+def get_contracts_folders(project_path: Path) -> List[Path]:
+    old_markers = list(project_path.glob(f"**/{OLD_CONTRACT_CONFIG_FILENAME}"))
+    new_markers = list(project_path.glob(f"**/{CONTRACT_CONFIG_FILENAME}"))
+    marker_files = old_markers + new_markers
+    folders = [marker_file.parent for marker_file in marker_files]
+    return sorted(folders)
 
 
-def copy_project_directory_to_build_directory(project_directory: Path):
-    shutil.rmtree(HARDCODED_BUILD_DIRECTORY, ignore_errors=True)
-    HARDCODED_BUILD_DIRECTORY.mkdir()
-    shutil.copytree(project_directory, HARDCODED_BUILD_DIRECTORY, dirs_exist_ok=True)
-    return HARDCODED_BUILD_DIRECTORY
+def copy_project_folder_to_build_folder(project_folder: Path):
+    shutil.rmtree(HARDCODED_BUILD_FOLDER, ignore_errors=True)
+    HARDCODED_BUILD_FOLDER.mkdir()
+    shutil.copytree(project_folder, HARDCODED_BUILD_FOLDER, dirs_exist_ok=True)
+    return HARDCODED_BUILD_FOLDER
 
 
-def clean_contract(directory: Path, clean_output: bool = True):
-    logging.info(f"Cleaning: {directory}")
+def clean_contract(folder: Path, clean_output: bool = True):
+    logging.info(f"Cleaning: {folder}")
 
-    # On a best-effort basis, remove directories that (usually) hold build artifacts
-    shutil.rmtree(directory / "wasm" / "target", ignore_errors=True)
-    shutil.rmtree(directory / "meta" / "target", ignore_errors=True)
+    # On a best-effort basis, remove folders that (usually) hold build artifacts
+    shutil.rmtree(folder / "wasm" / "target", ignore_errors=True)
+    shutil.rmtree(folder / "meta" / "target", ignore_errors=True)
 
     if clean_output:
-        shutil.rmtree(directory / "output", ignore_errors=True)
-
+        shutil.rmtree(folder / "output", ignore_errors=True)
 
-def build_contract(build_directory: Path, output_directory: Path, cargo_target_dir: Path, no_wasm_opt: bool):
-    cargo_output_directory = build_directory / "output"
-    meta_directory = build_directory / "meta"
-    cargo_lock = build_directory / "wasm" / "Cargo.lock"
 
-    # Best-effort on passing CARGO_TARGET_DIR: both as environment variable and as meta-crate parameter.
-    env = os.environ.copy()
-    env["CARGO_TARGET_DIR"] = str(cargo_target_dir)
+def build_contract(build_folder: Path, output_folder: Path, cargo_target_dir: Path, no_wasm_opt: bool):
+    cargo_output_folder = build_folder / "output"
+    meta_folder = build_folder / "meta"
+    cargo_lock = build_folder / "wasm" / "Cargo.lock"
 
     args = ["cargo", "run", "build"]
     args.extend(["--target-dir", str(cargo_target_dir)])
@@ -110,39 +113,37 @@ def build_contract(build_directory: Path, output_directory: Path, cargo_target_d
     args.extend(["--locked"] if cargo_lock.exists() else [])
 
     logging.info(f"Building: {args}")
-    return_code = subprocess.run(args, cwd=meta_directory, env=env).returncode
+    return_code = subprocess.run(args, cwd=meta_folder).returncode
     if return_code != 0:
-        exit(return_code)
+        raise ErrKnown(f"Failed to build contract {build_folder}. Return code: {return_code}.")
 
-    wasm_file = find_file_in_folder(cargo_output_directory, "*.wasm")
+    wasm_file = find_file_in_folder(cargo_output_folder, "*.wasm")
     generate_wabt_artifacts(wasm_file)
     generate_code_hash_artifact(wasm_file)
 
-    shutil.copytree(cargo_output_directory, output_directory, dirs_exist_ok=True)
+    shutil.copytree(cargo_output_folder, output_folder, dirs_exist_ok=True)
 
 
-def create_archives(contract_name: str, contract_version: str, input_directory: Path, output_directory: Path):
-    source_code_archive_file = output_directory / f"{contract_name}-src-{contract_version}.zip"
-    output_artifacts_archive_file = output_directory / f"{contract_name}-output-{contract_version}.zip"
+def create_archives(contract_name: str, contract_version: str, input_folder: Path, output_folder: Path):
+    output_artifacts_archive_file = output_folder / f"{contract_name}-output-{contract_version}.zip"
 
-    archive_directory(source_code_archive_file, input_directory, is_source_code_file)
-    archive_directory(output_artifacts_archive_file, input_directory / "output")
+    archive_folder(output_artifacts_archive_file, input_folder / "output")
 
-    size_of_source_code_archive = source_code_archive_file.stat().st_size
     size_of_output_artifacts_archive = output_artifacts_archive_file.stat().st_size
-
-    if size_of_source_code_archive > MAX_SOURCE_CODE_ARCHIVE_SIZE:
-        warn_file_too_large(source_code_archive_file, size_of_source_code_archive, MAX_SOURCE_CODE_ARCHIVE_SIZE)
     if size_of_output_artifacts_archive > MAX_OUTPUT_ARTIFACTS_ARCHIVE_SIZE:
         warn_file_too_large(output_artifacts_archive_file, size_of_output_artifacts_archive, MAX_OUTPUT_ARTIFACTS_ARCHIVE_SIZE)
 
 
-def warn_file_too_large(path: Path, size: int, max_size: int):
-    logging.warning(f"""File is too large (this might cause issues with using downstream applications, such as the contract build verification services): 
-file = {path}, size = {size}, maximum size = {max_size}""")
+def create_packaged_source_code(parent_project_folder: Path, contract_name: str, contract_version: str, contract_folder: Path, output_folder: Path):
+    package = PackagedSourceCode.from_filesystem(parent_project_folder, contract_folder)
+    package_path = output_folder / f"{contract_name}-{contract_version}.source.json"
+    package.save_to_file(package_path)
 
+    size_of_file = package_path.stat().st_size
+    if size_of_file > MAX_PACKAGED_SOURCE_CODE_SIZE:
+        warn_file_too_large(package_path, size_of_file, MAX_PACKAGED_SOURCE_CODE_SIZE)
 
-def create_packaged_source_code(contract_name: str, contract_version: str, input_directory: Path, output_directory: Path):
-    package = PackagedSourceCode.from_folder(input_directory)
-    package_path = output_directory / f"{contract_name}-{contract_version}.source.json"
-    package.save_to_file(package_path)
+
+def warn_file_too_large(path: Path, size: int, max_size: int):
+    logging.warning(f"""File is too large (this might cause issues with using downstream applications, such as the contract build verification services):
+file = {path}, size = {size}, maximum size = {max_size}""")
diff --git a/multiversx_sdk_rust_contract_builder/builder_test.py b/multiversx_sdk_rust_contract_builder/builder_test.py
index 88a89d9..3cda318 100644
--- a/multiversx_sdk_rust_contract_builder/builder_test.py
+++ b/multiversx_sdk_rust_contract_builder/builder_test.py
@@ -1,33 +1,60 @@
 from pathlib import Path
 
 from multiversx_sdk_rust_contract_builder import builder
+from multiversx_sdk_rust_contract_builder.packaged_source_code import \
+    PackagedSourceCode
 
+input_folder = Path("./testdata/input")
+expected_folder = Path("./testdata/expected")
+output_folder = Path("./testdata/output")
 
-def test_build_project():
+
+def test_build_project_adder():
     outcome = builder.build_project(
-        project_path=Path("./testdata/input"),
-        parent_output_directory=Path("./testdata/output"),
+        project_folder=input_folder / "adder",
+        parent_output_folder=output_folder,
         specific_contract=None,
         cargo_target_dir=Path("/tmp/cargo-target-dir"),
-        no_wasm_opt=False
+        no_wasm_opt=False,
+        context="test"
     )
 
-    actual_source = outcome.get_entry("adder").artifacts.src_package.read().decode()
+    actual_src_package = PackagedSourceCode.from_file(outcome.get_entry("adder").artifacts.src_package.path)
+    expected_src_package = PackagedSourceCode.from_file(expected_folder / "adder-1.2.3.source.json")
     actual_wat = outcome.get_entry("adder").artifacts.text.read().decode()
 
+    assert outcome.context == "test"
     assert outcome.get_entry("adder").version == "1.2.3"
     assert outcome.get_entry("adder").codehash == "58c6e78f40bd6ccc30d8a01f952b34a13ebfdad796a2526678be17c5d7820174"
-    assert actual_source == read_text_file(Path("./testdata/expected/adder-1.2.3.source.json")).strip()
-    assert actual_wat == read_text_file(Path("./testdata/expected/adder.wat"))
+    assert_equal_src_package(actual_src_package, expected_src_package)
+    assert actual_wat == (expected_folder / "adder.wat").read_text()
+
 
-    actual_source = outcome.get_entry("empty").artifacts.src_package.read().decode()
+def test_build_project_empty():
+    outcome = builder.build_project(
+        project_folder=input_folder / "empty",
+        parent_output_folder=output_folder,
+        specific_contract=None,
+        cargo_target_dir=Path("/tmp/cargo-target-dir"),
+        no_wasm_opt=False,
+        context="test"
+    )
+
+    actual_src_package = PackagedSourceCode.from_file(outcome.get_entry("empty").artifacts.src_package.path)
+    expected_src_package = PackagedSourceCode.from_file(expected_folder / "empty-4.5.6.source.json")
     actual_wat = outcome.get_entry("empty").artifacts.text.read().decode()
+
+    assert outcome.context == "test"
     assert outcome.get_entry("empty").version == "4.5.6"
     assert outcome.get_entry("empty").codehash == "20df405fa1733a22748c888f6c1571f2c12cc40a8b1de800e0fd105674b426a5"
-    assert actual_source == read_text_file(Path("./testdata/expected/empty-4.5.6.source.json")).strip()
-    assert actual_wat == read_text_file(Path("./testdata/expected/empty.wat"))
+    assert_equal_src_package(actual_src_package, expected_src_package)
+    assert actual_wat == (expected_folder / "empty.wat").read_text()
+
 
+def assert_equal_src_package(actual: PackagedSourceCode, expected: PackagedSourceCode):
+    assert actual.name == expected.name
+    assert actual.version == expected.version
 
-def read_text_file(path: Path) -> str:
-    with open(path, "r") as f:
-        return f.read()
+    for actual_entry, expected_entry in zip(actual.entries, expected.entries):
+        assert actual_entry.path == expected_entry.path, f"actual={actual_entry.path}, expected={expected_entry.path}"
+        assert actual_entry.content == expected_entry.content, f"content differs for {actual_entry.path}"
diff --git a/multiversx_sdk_rust_contract_builder/cargo_toml.py b/multiversx_sdk_rust_contract_builder/cargo_toml.py
index 964e2f0..cd1db9a 100644
--- a/multiversx_sdk_rust_contract_builder/cargo_toml.py
+++ b/multiversx_sdk_rust_contract_builder/cargo_toml.py
@@ -1,24 +1,47 @@
-
+import logging
 import shutil
 from pathlib import Path
 from typing import Tuple
 
+import tomlkit
+
+from multiversx_sdk_rust_contract_builder.filesystem import get_all_files
 
-def get_contract_name_and_version(contract_directory: Path) -> Tuple[str, str]:
-    # For simplicity and less dependencies installed in the Docker image, we do not rely on an external library
-    # to parse the metadata from Cargo.toml.
-    with open(contract_directory / "Cargo.toml") as file:
-        lines = file.readlines()
 
-    line_with_name = next((line for line in lines if line.startswith("name = ")), 'name = "untitled"')
-    line_with_version = next((line for line in lines if line.startswith("version = ")), 'version = "0.0.0"')
+def get_contract_name_and_version(contract_folder: Path) -> Tuple[str, str]:
+    file = contract_folder / "Cargo.toml"
+    toml = tomlkit.parse(file.read_text())
 
-    name = line_with_name.split("=")[1].strip().strip('"')
-    version = line_with_version.split("=")[1].strip().strip('"')
+    name = toml["package"]["name"]
+    version = toml["package"]["version"]
     return name, version
 
 
-def promote_cargo_lock_to_contract_directory(build_directory: Path, contract_directory: Path):
-    from_path = build_directory / "wasm" / "Cargo.lock"
-    to_path = contract_directory / "wasm" / "Cargo.lock"
+def promote_cargo_lock_to_contract_folder(build_folder: Path, contract_folder: Path):
+    from_path = build_folder / "wasm" / "Cargo.lock"
+    to_path = contract_folder / "wasm" / "Cargo.lock"
     shutil.copy(from_path, to_path)
+
+
+def remove_dev_dependencies_sections_from_all(folder: Path):
+    logging.info(f"remove_dev_dependencies_sections_from_all({folder})")
+
+    all_files = get_all_files(folder, lambda file: file.name == "Cargo.toml")
+    for file in all_files:
+        remove_dev_dependencies_sections(file)
+
+
+def remove_dev_dependencies_sections(file: Path):
+    # Workaround: if Cargo.toml contains [dev-dependencies] sections,
+    # then we'll attempt several times to remove them,
+    # because tomlkit does not properly handle a few special cases, such as:
+    # - https://github.com/multiversx/mx-exchange-sc/blob/v2.1-staking/dex/farm/Cargo.toml#L71
+    # - https://github.com/multiversx/mx-exchange-sc/blob/v2.1-staking/dex/farm/Cargo.toml#L84
+    while True:
+        toml = tomlkit.parse(file.read_text())
+
+        if "dev-dependencies" not in toml:
+            break
+
+        del toml["dev-dependencies"]
+        file.write_text(tomlkit.dumps(toml))
diff --git a/multiversx_sdk_rust_contract_builder/constants.py b/multiversx_sdk_rust_contract_builder/constants.py
index f8d884a..d49d522 100644
--- a/multiversx_sdk_rust_contract_builder/constants.py
+++ b/multiversx_sdk_rust_contract_builder/constants.py
@@ -1,8 +1,11 @@
 from pathlib import Path
 
-HARDCODED_BUILD_DIRECTORY = Path("/tmp/contract")
-HARDCODED_UNWRAP_DIRECTORY = Path("/tmp/unwrapped")
+HARDCODED_BUILD_FOLDER = Path("/tmp/elrond-contract-rust")
+HARDCODED_UNWRAP_FOLDER = Path("/tmp/unwrapped")
 ONE_KB_IN_BYTES: int = 1024
-MAX_SOURCE_CODE_ARCHIVE_SIZE: int = ONE_KB_IN_BYTES * 1024
+MAX_PACKAGED_SOURCE_CODE_SIZE: int = 2 * ONE_KB_IN_BYTES * 1024
 # The output archive contains not only the *.wasm, but also *.wat, *.abi.json files etc.
-MAX_OUTPUT_ARTIFACTS_ARCHIVE_SIZE: int = ONE_KB_IN_BYTES * 1024
+MAX_OUTPUT_ARTIFACTS_ARCHIVE_SIZE: int = 2 * ONE_KB_IN_BYTES * 1024
+
+CONTRACT_CONFIG_FILENAME = "multiversx.json"
+OLD_CONTRACT_CONFIG_FILENAME = "elrond.json"
diff --git a/multiversx_sdk_rust_contract_builder/filesystem.py b/multiversx_sdk_rust_contract_builder/filesystem.py
index 6964fad..baf76d9 100644
--- a/multiversx_sdk_rust_contract_builder/filesystem.py
+++ b/multiversx_sdk_rust_contract_builder/filesystem.py
@@ -1,39 +1,25 @@
 import logging
-import os
 from pathlib import Path
-from typing import Callable, List, Union
+from typing import Callable, Union
 from zipfile import ZIP_DEFLATED, ZipFile
 
 from multiversx_sdk_rust_contract_builder.errors import ErrKnown
 
 
-def archive_directory(archive_file: Path, directory: Path, should_include_file: Union[Callable[[Path], bool], None] = None):
-    files = get_files_recursively(directory, should_include_file)
+def archive_folder(archive_file: Path, folder: Path, should_include_file: Union[Callable[[Path], bool], None] = None):
+    files = get_all_files(folder, should_include_file)
 
     with ZipFile(archive_file, "w", ZIP_DEFLATED) as archive:
         for full_path in files:
-            archive.write(full_path, full_path.relative_to(directory))
+            archive.write(full_path, full_path.relative_to(folder))
 
     logging.info(f"Created archive: file = {archive_file}, with size = {archive_file.stat().st_size} bytes")
 
 
-def get_files_recursively(directory: Path, should_include_file: Union[Callable[[Path], bool], None] = None):
+def get_all_files(folder: Path, should_include_file: Union[Callable[[Path], bool], None] = None):
     should_include_file = should_include_file or (lambda _: True)
-    paths: List[Path] = []
-
-    for root, _, files in os.walk(directory):
-        root_path = Path(root)
-        for file in files:
-            file_path = Path(file)
-            full_path = root_path / file_path
-
-            if file_path.is_dir():
-                continue
-            if not should_include_file(file_path):
-                continue
-
-            paths.append(full_path)
-
+    paths = list(folder.rglob("*"))
+    paths = [path for path in paths if path.is_file() and should_include_file(path)]
     return paths
 
 
diff --git a/multiversx_sdk_rust_contract_builder/main.py b/multiversx_sdk_rust_contract_builder/main.py
index 5c2a8f0..d3c454d 100644
--- a/multiversx_sdk_rust_contract_builder/main.py
+++ b/multiversx_sdk_rust_contract_builder/main.py
@@ -1,5 +1,6 @@
 import logging
 import os
+import shutil
 import sys
 import time
 from argparse import ArgumentParser
@@ -8,7 +9,7 @@
 
 from multiversx_sdk_rust_contract_builder import builder
 from multiversx_sdk_rust_contract_builder.constants import \
-    HARDCODED_UNWRAP_DIRECTORY
+    HARDCODED_UNWRAP_FOLDER
 from multiversx_sdk_rust_contract_builder.errors import ErrKnown
 from multiversx_sdk_rust_contract_builder.packaged_source_code import \
     PackagedSourceCode
@@ -20,32 +21,43 @@ def main(cli_args: List[str]):
     start_time = time.time()
 
     parser = ArgumentParser()
-    parser.add_argument("--project", type=str, required=False, help="source code directory")
+    parser.add_argument("--project", type=str, required=False, help="source code folder (project)")
     parser.add_argument("--packaged-src", type=str, required=False, help="source code packaged in a JSON file")
-    parser.add_argument("--contract", type=str, required=False, help="contract to build from within the source code directory; should be relative to the project path")
+    parser.add_argument("--contract", type=str, required=False, help="contract to build from within the source code folder; should be relative to the project path")
     parser.add_argument("--output", type=str, required=True)
     parser.add_argument("--no-wasm-opt", action="store_true", default=False, help="do not optimize wasm files after the build (default: %(default)s)")
     parser.add_argument("--cargo-target-dir", type=str, required=True, help="Cargo's target-dir")
+    parser.add_argument("--context", type=str, required=False, default=os.environ.get("CONTEXT", "unknown"), help="the context of the build (e.g. a Docker image identifier))")
 
     parsed_args = parser.parse_args(cli_args)
     project_path = Path(parsed_args.project).expanduser().resolve() if parsed_args.project else None
     packaged_src_path = Path(parsed_args.packaged_src).expanduser().resolve() if parsed_args.packaged_src else None
-    parent_output_directory = Path(parsed_args.output)
+    parent_output_folder = Path(parsed_args.output)
     specific_contract = parsed_args.contract
     cargo_target_dir = Path(parsed_args.cargo_target_dir)
     no_wasm_opt = parsed_args.no_wasm_opt
+    context = parsed_args.context
 
     if not project_path:
         if not packaged_src_path:
             raise ErrKnown("One of the following must be provided: --project, --packaged-src")
 
         # We have to unwrap the packaged source code (JSON)
-        project_path = HARDCODED_UNWRAP_DIRECTORY
+        project_path = HARDCODED_UNWRAP_FOLDER
+        shutil.rmtree(HARDCODED_UNWRAP_FOLDER, ignore_errors=True)
         packaged = PackagedSourceCode.from_file(packaged_src_path)
-        packaged.unwrap_to_folder(HARDCODED_UNWRAP_DIRECTORY)
+        packaged.unwrap_to_filesystem(HARDCODED_UNWRAP_FOLDER)
 
-    outcome = builder.build_project(project_path, parent_output_directory, specific_contract, cargo_target_dir, no_wasm_opt)
-    outcome.save_to_file(parent_output_directory / "artifacts.json")
+    outcome = builder.build_project(
+        project_path,
+        parent_output_folder,
+        specific_contract,
+        cargo_target_dir,
+        no_wasm_opt,
+        context
+    )
+
+    outcome.save_to_file(parent_output_folder / "artifacts.json")
 
     end_time = time.time()
     time_elapsed = end_time - start_time
@@ -58,3 +70,4 @@ def main(cli_args: List[str]):
     except ErrKnown as err:
         print("An error occurred.")
         print(err)
+        exit(1)
diff --git a/multiversx_sdk_rust_contract_builder/packaged_source_code.py b/multiversx_sdk_rust_contract_builder/packaged_source_code.py
index 2fc2bd5..57054f1 100644
--- a/multiversx_sdk_rust_contract_builder/packaged_source_code.py
+++ b/multiversx_sdk_rust_contract_builder/packaged_source_code.py
@@ -6,10 +6,8 @@
 
 from multiversx_sdk_rust_contract_builder.cargo_toml import \
     get_contract_name_and_version
-from multiversx_sdk_rust_contract_builder.filesystem import \
-    get_files_recursively
 from multiversx_sdk_rust_contract_builder.source_code import \
-    is_source_code_file
+    get_source_code_files_necessary_for_contract
 
 
 class PackagedSourceCodeEntry:
@@ -51,31 +49,32 @@ def from_dict(cls, data: Dict[str, Any]) -> 'PackagedSourceCode':
         version = data.get("version", "0.0.0")
         entries_raw: List[Dict[str, Any]] = data.get("entries", [])
         entries = [PackagedSourceCodeEntry.from_dict(entry) for entry in entries_raw]
+        _sort_entries(entries)
+
         return PackagedSourceCode(name, version, entries)
 
     @classmethod
-    def from_folder(cls, folder: Path) -> 'PackagedSourceCode':
-        entries = cls._create_entries_from_folder(folder)
-        name, version = get_contract_name_and_version(folder)
+    def from_filesystem(cls, project_folder: Path, contract_folder: Path) -> 'PackagedSourceCode':
+        name, version = get_contract_name_and_version(contract_folder)
+        entries = cls._create_entries_from_filesystem(project_folder, contract_folder, name)
         return PackagedSourceCode(name, version, entries)
 
     @classmethod
-    def _create_entries_from_folder(cls, folder: Path) -> List[PackagedSourceCodeEntry]:
-        files = get_files_recursively(folder, is_source_code_file)
+    def _create_entries_from_filesystem(cls, project_folder: Path, contract_folder: Path, contract_name: str) -> List[PackagedSourceCodeEntry]:
+        source_files = get_source_code_files_necessary_for_contract(contract_folder, contract_name)
         entries: List[PackagedSourceCodeEntry] = []
 
-        for full_path in files:
-            with open(full_path, "rb") as f:
-                content = f.read()
-
-            relative_path = full_path.relative_to(folder)
+        for full_path in source_files:
+            content = full_path.read_bytes()
+            relative_path = full_path.relative_to(project_folder)
             entries.append(PackagedSourceCodeEntry(relative_path, content))
 
+        _sort_entries(entries)
         return entries
 
-    def unwrap_to_folder(self, folder: Path):
+    def unwrap_to_filesystem(self, project_folder: Path):
         for entry in self.entries:
-            full_path = folder / entry.path
+            full_path = project_folder / entry.path
             full_path.parent.mkdir(parents=True, exist_ok=True)
             with open(full_path, "wb") as f:
                 f.write(entry.content)
@@ -94,3 +93,8 @@ def to_dict(self) -> Dict[str, Any]:
             "version": self.version,
             "entries": entries
         }
+
+
+def _sort_entries(entries: List[PackagedSourceCodeEntry]) -> List[PackagedSourceCodeEntry]:
+    entries.sort(key=lambda entry: entry.path)
+    return entries
diff --git a/multiversx_sdk_rust_contract_builder/source_code.py b/multiversx_sdk_rust_contract_builder/source_code.py
index 7b706a0..19a395e 100644
--- a/multiversx_sdk_rust_contract_builder/source_code.py
+++ b/multiversx_sdk_rust_contract_builder/source_code.py
@@ -1,10 +1,95 @@
 
+import json
+import logging
+import subprocess
 from pathlib import Path
+from typing import Any, Dict, List, Set
 
+from multiversx_sdk_rust_contract_builder.constants import (
+    CONTRACT_CONFIG_FILENAME, OLD_CONTRACT_CONFIG_FILENAME)
+from multiversx_sdk_rust_contract_builder.errors import ErrKnown
+from multiversx_sdk_rust_contract_builder.filesystem import get_all_files
 
-def is_source_code_file(path: Path):
+
+def get_source_code_files_necessary_for_contract(contract_folder: Path, contract_name: str) -> List[Path]:
+    source_files: List[Path] = []
+
+    source_files.extend(get_all_source_code_files(contract_folder))
+    local_dependencies = get_local_dependencies(contract_folder, contract_name)
+
+    logging.info(f"Found {len(local_dependencies)} local dependencies.")
+
+    for dependency in local_dependencies:
+        logging.debug(f"Local dependency: {dependency}")
+        source_files.extend(get_all_files(dependency, is_source_code_file))
+
+    return sorted(set(source_files))
+
+
+def get_all_source_code_files(folder: Path) -> List[Path]:
+    return sorted(get_all_files(folder, is_source_code_file))
+
+
+def is_source_code_file(path: Path) -> bool:
     if path.suffix == ".rs":
         return True
-    if path.name in ["Cargo.toml", "Cargo.lock", "elrond.json"]:
+    if path.parent.name == "meta" and path.name == "Cargo.lock":
+        return False
+    if path.name in ["Cargo.toml", "Cargo.lock", CONTRACT_CONFIG_FILENAME, OLD_CONTRACT_CONFIG_FILENAME]:
         return True
     return False
+
+
+def replace_all_test_content_with_noop(folder: Path):
+    # At this moment (January 2023) we cannot completely exclude test files from the compilation
+    # (if we do so, the build throws some errors, in some cases).
+    # So we replace all test content with a noop function.
+    # This is not ideal, but it works for now.
+
+    logging.info(f"replace_all_test_content_with_noop({folder})")
+    test_files = get_all_files(folder, is_test_file)
+    for file in test_files:
+        file.write_text("fn nothing() {}")
+
+
+def is_test_file(path: Path) -> bool:
+    is_in_tests_folder = any(part in ["test", "tests"] for part in path.parts)
+    return path.suffix == ".rs" and is_in_tests_folder
+
+
+def get_local_dependencies(contract_folder: Path, contract_name: str) -> List[Path]:
+    args = ["cargo", "metadata", "--format-version=1"]
+    logging.info(f"get_local_dependencies(), running: {args}, with cwd = {contract_folder}")
+    metadata_json = subprocess.check_output(args, cwd=contract_folder, shell=False, universal_newlines=True)
+    metadata = json.loads(metadata_json)
+
+    logging.info(f"get_local_dependencies(), explore metadata recursively for contract {contract_name}")
+    paths = _get_local_dependencies_recursively(metadata, contract_name, set(), 0)
+    return list(paths)
+
+
+def _get_local_dependencies_recursively(cargo_metadata: Dict[str, Any], package_name: str, visited: Set[str], indentation: int) -> Set[Path]:
+    if package_name in visited:
+        return set()
+
+    visited.add(package_name)
+
+    packages = cargo_metadata.get("packages", [])
+    package = next((package for package in packages if package["name"] == package_name), None)
+    if not package:
+        raise ErrKnown(f"Could not find package {package_name} in project metadata.")
+
+    dependencies = package.get("dependencies", [])
+    local_dependencies = [dependency for dependency in dependencies if _is_local_dependency(dependency)]
+    paths = set([Path(dependency["path"]) for dependency in local_dependencies])
+
+    logging.debug(f"{indentation * 4 * ' '} ({package_name}): {[dependency['name'] for dependency in local_dependencies]}")
+
+    for dependency in local_dependencies:
+        paths |= _get_local_dependencies_recursively(cargo_metadata, dependency["name"], visited, indentation + 1)
+
+    return paths
+
+
+def _is_local_dependency(dependency: Dict[str, Any]) -> bool:
+    return "path" in dependency
diff --git a/pyproject.toml b/pyproject.toml
index 389e0bd..8991b82 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ allow-direct-references = true
 
 [project]
 name = "multiversx-sdk-rust-contract-builder"
-version = "4.0.3"
+version = "4.1.0"
 authors = [
   { name="MultiversX" },
 ]
@@ -23,7 +23,13 @@ classifiers = [
 
 [tool.hatch.build]
 exclude = [
-  "testdata/**"
+  "integration_tests/**",
+  "testdata/**",
+  "support/**"
+]
+
+dependencies = [
+  "tomlkit==0.11.6"
 ]
 
 [project.urls]
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..cc51f9c
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1 @@
+tomlkit==0.11.6
diff --git a/testdata/expected/adder-1.2.3.source.json b/testdata/expected/adder-1.2.3.source.json
index 700ea21..81cc5e7 100644
--- a/testdata/expected/adder-1.2.3.source.json
+++ b/testdata/expected/adder-1.2.3.source.json
@@ -11,32 +11,28 @@
             "content": "ewogICAgImxhbmd1YWdlIjogInJ1c3QiCn0="
         },
         {
-            "path": "src/adder.rs",
-            "content": "IyFbbm9fc3RkXQoKZWxyb25kX3dhc206OmltcG9ydHMhKCk7CgovLy8gT25lIG9mIHRoZSBzaW1wbGVzdCBzbWFydCBjb250cmFjdHMgcG9zc2libGUsCi8vLyBpdCBob2xkcyBhIHNpbmdsZSB2YXJpYWJsZSBpbiBzdG9yYWdlLCB3aGljaCBhbnlvbmUgY2FuIGluY3JlbWVudC4KI1tlbHJvbmRfd2FzbTo6Y29udHJhY3RdCnB1YiB0cmFpdCBBZGRlciB7CiAgICAjW3ZpZXcoZ2V0U3VtKV0KICAgICNbc3RvcmFnZV9tYXBwZXIoInN1bSIpXQogICAgZm4gc3VtKCZzZWxmKSAtPiBTaW5nbGVWYWx1ZU1hcHBlcjxCaWdVaW50PjsKCiAgICAjW2luaXRdCiAgICBmbiBpbml0KCZzZWxmLCBpbml0aWFsX3ZhbHVlOiBCaWdVaW50KSB7CiAgICAgICAgc2VsZi5zdW0oKS5zZXQoaW5pdGlhbF92YWx1ZSk7CiAgICB9CgogICAgLy8vIEFkZCBkZXNpcmVkIGFtb3VudCB0byB0aGUgc3RvcmFnZSB2YXJpYWJsZS4KICAgICNbZW5kcG9pbnRdCiAgICBmbiBhZGQoJnNlbGYsIHZhbHVlOiBCaWdVaW50KSB7CiAgICAgICAgc2VsZi5zdW0oKS51cGRhdGUofHN1bXwgKnN1bSArPSB2YWx1ZSk7CiAgICB9Cn0K"
-        },
-        {
-            "path": "wasm/Cargo.toml",
-            "content": "W3BhY2thZ2VdCm5hbWUgPSAiYWRkZXItd2FzbSIKdmVyc2lvbiA9ICIxLjIuMyIKYXV0aG9ycyA9IFsieW91Il0KZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltsaWJdCmNyYXRlLXR5cGUgPSBbImNkeWxpYiJdCgpbcHJvZmlsZS5yZWxlYXNlXQpjb2RlZ2VuLXVuaXRzID0gMQpvcHQtbGV2ZWwgPSAieiIKbHRvID0gdHJ1ZQpkZWJ1ZyA9IGZhbHNlCnBhbmljID0gImFib3J0IgoKW2RlcGVuZGVuY2llcy5hZGRlcl0KcGF0aCA9ICIuLiIKCltkZXBlbmRlbmNpZXMuZWxyb25kLXdhc20tbm9kZV0KdmVyc2lvbiA9ICIwLjM2LjEiCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLW91dHB1dF0KdmVyc2lvbiA9ICIwLjM2LjEiCmZlYXR1cmVzID0gWyJ3YXNtLW91dHB1dC1tb2RlIl0KClt3b3Jrc3BhY2VdCm1lbWJlcnMgPSBbIi4iXQo="
+            "path": "meta/Cargo.toml",
+            "content": "W3BhY2thZ2VdCm5hbWUgPSAiYWRkZXItbWV0YSIKdmVyc2lvbiA9ICIwLjAuMCIKZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltkZXBlbmRlbmNpZXMuYWRkZXJdCnBhdGggPSAiLi4iCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLWRlYnVnXQp2ZXJzaW9uID0gIjAuMzYuMSIK"
         },
         {
-            "path": "wasm/Cargo.lock",
-            "content": "# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "adder"
version = "1.2.3"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "adder-wasm"
version = "1.2.3"
dependencies = [
 "adder",
 "elrond-wasm-node",
 "elrond-wasm-output",
]

[[package]]
name = "ahash"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
dependencies = [
 "getrandom",
 "once_cell",
 "version_check",
]

[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"

[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "elrond-codec"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c85c5951864dd4816e1df2ceaccb0f22c64ff117ddcde1f53351ace4d785c47"
dependencies = [
 "arrayvec",
 "elrond-codec-derive",
 "wee_alloc",
]

[[package]]
name = "elrond-codec-derive"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a8987a7f506ae5b352ad7ac28fb13b9f600355c8b88a444881f86bc565c75cf"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "elrond-wasm"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ff7dd10f4a7133a2c6feb3f79e04953f9a3c1eda9f8444b43c1300f302e02fd"
dependencies = [
 "bitflags",
 "elrond-codec",
 "elrond-wasm-derive",
 "git-version",
 "hashbrown",
 "hex-literal",
 "num-traits",
 "wee_alloc",
]

[[package]]
name = "elrond-wasm-derive"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60358989163ae1c28b79d7c687869874c765001bbdfa12a31dfd920350bc7a22"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "radix_trie",
 "syn",
]

[[package]]
name = "elrond-wasm-node"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4cb4d4c1aced967f86dbc2a0a01910d1ebb10ceab459cb4a3d7d2e43b4df2f9b"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "elrond-wasm-output"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a8c02515e43ef7fda0c74cc4a0a4d353846af999cc802c2306c34fd70cda11"
dependencies = [
 "elrond-wasm-node",
 "wee_alloc",
]

[[package]]
name = "endian-type"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"

[[package]]
name = "getrandom"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi",
]

[[package]]
name = "git-version"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"
dependencies = [
 "git-version-macro",
 "proc-macro-hack",
]

[[package]]
name = "git-version-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
 "ahash",
]

[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]
name = "hex-literal"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"

[[package]]
name = "libc"
version = "0.2.137"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"

[[package]]
name = "memory_units"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3"

[[package]]
name = "nibble_vec"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d77f3db4bce033f4d04db08079b2ef1c3d02b44e86f25d08886fafa7756ffa"

[[package]]
name = "num-traits"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

[[package]]
name = "once_cell"
version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"

[[package]]
name = "proc-macro-hack"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"

[[package]]
name = "proc-macro2"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
dependencies = [
 "unicode-ident",
]

[[package]]
name = "quote"
version = "1.0.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "radix_trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3681b28cd95acfb0560ea9441f82d6a4504fa3b15b97bd7b6e952131820e95"
dependencies = [
 "endian-type",
 "nibble_vec",
]

[[package]]
name = "syn"
version = "1.0.103"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]

[[package]]
name = "unicode-ident"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"

[[package]]
name = "version_check"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

[[package]]
name = "wee_alloc"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e"
dependencies = [
 "cfg-if 0.1.10",
 "libc",
 "memory_units",
 "winapi",
]

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"
+            "path": "meta/src/main.rs",
+            "content": "Zm4gbWFpbigpIHsKICAgIGVscm9uZF93YXNtX2RlYnVnOjptZXRhOjpwZXJmb3JtOjo8YWRkZXI6OkFiaVByb3ZpZGVyPigpOwp9Cg=="
         },
         {
-            "path": "wasm/src/lib.rs",
-            "content": "Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwovLy8vLy8vLy8vLy8vLy8vLy8gQVVUTy1HRU5FUkFURUQgLy8vLy8vLy8vLy8vLy8vLy8vCi8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCiMhW25vX3N0ZF0KCmVscm9uZF93YXNtX25vZGU6Ondhc21fZW5kcG9pbnRzISB7CiAgICBhZGRlcgogICAgKAogICAgICAgIGFkZAogICAgICAgIGdldFN1bQogICAgKQp9CgplbHJvbmRfd2FzbV9ub2RlOjp3YXNtX2VtcHR5X2NhbGxiYWNrISB7fQo="
+            "path": "src/adder.rs",
+            "content": "IyFbbm9fc3RkXQoKZWxyb25kX3dhc206OmltcG9ydHMhKCk7CgovLy8gT25lIG9mIHRoZSBzaW1wbGVzdCBzbWFydCBjb250cmFjdHMgcG9zc2libGUsCi8vLyBpdCBob2xkcyBhIHNpbmdsZSB2YXJpYWJsZSBpbiBzdG9yYWdlLCB3aGljaCBhbnlvbmUgY2FuIGluY3JlbWVudC4KI1tlbHJvbmRfd2FzbTo6Y29udHJhY3RdCnB1YiB0cmFpdCBBZGRlciB7CiAgICAjW3ZpZXcoZ2V0U3VtKV0KICAgICNbc3RvcmFnZV9tYXBwZXIoInN1bSIpXQogICAgZm4gc3VtKCZzZWxmKSAtPiBTaW5nbGVWYWx1ZU1hcHBlcjxCaWdVaW50PjsKCiAgICAjW2luaXRdCiAgICBmbiBpbml0KCZzZWxmLCBpbml0aWFsX3ZhbHVlOiBCaWdVaW50KSB7CiAgICAgICAgc2VsZi5zdW0oKS5zZXQoaW5pdGlhbF92YWx1ZSk7CiAgICB9CgogICAgLy8vIEFkZCBkZXNpcmVkIGFtb3VudCB0byB0aGUgc3RvcmFnZSB2YXJpYWJsZS4KICAgICNbZW5kcG9pbnRdCiAgICBmbiBhZGQoJnNlbGYsIHZhbHVlOiBCaWdVaW50KSB7CiAgICAgICAgc2VsZi5zdW0oKS51cGRhdGUofHN1bXwgKnN1bSArPSB2YWx1ZSk7CiAgICB9Cn0K"
         },
         {
-            "path": "meta/Cargo.toml",
-            "content": "W3BhY2thZ2VdCm5hbWUgPSAiYWRkZXItbWV0YSIKdmVyc2lvbiA9ICIwLjAuMCIKZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltkZXBlbmRlbmNpZXMuYWRkZXJdCnBhdGggPSAiLi4iCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLWRlYnVnXQp2ZXJzaW9uID0gIjAuMzYuMSIK"
+            "path": "wasm/Cargo.lock",
+            "content": "# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "adder"
version = "1.2.3"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "adder-wasm"
version = "1.2.3"
dependencies = [
 "adder",
 "elrond-wasm-node",
 "elrond-wasm-output",
]

[[package]]
name = "ahash"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
dependencies = [
 "getrandom",
 "once_cell",
 "version_check",
]

[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"

[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "elrond-codec"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c85c5951864dd4816e1df2ceaccb0f22c64ff117ddcde1f53351ace4d785c47"
dependencies = [
 "arrayvec",
 "elrond-codec-derive",
 "wee_alloc",
]

[[package]]
name = "elrond-codec-derive"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a8987a7f506ae5b352ad7ac28fb13b9f600355c8b88a444881f86bc565c75cf"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "elrond-wasm"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ff7dd10f4a7133a2c6feb3f79e04953f9a3c1eda9f8444b43c1300f302e02fd"
dependencies = [
 "bitflags",
 "elrond-codec",
 "elrond-wasm-derive",
 "git-version",
 "hashbrown",
 "hex-literal",
 "num-traits",
 "wee_alloc",
]

[[package]]
name = "elrond-wasm-derive"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60358989163ae1c28b79d7c687869874c765001bbdfa12a31dfd920350bc7a22"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "radix_trie",
 "syn",
]

[[package]]
name = "elrond-wasm-node"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4cb4d4c1aced967f86dbc2a0a01910d1ebb10ceab459cb4a3d7d2e43b4df2f9b"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "elrond-wasm-output"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a8c02515e43ef7fda0c74cc4a0a4d353846af999cc802c2306c34fd70cda11"
dependencies = [
 "elrond-wasm-node",
 "wee_alloc",
]

[[package]]
name = "endian-type"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"

[[package]]
name = "getrandom"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi",
]

[[package]]
name = "git-version"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"
dependencies = [
 "git-version-macro",
 "proc-macro-hack",
]

[[package]]
name = "git-version-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
 "ahash",
]

[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]
name = "hex-literal"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"

[[package]]
name = "libc"
version = "0.2.137"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"

[[package]]
name = "memory_units"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3"

[[package]]
name = "nibble_vec"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d77f3db4bce033f4d04db08079b2ef1c3d02b44e86f25d08886fafa7756ffa"

[[package]]
name = "num-traits"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

[[package]]
name = "once_cell"
version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"

[[package]]
name = "proc-macro-hack"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"

[[package]]
name = "proc-macro2"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
dependencies = [
 "unicode-ident",
]

[[package]]
name = "quote"
version = "1.0.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "radix_trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3681b28cd95acfb0560ea9441f82d6a4504fa3b15b97bd7b6e952131820e95"
dependencies = [
 "endian-type",
 "nibble_vec",
]

[[package]]
name = "syn"
version = "1.0.103"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]

[[package]]
name = "unicode-ident"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"

[[package]]
name = "version_check"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

[[package]]
name = "wee_alloc"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e"
dependencies = [
 "cfg-if 0.1.10",
 "libc",
 "memory_units",
 "winapi",
]

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"
         },
         {
-            "path": "meta/Cargo.lock",
-            "content": "# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "adder"
version = "1.2.3"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "adder-meta"
version = "0.0.0"
dependencies = [
 "adder",
 "elrond-wasm-debug",
]

[[package]]
name = "ahash"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
dependencies = [
 "getrandom 0.2.8",
 "once_cell",
 "version_check",
]

[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"

[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

[[package]]
name = "bech32"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445"

[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

[[package]]
name = "block-buffer"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
dependencies = [
 "block-padding",
 "generic-array",
]

[[package]]
name = "block-padding"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"

[[package]]
name = "byteorder"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"

[[package]]
name = "cargo_toml"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "363c7cfaa15f101415c4ac9e68706ca4a2277773932828b33f96e59d28c68e62"
dependencies = [
 "serde",
 "serde_derive",
 "toml",
]

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "cpufeatures"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
dependencies = [
 "libc",
]

[[package]]
name = "curve25519-dalek"
version = "3.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"
dependencies = [
 "byteorder",
 "digest",
 "rand_core 0.5.1",
 "subtle",
 "zeroize",
]

[[package]]
name = "digest"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
dependencies = [
 "generic-array",
]

[[package]]
name = "ed25519"
version = "1.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e9c280362032ea4203659fc489832d0204ef09f247a0506f170dafcac08c369"
dependencies = [
 "signature",
]

[[package]]
name = "ed25519-dalek"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
dependencies = [
 "curve25519-dalek",
 "ed25519",
 "rand 0.7.3",
 "serde",
 "sha2",
 "zeroize",
]

[[package]]
name = "either"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"

[[package]]
name = "elrond-codec"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c85c5951864dd4816e1df2ceaccb0f22c64ff117ddcde1f53351ace4d785c47"
dependencies = [
 "arrayvec",
 "elrond-codec-derive",
 "num-bigint",
 "wee_alloc",
]

[[package]]
name = "elrond-codec-derive"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a8987a7f506ae5b352ad7ac28fb13b9f600355c8b88a444881f86bc565c75cf"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "elrond-wasm"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ff7dd10f4a7133a2c6feb3f79e04953f9a3c1eda9f8444b43c1300f302e02fd"
dependencies = [
 "bitflags",
 "elrond-codec",
 "elrond-wasm-derive",
 "git-version",
 "hashbrown",
 "hex-literal",
 "num-traits",
 "wee_alloc",
]

[[package]]
name = "elrond-wasm-debug"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d5edfe86985956f2de3a649bb1619c1f8b794b540e620461ba08f05086353fc"
dependencies = [
 "bech32",
 "cargo_toml",
 "ed25519-dalek",
 "elrond-wasm",
 "hex",
 "itertools",
 "mandos",
 "num-bigint",
 "num-traits",
 "pathdiff",
 "rand 0.8.5",
 "rand_pcg",
 "rand_seeder",
 "rustc_version",
 "serde",
 "serde_json",
 "sha2",
 "sha3",
 "toml",
]

[[package]]
name = "elrond-wasm-derive"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60358989163ae1c28b79d7c687869874c765001bbdfa12a31dfd920350bc7a22"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "radix_trie",
 "syn",
]

[[package]]
name = "endian-type"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"

[[package]]
name = "generic-array"
version = "0.14.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
dependencies = [
 "typenum",
 "version_check",
]

[[package]]
name = "getrandom"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi 0.9.0+wasi-snapshot-preview1",
]

[[package]]
name = "getrandom"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
]

[[package]]
name = "git-version"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"
dependencies = [
 "git-version-macro",
 "proc-macro-hack",
]

[[package]]
name = "git-version-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
 "ahash",
]

[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]
name = "hex-literal"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"

[[package]]
name = "itertools"
version = "0.10.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
dependencies = [
 "either",
]

[[package]]
name = "itoa"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"

[[package]]
name = "keccak"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
dependencies = [
 "cpufeatures",
]

[[package]]
name = "libc"
version = "0.2.139"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"

[[package]]
name = "mandos"
version = "0.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1842e74cfde878e86af08648332c357e63135763f554ffbd6e82f110defdbeaf"
dependencies = [
 "bech32",
 "hex",
 "num-bigint",
 "num-traits",
 "serde",
 "serde_json",
 "sha3",
]

[[package]]
name = "memory_units"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3"

[[package]]
name = "nibble_vec"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d77f3db4bce033f4d04db08079b2ef1c3d02b44e86f25d08886fafa7756ffa"

[[package]]
name = "num-bigint"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
dependencies = [
 "autocfg",
 "num-integer",
 "num-traits",
]

[[package]]
name = "num-integer"
version = "0.1.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
dependencies = [
 "autocfg",
 "num-traits",
]

[[package]]
name = "num-traits"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

[[package]]
name = "once_cell"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"

[[package]]
name = "opaque-debug"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"

[[package]]
name = "pathdiff"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"

[[package]]
name = "ppv-lite86"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

[[package]]
name = "proc-macro-hack"
version = "0.5.20+deprecated"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"

[[package]]
name = "proc-macro2"
version = "1.0.49"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5"
dependencies = [
 "unicode-ident",
]

[[package]]
name = "quote"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "radix_trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3681b28cd95acfb0560ea9441f82d6a4504fa3b15b97bd7b6e952131820e95"
dependencies = [
 "endian-type",
 "nibble_vec",
]

[[package]]
name = "rand"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
 "getrandom 0.1.16",
 "libc",
 "rand_chacha 0.2.2",
 "rand_core 0.5.1",
 "rand_hc",
]

[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
 "libc",
 "rand_chacha 0.3.1",
 "rand_core 0.6.4",
]

[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
 "ppv-lite86",
 "rand_core 0.5.1",
]

[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
 "ppv-lite86",
 "rand_core 0.6.4",
]

[[package]]
name = "rand_core"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
 "getrandom 0.1.16",
]

[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
 "getrandom 0.2.8",
]

[[package]]
name = "rand_hc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
 "rand_core 0.5.1",
]

[[package]]
name = "rand_pcg"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
dependencies = [
 "rand_core 0.5.1",
]

[[package]]
name = "rand_seeder"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf2890aaef0aa82719a50e808de264f9484b74b442e1a3a0e5ee38243ac40bdb"
dependencies = [
 "rand_core 0.6.4",
]

[[package]]
name = "rustc_version"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
dependencies = [
 "semver",
]

[[package]]
name = "ryu"
version = "1.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"

[[package]]
name = "semver"
version = "1.0.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"

[[package]]
name = "serde"
version = "1.0.152"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
dependencies = [
 "serde_derive",
]

[[package]]
name = "serde_derive"
version = "1.0.152"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "serde_json"
version = "1.0.91"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
dependencies = [
 "itoa",
 "ryu",
 "serde",
]

[[package]]
name = "sha2"
version = "0.9.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
dependencies = [
 "block-buffer",
 "cfg-if 1.0.0",
 "cpufeatures",
 "digest",
 "opaque-debug",
]

[[package]]
name = "sha3"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f81199417d4e5de3f04b1e871023acea7389672c4135918f05aa9cbf2f2fa809"
dependencies = [
 "block-buffer",
 "digest",
 "keccak",
 "opaque-debug",
]

[[package]]
name = "signature"
version = "1.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"

[[package]]
name = "subtle"
version = "2.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"

[[package]]
name = "syn"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]

[[package]]
name = "synstructure"
version = "0.12.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "unicode-xid",
]

[[package]]
name = "toml"
version = "0.5.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1333c76748e868a4d9d1017b5ab53171dfd095f70c712fdb4653a406547f598f"
dependencies = [
 "serde",
]

[[package]]
name = "typenum"
version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"

[[package]]
name = "unicode-ident"
version = "1.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"

[[package]]
name = "unicode-xid"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"

[[package]]
name = "version_check"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"

[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

[[package]]
name = "wee_alloc"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e"
dependencies = [
 "cfg-if 0.1.10",
 "libc",
 "memory_units",
 "winapi",
]

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

[[package]]
name = "zeroize"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
dependencies = [
 "zeroize_derive",
]

[[package]]
name = "zeroize_derive"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44bf07cb3e50ea2003396695d58bf46bc9887a1f362260446fad6bc4e79bd36c"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
]
"
+            "path": "wasm/Cargo.toml",
+            "content": "W3BhY2thZ2VdCm5hbWUgPSAiYWRkZXItd2FzbSIKdmVyc2lvbiA9ICIxLjIuMyIKYXV0aG9ycyA9IFsieW91Il0KZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltsaWJdCmNyYXRlLXR5cGUgPSBbImNkeWxpYiJdCgpbcHJvZmlsZS5yZWxlYXNlXQpjb2RlZ2VuLXVuaXRzID0gMQpvcHQtbGV2ZWwgPSAieiIKbHRvID0gdHJ1ZQpkZWJ1ZyA9IGZhbHNlCnBhbmljID0gImFib3J0IgoKW2RlcGVuZGVuY2llcy5hZGRlcl0KcGF0aCA9ICIuLiIKCltkZXBlbmRlbmNpZXMuZWxyb25kLXdhc20tbm9kZV0KdmVyc2lvbiA9ICIwLjM2LjEiCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLW91dHB1dF0KdmVyc2lvbiA9ICIwLjM2LjEiCmZlYXR1cmVzID0gWyJ3YXNtLW91dHB1dC1tb2RlIl0KClt3b3Jrc3BhY2VdCm1lbWJlcnMgPSBbIi4iXQo="
         },
         {
-            "path": "meta/src/main.rs",
-            "content": "Zm4gbWFpbigpIHsKICAgIGVscm9uZF93YXNtX2RlYnVnOjptZXRhOjpwZXJmb3JtOjo8YWRkZXI6OkFiaVByb3ZpZGVyPigpOwp9Cg=="
+            "path": "wasm/src/lib.rs",
+            "content": "Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwovLy8vLy8vLy8vLy8vLy8vLy8gQVVUTy1HRU5FUkFURUQgLy8vLy8vLy8vLy8vLy8vLy8vCi8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCiMhW25vX3N0ZF0KCmVscm9uZF93YXNtX25vZGU6Ondhc21fZW5kcG9pbnRzISB7CiAgICBhZGRlcgogICAgKAogICAgICAgIGFkZAogICAgICAgIGdldFN1bQogICAgKQp9CgplbHJvbmRfd2FzbV9ub2RlOjp3YXNtX2VtcHR5X2NhbGxiYWNrISB7fQo="
         }
     ]
 }
diff --git a/testdata/expected/empty-4.5.6.source.json b/testdata/expected/empty-4.5.6.source.json
index b2c9109..e3c84d0 100644
--- a/testdata/expected/empty-4.5.6.source.json
+++ b/testdata/expected/empty-4.5.6.source.json
@@ -11,32 +11,28 @@
             "content": "ewogICAgImxhbmd1YWdlIjogInJ1c3QiCn0="
         },
         {
-            "path": "src/empty.rs",
-            "content": "IyFbbm9fc3RkXQoKZWxyb25kX3dhc206OmltcG9ydHMhKCk7CgovLy8gQW4gZW1wdHkgY29udHJhY3QuIFRvIGJlIHVzZWQgYXMgYSB0ZW1wbGF0ZSB3aGVuIHN0YXJ0aW5nIGEgbmV3IGNvbnRyYWN0IGZyb20gc2NyYXRjaC4KI1tlbHJvbmRfd2FzbTo6Y29udHJhY3RdCnB1YiB0cmFpdCBFbXB0eUNvbnRyYWN0IHsKICAgICNbaW5pdF0KICAgIGZuIGluaXQoJnNlbGYpIHt9Cn0K"
-        },
-        {
-            "path": "wasm/Cargo.toml",
-            "content": "W3BhY2thZ2VdCm5hbWUgPSAiZW1wdHktd2FzbSIKdmVyc2lvbiA9ICI0LjUuNiIKZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltsaWJdCmNyYXRlLXR5cGUgPSBbImNkeWxpYiJdCgpbcHJvZmlsZS5yZWxlYXNlXQpjb2RlZ2VuLXVuaXRzID0gMQpvcHQtbGV2ZWwgPSAieiIKbHRvID0gdHJ1ZQpkZWJ1ZyA9IGZhbHNlCnBhbmljID0gImFib3J0IgoKW2RlcGVuZGVuY2llcy5lbXB0eV0KcGF0aCA9ICIuLiIKCltkZXBlbmRlbmNpZXMuZWxyb25kLXdhc20tbm9kZV0KdmVyc2lvbiA9ICIwLjM2LjEiCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLW91dHB1dF0KdmVyc2lvbiA9ICIwLjM2LjEiCmZlYXR1cmVzID0gWyJ3YXNtLW91dHB1dC1tb2RlIl0KClt3b3Jrc3BhY2VdCm1lbWJlcnMgPSBbIi4iXQo="
+            "path": "meta/Cargo.toml",
+            "content": "W3BhY2thZ2VdCm5hbWUgPSAiZW1wdHktbWV0YSIKdmVyc2lvbiA9ICIwLjAuMCIKZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltkZXBlbmRlbmNpZXMuZW1wdHldCnBhdGggPSAiLi4iCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLWRlYnVnXQp2ZXJzaW9uID0gIjAuMzYuMSIK"
         },
         {
-            "path": "wasm/Cargo.lock",
-            "content": "# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "ahash"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43bb833f0bf979d8475d38fbf09ed3b8a55e1885fe93ad3f93239fc6a4f17b98"
dependencies = [
 "getrandom",
 "once_cell",
 "version_check",
]

[[package]]
name = "arrayvec"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be4dc07131ffa69b8072d35f5007352af944213cde02545e2103680baed38fcd"

[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "elrond-codec"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c85c5951864dd4816e1df2ceaccb0f22c64ff117ddcde1f53351ace4d785c47"
dependencies = [
 "arrayvec",
 "elrond-codec-derive",
 "wee_alloc",
]

[[package]]
name = "elrond-codec-derive"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a8987a7f506ae5b352ad7ac28fb13b9f600355c8b88a444881f86bc565c75cf"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "elrond-wasm"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ff7dd10f4a7133a2c6feb3f79e04953f9a3c1eda9f8444b43c1300f302e02fd"
dependencies = [
 "bitflags",
 "elrond-codec",
 "elrond-wasm-derive",
 "git-version",
 "hashbrown",
 "hex-literal",
 "num-traits",
 "wee_alloc",
]

[[package]]
name = "elrond-wasm-derive"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60358989163ae1c28b79d7c687869874c765001bbdfa12a31dfd920350bc7a22"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "radix_trie",
 "syn",
]

[[package]]
name = "elrond-wasm-node"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4cb4d4c1aced967f86dbc2a0a01910d1ebb10ceab459cb4a3d7d2e43b4df2f9b"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "elrond-wasm-output"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a8c02515e43ef7fda0c74cc4a0a4d353846af999cc802c2306c34fd70cda11"
dependencies = [
 "elrond-wasm-node",
 "wee_alloc",
]

[[package]]
name = "empty"
version = "4.5.6"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "empty-wasm"
version = "4.5.6"
dependencies = [
 "elrond-wasm-node",
 "elrond-wasm-output",
 "empty",
]

[[package]]
name = "endian-type"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"

[[package]]
name = "getrandom"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi",
]

[[package]]
name = "git-version"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"
dependencies = [
 "git-version-macro",
 "proc-macro-hack",
]

[[package]]
name = "git-version-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
 "ahash",
]

[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]
name = "hex-literal"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5af1f635ef1bc545d78392b136bfe1c9809e029023c84a3638a864a10b8819c8"

[[package]]
name = "libc"
version = "0.2.81"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1482821306169ec4d07f6aca392a4681f66c75c9918aa49641a2595db64053cb"

[[package]]
name = "memory_units"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3"

[[package]]
name = "nibble_vec"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d77f3db4bce033f4d04db08079b2ef1c3d02b44e86f25d08886fafa7756ffa"

[[package]]
name = "num-traits"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

[[package]]
name = "once_cell"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"

[[package]]
name = "proc-macro-hack"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"

[[package]]
name = "proc-macro2"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
dependencies = [
 "unicode-xid",
]

[[package]]
name = "quote"
version = "1.0.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "991431c3519a3f36861882da93630ce66b52918dcf1b8e2fd66b397fc96f28df"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "radix_trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3681b28cd95acfb0560ea9441f82d6a4504fa3b15b97bd7b6e952131820e95"
dependencies = [
 "endian-type",
 "nibble_vec",
]

[[package]]
name = "syn"
version = "1.0.67"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6498a9efc342871f91cc2d0d694c674368b4ceb40f62b65a7a08c3792935e702"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-xid",
]

[[package]]
name = "unicode-xid"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"

[[package]]
name = "version_check"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"

[[package]]
name = "wasi"
version = "0.10.2+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

[[package]]
name = "wee_alloc"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e"
dependencies = [
 "cfg-if 0.1.10",
 "libc",
 "memory_units",
 "winapi",
]

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"
+            "path": "meta/src/main.rs",
+            "content": "Zm4gbWFpbigpIHsKICAgIGVscm9uZF93YXNtX2RlYnVnOjptZXRhOjpwZXJmb3JtOjo8ZW1wdHk6OkFiaVByb3ZpZGVyPigpOwp9Cg=="
         },
         {
-            "path": "wasm/src/lib.rs",
-            "content": "Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwovLy8vLy8vLy8vLy8vLy8vLy8gQVVUTy1HRU5FUkFURUQgLy8vLy8vLy8vLy8vLy8vLy8vCi8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCiMhW25vX3N0ZF0KCmVscm9uZF93YXNtX25vZGU6Ondhc21fZW5kcG9pbnRzISB7CiAgICBlbXB0eQogICAgKAogICAgKQp9CgplbHJvbmRfd2FzbV9ub2RlOjp3YXNtX2VtcHR5X2NhbGxiYWNrISB7fQo="
+            "path": "src/empty.rs",
+            "content": "IyFbbm9fc3RkXQoKZWxyb25kX3dhc206OmltcG9ydHMhKCk7CgovLy8gQW4gZW1wdHkgY29udHJhY3QuIFRvIGJlIHVzZWQgYXMgYSB0ZW1wbGF0ZSB3aGVuIHN0YXJ0aW5nIGEgbmV3IGNvbnRyYWN0IGZyb20gc2NyYXRjaC4KI1tlbHJvbmRfd2FzbTo6Y29udHJhY3RdCnB1YiB0cmFpdCBFbXB0eUNvbnRyYWN0IHsKICAgICNbaW5pdF0KICAgIGZuIGluaXQoJnNlbGYpIHt9Cn0K"
         },
         {
-            "path": "meta/Cargo.toml",
-            "content": "W3BhY2thZ2VdCm5hbWUgPSAiZW1wdHktbWV0YSIKdmVyc2lvbiA9ICIwLjAuMCIKZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltkZXBlbmRlbmNpZXMuZW1wdHldCnBhdGggPSAiLi4iCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLWRlYnVnXQp2ZXJzaW9uID0gIjAuMzYuMSIK"
+            "path": "wasm/Cargo.lock",
+            "content": "# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "ahash"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43bb833f0bf979d8475d38fbf09ed3b8a55e1885fe93ad3f93239fc6a4f17b98"
dependencies = [
 "getrandom",
 "once_cell",
 "version_check",
]

[[package]]
name = "arrayvec"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be4dc07131ffa69b8072d35f5007352af944213cde02545e2103680baed38fcd"

[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "elrond-codec"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c85c5951864dd4816e1df2ceaccb0f22c64ff117ddcde1f53351ace4d785c47"
dependencies = [
 "arrayvec",
 "elrond-codec-derive",
 "wee_alloc",
]

[[package]]
name = "elrond-codec-derive"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a8987a7f506ae5b352ad7ac28fb13b9f600355c8b88a444881f86bc565c75cf"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "elrond-wasm"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ff7dd10f4a7133a2c6feb3f79e04953f9a3c1eda9f8444b43c1300f302e02fd"
dependencies = [
 "bitflags",
 "elrond-codec",
 "elrond-wasm-derive",
 "git-version",
 "hashbrown",
 "hex-literal",
 "num-traits",
 "wee_alloc",
]

[[package]]
name = "elrond-wasm-derive"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60358989163ae1c28b79d7c687869874c765001bbdfa12a31dfd920350bc7a22"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "radix_trie",
 "syn",
]

[[package]]
name = "elrond-wasm-node"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4cb4d4c1aced967f86dbc2a0a01910d1ebb10ceab459cb4a3d7d2e43b4df2f9b"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "elrond-wasm-output"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a8c02515e43ef7fda0c74cc4a0a4d353846af999cc802c2306c34fd70cda11"
dependencies = [
 "elrond-wasm-node",
 "wee_alloc",
]

[[package]]
name = "empty"
version = "4.5.6"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "empty-wasm"
version = "4.5.6"
dependencies = [
 "elrond-wasm-node",
 "elrond-wasm-output",
 "empty",
]

[[package]]
name = "endian-type"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"

[[package]]
name = "getrandom"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi",
]

[[package]]
name = "git-version"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"
dependencies = [
 "git-version-macro",
 "proc-macro-hack",
]

[[package]]
name = "git-version-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
 "ahash",
]

[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]
name = "hex-literal"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5af1f635ef1bc545d78392b136bfe1c9809e029023c84a3638a864a10b8819c8"

[[package]]
name = "libc"
version = "0.2.81"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1482821306169ec4d07f6aca392a4681f66c75c9918aa49641a2595db64053cb"

[[package]]
name = "memory_units"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3"

[[package]]
name = "nibble_vec"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d77f3db4bce033f4d04db08079b2ef1c3d02b44e86f25d08886fafa7756ffa"

[[package]]
name = "num-traits"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

[[package]]
name = "once_cell"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"

[[package]]
name = "proc-macro-hack"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"

[[package]]
name = "proc-macro2"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
dependencies = [
 "unicode-xid",
]

[[package]]
name = "quote"
version = "1.0.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "991431c3519a3f36861882da93630ce66b52918dcf1b8e2fd66b397fc96f28df"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "radix_trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3681b28cd95acfb0560ea9441f82d6a4504fa3b15b97bd7b6e952131820e95"
dependencies = [
 "endian-type",
 "nibble_vec",
]

[[package]]
name = "syn"
version = "1.0.67"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6498a9efc342871f91cc2d0d694c674368b4ceb40f62b65a7a08c3792935e702"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-xid",
]

[[package]]
name = "unicode-xid"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"

[[package]]
name = "version_check"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"

[[package]]
name = "wasi"
version = "0.10.2+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

[[package]]
name = "wee_alloc"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e"
dependencies = [
 "cfg-if 0.1.10",
 "libc",
 "memory_units",
 "winapi",
]

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"
         },
         {
-            "path": "meta/Cargo.lock",
-            "content": "# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "ahash"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
dependencies = [
 "getrandom 0.2.8",
 "once_cell",
 "version_check",
]

[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"

[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

[[package]]
name = "bech32"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445"

[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

[[package]]
name = "block-buffer"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
dependencies = [
 "block-padding",
 "generic-array",
]

[[package]]
name = "block-padding"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"

[[package]]
name = "byteorder"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"

[[package]]
name = "cargo_toml"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "363c7cfaa15f101415c4ac9e68706ca4a2277773932828b33f96e59d28c68e62"
dependencies = [
 "serde",
 "serde_derive",
 "toml",
]

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "cpufeatures"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
dependencies = [
 "libc",
]

[[package]]
name = "curve25519-dalek"
version = "3.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"
dependencies = [
 "byteorder",
 "digest",
 "rand_core 0.5.1",
 "subtle",
 "zeroize",
]

[[package]]
name = "digest"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
dependencies = [
 "generic-array",
]

[[package]]
name = "ed25519"
version = "1.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e9c280362032ea4203659fc489832d0204ef09f247a0506f170dafcac08c369"
dependencies = [
 "signature",
]

[[package]]
name = "ed25519-dalek"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
dependencies = [
 "curve25519-dalek",
 "ed25519",
 "rand 0.7.3",
 "serde",
 "sha2",
 "zeroize",
]

[[package]]
name = "either"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"

[[package]]
name = "elrond-codec"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c85c5951864dd4816e1df2ceaccb0f22c64ff117ddcde1f53351ace4d785c47"
dependencies = [
 "arrayvec",
 "elrond-codec-derive",
 "num-bigint",
 "wee_alloc",
]

[[package]]
name = "elrond-codec-derive"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a8987a7f506ae5b352ad7ac28fb13b9f600355c8b88a444881f86bc565c75cf"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "elrond-wasm"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ff7dd10f4a7133a2c6feb3f79e04953f9a3c1eda9f8444b43c1300f302e02fd"
dependencies = [
 "bitflags",
 "elrond-codec",
 "elrond-wasm-derive",
 "git-version",
 "hashbrown",
 "hex-literal",
 "num-traits",
 "wee_alloc",
]

[[package]]
name = "elrond-wasm-debug"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d5edfe86985956f2de3a649bb1619c1f8b794b540e620461ba08f05086353fc"
dependencies = [
 "bech32",
 "cargo_toml",
 "ed25519-dalek",
 "elrond-wasm",
 "hex",
 "itertools",
 "mandos",
 "num-bigint",
 "num-traits",
 "pathdiff",
 "rand 0.8.5",
 "rand_pcg",
 "rand_seeder",
 "rustc_version",
 "serde",
 "serde_json",
 "sha2",
 "sha3",
 "toml",
]

[[package]]
name = "elrond-wasm-derive"
version = "0.36.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60358989163ae1c28b79d7c687869874c765001bbdfa12a31dfd920350bc7a22"
dependencies = [
 "hex",
 "proc-macro2",
 "quote",
 "radix_trie",
 "syn",
]

[[package]]
name = "empty"
version = "4.5.6"
dependencies = [
 "elrond-wasm",
]

[[package]]
name = "empty-meta"
version = "0.0.0"
dependencies = [
 "elrond-wasm-debug",
 "empty",
]

[[package]]
name = "endian-type"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"

[[package]]
name = "generic-array"
version = "0.14.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
dependencies = [
 "typenum",
 "version_check",
]

[[package]]
name = "getrandom"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi 0.9.0+wasi-snapshot-preview1",
]

[[package]]
name = "getrandom"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
]

[[package]]
name = "git-version"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"
dependencies = [
 "git-version-macro",
 "proc-macro-hack",
]

[[package]]
name = "git-version-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
 "ahash",
]

[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]
name = "hex-literal"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"

[[package]]
name = "itertools"
version = "0.10.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
dependencies = [
 "either",
]

[[package]]
name = "itoa"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"

[[package]]
name = "keccak"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
dependencies = [
 "cpufeatures",
]

[[package]]
name = "libc"
version = "0.2.139"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"

[[package]]
name = "mandos"
version = "0.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1842e74cfde878e86af08648332c357e63135763f554ffbd6e82f110defdbeaf"
dependencies = [
 "bech32",
 "hex",
 "num-bigint",
 "num-traits",
 "serde",
 "serde_json",
 "sha3",
]

[[package]]
name = "memory_units"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3"

[[package]]
name = "nibble_vec"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d77f3db4bce033f4d04db08079b2ef1c3d02b44e86f25d08886fafa7756ffa"

[[package]]
name = "num-bigint"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
dependencies = [
 "autocfg",
 "num-integer",
 "num-traits",
]

[[package]]
name = "num-integer"
version = "0.1.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
dependencies = [
 "autocfg",
 "num-traits",
]

[[package]]
name = "num-traits"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

[[package]]
name = "once_cell"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"

[[package]]
name = "opaque-debug"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"

[[package]]
name = "pathdiff"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"

[[package]]
name = "ppv-lite86"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

[[package]]
name = "proc-macro-hack"
version = "0.5.20+deprecated"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"

[[package]]
name = "proc-macro2"
version = "1.0.49"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5"
dependencies = [
 "unicode-ident",
]

[[package]]
name = "quote"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "radix_trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3681b28cd95acfb0560ea9441f82d6a4504fa3b15b97bd7b6e952131820e95"
dependencies = [
 "endian-type",
 "nibble_vec",
]

[[package]]
name = "rand"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
 "getrandom 0.1.16",
 "libc",
 "rand_chacha 0.2.2",
 "rand_core 0.5.1",
 "rand_hc",
]

[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
 "libc",
 "rand_chacha 0.3.1",
 "rand_core 0.6.4",
]

[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
 "ppv-lite86",
 "rand_core 0.5.1",
]

[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
 "ppv-lite86",
 "rand_core 0.6.4",
]

[[package]]
name = "rand_core"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
 "getrandom 0.1.16",
]

[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
 "getrandom 0.2.8",
]

[[package]]
name = "rand_hc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
 "rand_core 0.5.1",
]

[[package]]
name = "rand_pcg"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
dependencies = [
 "rand_core 0.5.1",
]

[[package]]
name = "rand_seeder"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf2890aaef0aa82719a50e808de264f9484b74b442e1a3a0e5ee38243ac40bdb"
dependencies = [
 "rand_core 0.6.4",
]

[[package]]
name = "rustc_version"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
dependencies = [
 "semver",
]

[[package]]
name = "ryu"
version = "1.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"

[[package]]
name = "semver"
version = "1.0.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"

[[package]]
name = "serde"
version = "1.0.152"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
dependencies = [
 "serde_derive",
]

[[package]]
name = "serde_derive"
version = "1.0.152"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "serde_json"
version = "1.0.91"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
dependencies = [
 "itoa",
 "ryu",
 "serde",
]

[[package]]
name = "sha2"
version = "0.9.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
dependencies = [
 "block-buffer",
 "cfg-if 1.0.0",
 "cpufeatures",
 "digest",
 "opaque-debug",
]

[[package]]
name = "sha3"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f81199417d4e5de3f04b1e871023acea7389672c4135918f05aa9cbf2f2fa809"
dependencies = [
 "block-buffer",
 "digest",
 "keccak",
 "opaque-debug",
]

[[package]]
name = "signature"
version = "1.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"

[[package]]
name = "subtle"
version = "2.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"

[[package]]
name = "syn"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]

[[package]]
name = "synstructure"
version = "0.12.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "unicode-xid",
]

[[package]]
name = "toml"
version = "0.5.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1333c76748e868a4d9d1017b5ab53171dfd095f70c712fdb4653a406547f598f"
dependencies = [
 "serde",
]

[[package]]
name = "typenum"
version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"

[[package]]
name = "unicode-ident"
version = "1.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"

[[package]]
name = "unicode-xid"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"

[[package]]
name = "version_check"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"

[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

[[package]]
name = "wee_alloc"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e"
dependencies = [
 "cfg-if 0.1.10",
 "libc",
 "memory_units",
 "winapi",
]

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

[[package]]
name = "zeroize"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
dependencies = [
 "zeroize_derive",
]

[[package]]
name = "zeroize_derive"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44bf07cb3e50ea2003396695d58bf46bc9887a1f362260446fad6bc4e79bd36c"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
]
"
+            "path": "wasm/Cargo.toml",
+            "content": "W3BhY2thZ2VdCm5hbWUgPSAiZW1wdHktd2FzbSIKdmVyc2lvbiA9ICI0LjUuNiIKZWRpdGlvbiA9ICIyMDE4IgpwdWJsaXNoID0gZmFsc2UKCltsaWJdCmNyYXRlLXR5cGUgPSBbImNkeWxpYiJdCgpbcHJvZmlsZS5yZWxlYXNlXQpjb2RlZ2VuLXVuaXRzID0gMQpvcHQtbGV2ZWwgPSAieiIKbHRvID0gdHJ1ZQpkZWJ1ZyA9IGZhbHNlCnBhbmljID0gImFib3J0IgoKW2RlcGVuZGVuY2llcy5lbXB0eV0KcGF0aCA9ICIuLiIKCltkZXBlbmRlbmNpZXMuZWxyb25kLXdhc20tbm9kZV0KdmVyc2lvbiA9ICIwLjM2LjEiCgpbZGVwZW5kZW5jaWVzLmVscm9uZC13YXNtLW91dHB1dF0KdmVyc2lvbiA9ICIwLjM2LjEiCmZlYXR1cmVzID0gWyJ3YXNtLW91dHB1dC1tb2RlIl0KClt3b3Jrc3BhY2VdCm1lbWJlcnMgPSBbIi4iXQo="
         },
         {
-            "path": "meta/src/main.rs",
-            "content": "Zm4gbWFpbigpIHsKICAgIGVscm9uZF93YXNtX2RlYnVnOjptZXRhOjpwZXJmb3JtOjo8ZW1wdHk6OkFiaVByb3ZpZGVyPigpOwp9Cg=="
+            "path": "wasm/src/lib.rs",
+            "content": "Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwovLy8vLy8vLy8vLy8vLy8vLy8gQVVUTy1HRU5FUkFURUQgLy8vLy8vLy8vLy8vLy8vLy8vCi8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCiMhW25vX3N0ZF0KCmVscm9uZF93YXNtX25vZGU6Ondhc21fZW5kcG9pbnRzISB7CiAgICBlbXB0eQogICAgKAogICAgKQp9CgplbHJvbmRfd2FzbV9ub2RlOjp3YXNtX2VtcHR5X2NhbGxiYWNrISB7fQo="
         }
     ]
 }