diff --git a/.circleci/config.yml b/.circleci/config.yml index 5e939431ab53..ff516d0f1499 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -103,6 +103,17 @@ jobs: name: "Create ECR manifest" command: create_ecr_manifest noir x86_64,arm64 + noir-packages: + docker: + - image: aztecprotocol/alpine-build-image + resource_class: small + steps: + - *checkout + - *setup_env + - run: + name: "Build" + command: cond_spot_run_build noir-packages 32 + # Barretenberg barretenberg-wasm-linux-clang: docker: @@ -1013,6 +1024,7 @@ workflows: - noir-x86_64 - noir-arm64 <<: *defaults + - noir-packages: *defaults # Barretenberg - barretenberg-x86_64-linux-gcc: *defaults @@ -1069,6 +1081,8 @@ workflows: - circuits-wasm-linux-clang - l1-contracts - bb-js + - noir-ecr-manifest + - noir-packages <<: *defaults - yarn-project: requires: @@ -1147,7 +1161,6 @@ workflows: - end: requires: - mainnet-fork - - noir-ecr-manifest - e2e-2-pxes - e2e-deploy-contract - e2e-lending-contract diff --git a/barretenberg/bootstrap.sh b/barretenberg/bootstrap.sh index 33342fc9f66e..504f19809820 100755 --- a/barretenberg/bootstrap.sh +++ b/barretenberg/bootstrap.sh @@ -1,8 +1,7 @@ #!/bin/bash set -eu -# Navigate to script folder cd "$(dirname "$0")" -(cd cpp && ./bootstrap.sh) -(cd ts && yarn install --immutable && yarn build && npm link) +(cd cpp && ./bootstrap.sh $@) +(cd ts && ./bootstrap.sh $@) diff --git a/barretenberg/cpp/bootstrap.sh b/barretenberg/cpp/bootstrap.sh index 254179aaf157..25350c4fcce1 100755 --- a/barretenberg/cpp/bootstrap.sh +++ b/barretenberg/cpp/bootstrap.sh @@ -4,22 +4,32 @@ set -eu # Navigate to script folder cd "$(dirname "$0")" -# Clean. -rm -rf ./build -rm -rf ./build-wasm +CMD=${1:-} + +if [ -n "$CMD" ]; then + if [ "$CMD" = "clean" ]; then + git clean -ffdx + exit 0 + else + echo "Unknown command: $CMD" + exit 1 + fi +fi # Determine system. if [[ "$OSTYPE" == "darwin"* ]]; then OS=macos elif [[ "$OSTYPE" == "linux-gnu" ]]; then OS=linux +elif [[ "$OSTYPE" == "linux-musl" ]]; then + OS=linux else echo "Unknown OS: $OSTYPE" exit 1 fi # Download ignition transcripts. -(cd ./srs_db && ./download_ignition.sh 3) +(cd ./srs_db && ./download_ignition.sh 0) # Pick native toolchain file. ARCH=$(uname -m) @@ -33,6 +43,9 @@ else fi fi +# Remove cmake cache files. +rm -f {build,build-wasm,build-wasm-threads}/CMakeCache.txt + echo "#################################" echo "# Building with preset: $PRESET" echo "# When running cmake directly, remember to use: --build --preset $PRESET" @@ -40,15 +53,13 @@ echo "#################################" # Build native. cmake --preset $PRESET -DCMAKE_BUILD_TYPE=RelWithAssert -cmake --build --preset $PRESET ${@/#/--target } - -cd ./build -# The Grumpkin SRS is generated manually at the moment, only up to a large enough size for tests -# If tests require more points, the parameter can be increased here. -cmake --build . --parallel --target grumpkin_srs_gen -./bin/grumpkin_srs_gen 8192 -echo "Generated Grumpkin SRS successfully" -cd ../ +cmake --build --preset $PRESET --target bb + +if [ ! -d ./srs_db/grumpkin ]; then + # The Grumpkin SRS is generated manually at the moment, only up to a large enough size for tests + # If tests require more points, the parameter can be increased here. + (cd ./build && cmake --build . --parallel --target grumpkin_srs_gen && ./bin/grumpkin_srs_gen 8192) +fi # Install wasi-sdk. ./scripts/install-wasi-sdk.sh diff --git a/barretenberg/cpp/scripts/install-wasi-sdk.sh b/barretenberg/cpp/scripts/install-wasi-sdk.sh index 3a8eecf24384..1da258d880bf 100755 --- a/barretenberg/cpp/scripts/install-wasi-sdk.sh +++ b/barretenberg/cpp/scripts/install-wasi-sdk.sh @@ -1,6 +1,11 @@ #!/bin/bash set -eu +if [[ -d ./src/wasi-sdk-20.0 && -d ./src/wasi-sdk-20.0+threads ]]; then + echo "WASI already installed. Skipping." + exit 0 +fi + # Clean. rm -rf ./src/wasi-sdk-* @@ -17,15 +22,15 @@ fi # Install the webassembly toolchain. mkdir -p src cd ./src -curl -s -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-20/wasi-sdk-20.0-$OS.tar.gz | tar zxfv - +curl -s -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-20/wasi-sdk-20.0-$OS.tar.gz | tar zxf - if [ "$OS" == "linux" ]; then # Exceptional linux case that provides an llvm build that works on Ubuntu 20. - curl -s -L https://wasi-sdk.s3.eu-west-2.amazonaws.com/yamt-wasi-sdk-20.0.threads.tgz | tar zxfv - + curl -s -L https://wasi-sdk.s3.eu-west-2.amazonaws.com/yamt-wasi-sdk-20.0.threads.tgz | tar zxf - else # For other operating systems, first download the standard release (this is to get the llvm build). - curl -s -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-20%2Bthreads/wasi-sdk-20.0.threads-$OS.tar.gz | tar zxfv - + curl -s -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-20%2Bthreads/wasi-sdk-20.0.threads-$OS.tar.gz | tar zxf - # Replace wasi-sysroot in wasi-sdk-20.0+threads with our custom build. # It contains libc++ and a patch by yamt to improve thread join stability. # Can remove once future releases are more stable. - curl -s -L https://wasi-sdk.s3.eu-west-2.amazonaws.com/yamt-wasi-sysroot-20.0.threads.tgz | tar zxfv - + curl -s -L https://wasi-sdk.s3.eu-west-2.amazonaws.com/yamt-wasi-sysroot-20.0.threads.tgz | tar zxf - fi diff --git a/barretenberg/cpp/yarn.lock b/barretenberg/cpp/yarn.lock deleted file mode 100644 index fb57ccd13afb..000000000000 --- a/barretenberg/cpp/yarn.lock +++ /dev/null @@ -1,4 +0,0 @@ -# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. -# yarn lockfile v1 - - diff --git a/barretenberg/ts/bootstrap.sh b/barretenberg/ts/bootstrap.sh new file mode 100755 index 000000000000..8b2d5b76c667 --- /dev/null +++ b/barretenberg/ts/bootstrap.sh @@ -0,0 +1,22 @@ +#!/bin/bash +set -eu + +cd "$(dirname "$0")" + +CMD=${1:-} + +if [ -n "$CMD" ]; then + if [ "$CMD" = "clean" ]; then + git clean -fdx + exit 0 + else + echo "Unknown command: $CMD" + exit 1 + fi +fi + +yarn install --immutable +yarn build + +# Make bin globally available. +npm link diff --git a/barretenberg/ts/package.json b/barretenberg/ts/package.json index d134c8dd7d49..23fe1cb7262c 100644 --- a/barretenberg/ts/package.json +++ b/barretenberg/ts/package.json @@ -12,9 +12,7 @@ "default": "./dest/node/index.js" } }, - "bin": { - "bb.js": "./dest/node/main.js" - }, + "bin": "./dest/node/main.js", "files": [ "src/", "dest/", diff --git a/barretenberg/ts/scripts/cjs_postprocess.sh b/barretenberg/ts/scripts/cjs_postprocess.sh index 0c2d37565bfd..ccfcfc2d8a20 100755 --- a/barretenberg/ts/scripts/cjs_postprocess.sh +++ b/barretenberg/ts/scripts/cjs_postprocess.sh @@ -10,5 +10,5 @@ DIR="./dest/node-cjs" # Iterate over all .js files in the directory for FILE in $(find "$DIR" -name "*.js"); do # Use sed to replace 'import.meta.url' with '""' - sed -i 's/import\.meta\.url/""/g' "$FILE" + sed -i.bak 's/import\.meta\.url/""/g' "$FILE" && rm "$FILE.bak" done \ No newline at end of file diff --git a/bootstrap.sh b/bootstrap.sh index 55ee1711eaba..709c0129c491 100755 --- a/bootstrap.sh +++ b/bootstrap.sh @@ -8,14 +8,10 @@ # ./bootstrap.sh clean set -eu -export CMD=${1:-} - cd "$(dirname "$0")" -# Bump this number to force a full bootstrap. -VERSION=1 +CMD=${1:-} -# Remove all untracked files and directories. if [ -n "$CMD" ]; then if [ "$CMD" = "clean" ]; then echo "WARNING: This will erase *all* untracked files, including hooks and submodules." @@ -24,55 +20,51 @@ if [ -n "$CMD" ]; then if [ "$user_input" != "y" ] && [ "$user_input" != "Y" ]; then exit 1 fi - rm -f .bootstrapped + + # Remove hooks and submodules. rm -rf .git/hooks/* rm -rf .git/modules/* - git clean -fd for SUBMODULE in $(git config --file .gitmodules --get-regexp path | awk '{print $2}'); do rm -rf $SUBMODULE done + + # Remove all untracked files, directories, nested repos, and .gitignore files. + git clean -ffdx + + exit 0 else - echo "Unknown command: $CLEAN" + echo "Unknown command: $CMD" exit 1 fi fi -if [ ! -f ~/.nvm/nvm.sh ]; then - echo "Nvm not found at ~/.nvm" - exit 1 -fi +# if [ ! -f ~/.nvm/nvm.sh ]; then +# echo "Nvm not found at ~/.nvm" +# exit 1 +# fi # Install pre-commit git hooks. HOOKS_DIR=$(git rev-parse --git-path hooks) echo "(cd barretenberg/cpp && ./format.sh staged)" > $HOOKS_DIR/pre-commit echo "(cd circuits/cpp && ./format.sh staged)" >> $HOOKS_DIR/pre-commit -# TODO: Call cci_gen to ensure .circleci/config.yml is up-to-date! chmod +x $HOOKS_DIR/pre-commit git submodule update --init --recursive -# Lightweight bootstrap. Run `./bootstrap.sh clean` to bypass. -# TODO: We shouldn't do this here. We should call each projects bootstrap script and it should decide between light/heavy. -if [[ -f .bootstrapped && $(cat .bootstrapped) -eq "$VERSION" ]]; then - echo -e '\033[1mRebuild L1 contracts...\033[0m' - (cd l1-contracts && .foundry/bin/forge build) +PROJECTS=( + barretenberg + noir + circuits/cpp + l1-contracts + yarn-project +) - echo -e '\n\033[1mUpdate npm deps...\033[0m' - (cd yarn-project && yarn install) - - echo -e '\n\033[1mRebuild Noir contracts...\033[0m' - (cd yarn-project/noir-contracts && yarn noir:build:all 2> /dev/null) - - echo -e '\n\033[1mRebuild barretenberg wasm...\033[0m' - (cd barretenberg/cpp && cmake --build --preset default && cmake --build --preset wasm && cmake --build --preset wasm-threads) - - echo -e '\n\033[1mRebuild circuits wasm...\033[0m' - (cd circuits/cpp && cmake --build --preset wasm -j --target aztec3-circuits.wasm) -else - # Heavy bootstrap. - barretenberg/bootstrap.sh - circuits/cpp/bootstrap.sh - yarn-project/bootstrap.sh - - echo $VERSION > .bootstrapped -fi +for P in "${PROJECTS[@]}"; do + echo "**************************************" + echo -e "\033[1mBootstrapping $P...\033[0m" + echo "**************************************" + echo + $P/bootstrap.sh + echo + echo +done \ No newline at end of file diff --git a/bootstrap/Dockerfile.alpine b/bootstrap/Dockerfile.alpine new file mode 100644 index 000000000000..81661fd5a70d --- /dev/null +++ b/bootstrap/Dockerfile.alpine @@ -0,0 +1,25 @@ +# At present this doesn't work, as we don't have an alpine wasm toolchain we can use (or it's not directly obvious). +# Keeping this around though, as it would be nice to resolve this in the future. +FROM alpine:latest +RUN apk update && apk add --no-cache \ + build-base \ + curl \ + git \ + cmake \ + lsb-release \ + wget \ + gnupg \ + ninja \ + npm \ + pkgconf \ + openssl-dev \ + jq \ + llvm \ + clang \ + rust \ + cargo \ + bash +RUN npm install -g yarn +WORKDIR /usr/src +COPY . . +RUN ./bootstrap.sh \ No newline at end of file diff --git a/bootstrap/Dockerfile.lunar b/bootstrap/Dockerfile.lunar new file mode 100644 index 000000000000..daf60c11b61e --- /dev/null +++ b/bootstrap/Dockerfile.lunar @@ -0,0 +1,23 @@ +FROM ubuntu:lunar +ENV DEBIAN_FRONTEND=noninteractive +RUN apt update && apt install -y \ + build-essential \ + curl \ + git \ + cmake \ + lsb-release \ + wget \ + software-properties-common \ + gnupg \ + ninja-build \ + npm \ + pkg-config \ + libssl-dev \ + jq +RUN wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh && ./llvm.sh 16 +RUN curl https://sh.rustup.rs -sSf | sh -s -- -y +ENV PATH="/root/.cargo/bin:${PATH}" +RUN npm install -g yarn +WORKDIR /usr/src +COPY . . +RUN ./bootstrap.sh \ No newline at end of file diff --git a/bootstrap/bootstrap_test.sh b/bootstrap/bootstrap_test.sh new file mode 100755 index 000000000000..805f0d0ef0ed --- /dev/null +++ b/bootstrap/bootstrap_test.sh @@ -0,0 +1,31 @@ +#!/bin/bash +# This script takes the state of your current repository, and clones it inside of a docker container. +# You likely don't have a fresh clone, and it's paramount that to test bootstrapping, we don't have any +# intermediate build state in the context. +# To achieve this we mount your working directory into the container, and then perform the clone into the container. +# After cloning the repo we build the relevant dockerfile to bootstrap. +# "docker-in-docker" is achieved by mounting the host systems docker socket into the container. + +DOCKERFILE=${1:-Dockerfile.lunar} + +docker build -t bootstrap-build - < /dev/null 2>&1; done + +cd /project +docker build -f bootstrap/$DOCKERFILE . +" \ No newline at end of file diff --git a/build-system/scripts/build_local b/build-system/scripts/build_local index 4ef00589f920..b4572cecee0a 100755 --- a/build-system/scripts/build_local +++ b/build-system/scripts/build_local @@ -11,9 +11,10 @@ set -eu TARGET_PROJECT=${1:-} ONLY_TARGET=${ONLY_TARGET:-} +NO_CACHE=${NO_CACHE:-} MANIFEST="build_manifest.yml" -if [ -n "${NO_CACHE:-}" ]; then +if [ -n "$NO_CACHE" ]; then ADDITIONAL_ARGS="${ADDITIONAL_ARGS:-} --no-cache" fi @@ -93,15 +94,15 @@ for E in "${PROJECTS[@]}"; do # Ensure index is updated before we call git diff-index. git status > /dev/null - if (git diff-index --name-only HEAD; git ls-files --others --exclude-standard) | grep -qE "$GREP_PATTERN"; then + if (cd $(git rev-parse --show-toplevel) && git diff-index --name-only HEAD; git ls-files --others --exclude-standard) | grep -qE "$GREP_PATTERN"; then echo -e "${YELLOW}Project or dependency has local modifications! Building...${RESET}" docker build ${ADDITIONAL_ARGS:-} --build-arg ARG_COMMIT_HASH=$COMMIT_HASH -f $DOCKERFILE -t $DEPLOY_IMAGE_URI . else - if docker image ls --format "{{.Repository}}:{{.Tag}}" | grep -q -w $CACHE_IMAGE_URI; then + if [ -z "$NO_CACHE" ] && docker image ls --format "{{.Repository}}:{{.Tag}}" | grep -q -w $CACHE_IMAGE_URI; then echo -e "${GREEN}Image exists locally. Tagging as $DEPLOY_IMAGE_URI${RESET}" docker tag $CACHE_IMAGE_URI $DEPLOY_IMAGE_URI else - if ecr_login && image_exists $REPO $TAG ; then + if [ -z "$NO_CACHE" ] && ecr_login && image_exists $REPO $TAG ; then docker pull $CACHE_IMAGE_URI else docker build ${ADDITIONAL_ARGS:-} --build-arg ARG_COMMIT_HASH=$COMMIT_HASH -f $DOCKERFILE -t $CACHE_IMAGE_URI . diff --git a/build_manifest.yml b/build_manifest.yml index 53f1a8db4f1f..aa0e76eae93e 100644 --- a/build_manifest.yml +++ b/build_manifest.yml @@ -79,6 +79,8 @@ yarn-project-base: - circuits-wasm-linux-clang - l1-contracts - bb.js + - noir + - noir-packages yarn-project: buildDir: yarn-project @@ -165,3 +167,7 @@ docs: noir: buildDir: noir + +noir-packages: + buildDir: noir + dockerfile: Dockerfile.packages diff --git a/circuits/cpp/bootstrap.sh b/circuits/cpp/bootstrap.sh index 4c829a9570e1..6a64d541b7be 100755 --- a/circuits/cpp/bootstrap.sh +++ b/circuits/cpp/bootstrap.sh @@ -1,71 +1,27 @@ #!/bin/bash -# Takes a list of targets from commandline -# Takes CLEAN as an environment variable. If passed, cleans build artifacts set -eu -export WASI_VERSION=20 - -# Navigate to script folder cd "$(dirname "$0")" -# Update the submodule -git submodule update --init --recursive - -# Remove all untracked files and directories. -if [ -n "${CLEAN:-}" ]; then - # Clean. - rm -rf ./build - rm -rf ./build-wasm -fi - -# Determine system. -if [[ "$OSTYPE" == "darwin"* ]]; then - OS=macos -elif [[ "$OSTYPE" == "linux-gnu" ]]; then - OS=linux -else - echo "Unknown OS: $OSTYPE" - exit 1 -fi - -# Pick native toolchain file. -ARCH=$(uname -m) -if [ "$OS" == "macos" ]; then - if [ "$(which brew)" != "" ]; then - export BREW_PREFIX=$(brew --prefix) - - # Ensure we have toolchain. - if [ ! "$?" -eq 0 ] || [ ! -f "$BREW_PREFIX/opt/llvm/bin/clang++" ]; then - echo "Default clang not sufficient. Install homebrew, and then: brew install llvm libomp clang-format" - exit 1 - fi +CMD=${1:-} - PRESET=homebrew - else - PRESET=default - fi -else - if [ "$(which clang++-16)" != "" ]; then - PRESET=clang16 +if [ -n "$CMD" ]; then + if [ "$CMD" = "clean" ]; then + git clean -fdx + exit 0 else - PRESET=default + echo "Unknown command: $CMD" + exit 1 fi fi -echo "#################################" -echo "# Building with preset: $PRESET" -echo "# When running cmake directly, remember to use: --build --preset $PRESET" -echo "#################################" - -# Build native. -cmake --preset $PRESET -DCMAKE_BUILD_TYPE=RelWithAssert -cmake --build --preset $PRESET ${@/#/--target } +rm -f build-wasm/CMakeCache.txt # Build WASM. if [ -n "${WASM_DEBUG:-}" ] ; then cmake --preset wasm-dbg - cmake --build --preset wasm-dbg + cmake --build --preset wasm-dbg --target aztec3-circuits.wasm else cmake --preset wasm - cmake --build --preset wasm + cmake --build --preset wasm --target aztec3-circuits.wasm fi diff --git a/l1-contracts/bootstrap.sh b/l1-contracts/bootstrap.sh index 58aba5449eb3..9534d9399936 100755 --- a/l1-contracts/bootstrap.sh +++ b/l1-contracts/bootstrap.sh @@ -3,8 +3,20 @@ set -eu cd "$(dirname "$0")" +CMD=${1:-} + +if [ -n "$CMD" ]; then + if [ "$CMD" = "clean" ]; then + git clean -fdx + exit 0 + else + echo "Unknown command: $CMD" + exit 1 + fi +fi + # Clean -rm -rf broadcast cache out serve +git clean -fdx # Install foundry. . ./scripts/install_foundry.sh diff --git a/noir/.dockerignore b/noir/.dockerignore new file mode 100644 index 000000000000..25dd24f015c5 --- /dev/null +++ b/noir/.dockerignore @@ -0,0 +1,22 @@ +Dockerfile* +.dockerignore + +packages +**/package.tgz +**/target +**/node_modules +**/outputs + +# Source resolver +compiler/source-resolver/lib +compiler/source-resolver/lib-node + +# Noir.js +tooling/noir_js/lib + +# Wasm build artifacts +compiler/wasm/nodejs +compiler/wasm/web +tooling/noirc_abi_wasm/nodejs +tooling/noirc_abi_wasm/web +tooling/noir_js/lib \ No newline at end of file diff --git a/noir/.gitignore b/noir/.gitignore index 169353af2b68..a354669683b8 100644 --- a/noir/.gitignore +++ b/noir/.gitignore @@ -53,3 +53,6 @@ compiler/wasm/web tooling/noirc_abi_wasm/nodejs tooling/noirc_abi_wasm/web tooling/noir_js/lib + +**/package.tgz +packages \ No newline at end of file diff --git a/noir/Dockerfile b/noir/Dockerfile index 746efbe64c53..ac818cb8bd2a 100644 --- a/noir/Dockerfile +++ b/noir/Dockerfile @@ -2,14 +2,14 @@ FROM rust:alpine3.17 RUN apk update \ && apk upgrade \ && apk add --no-cache \ - build-base + build-base \ + bash WORKDIR /usr/src/noir COPY . . -RUN GIT_DIRTY=false \ - GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo) \ - cargo build --features="noirc_frontend/aztec" --release +RUN ./scripts/bootstrap_native.sh +# When running the container, mount the current working directory to /project. FROM alpine:3.17 -COPY --from=0 /usr/src/noir/target/release/nargo /usr/bin/nargo +COPY --from=0 /usr/src/noir/target/release/nargo /usr/src/noir/target/release/nargo WORKDIR /project -ENTRYPOINT ["/usr/bin/nargo"] \ No newline at end of file +ENTRYPOINT ["/usr/src/noir/target/release/nargo"] \ No newline at end of file diff --git a/noir/Dockerfile.dockerignore b/noir/Dockerfile.dockerignore deleted file mode 100644 index 521e73ea5bff..000000000000 --- a/noir/Dockerfile.dockerignore +++ /dev/null @@ -1,2 +0,0 @@ -target -Dockerfile* \ No newline at end of file diff --git a/noir/Dockerfile.packages b/noir/Dockerfile.packages new file mode 100644 index 000000000000..11737014e3d8 --- /dev/null +++ b/noir/Dockerfile.packages @@ -0,0 +1,19 @@ +FROM rust:alpine3.17 +RUN apk update \ + && apk upgrade \ + && apk add --no-cache \ + build-base \ + pkgconfig \ + openssl-dev \ + npm \ + yarn \ + bash \ + jq +WORKDIR /usr/src/noir +COPY . . +RUN ./scripts/bootstrap_packages.sh + +FROM scratch +COPY --from=0 /usr/src/noir/packages /usr/src/noir/packages +# For some unknown reason, on alpine only, we need this to exist. +COPY --from=0 /usr/src/noir/node_modules/@noir-lang /usr/src/noir/node_modules/@noir-lang \ No newline at end of file diff --git a/noir/bootstrap.sh b/noir/bootstrap.sh new file mode 100755 index 000000000000..bf672ac0ad2e --- /dev/null +++ b/noir/bootstrap.sh @@ -0,0 +1,19 @@ +#!/bin/bash +set -eu + +cd $(dirname "$0") + +CMD=${1:-} + +if [ -n "$CMD" ]; then + if [ "$CMD" = "clean" ]; then + git clean -fdx + exit 0 + else + echo "Unknown command: $CMD" + exit 1 + fi +fi + +./scripts/bootstrap_native.sh +./scripts/bootstrap_packages.sh \ No newline at end of file diff --git a/noir/docs/package.json b/noir/docs/package.json index 09f8d718b56a..db0efbe75430 100644 --- a/noir/docs/package.json +++ b/noir/docs/package.json @@ -13,6 +13,7 @@ "@docusaurus/preset-classic": "^2.4.0", "@easyops-cn/docusaurus-search-local": "^0.35.0", "@mdx-js/react": "^1.6.22", + "@noir-lang/noir_js": "workspace:*", "axios": "^1.4.0", "clsx": "^1.2.1", "docusaurus-plugin-typedoc": "1.0.0-next.18", diff --git a/noir/package.json b/noir/package.json index 0e86b100b7cd..bced1fb21e87 100644 --- a/noir/package.json +++ b/noir/package.json @@ -19,7 +19,7 @@ "test": "yarn workspaces foreach run test", "test:integration": "yarn workspace integration-tests test", "clean:workspaces": "yarn workspaces foreach --exclude @noir-lang/root run clean", - "clean:root": "rm -rf ./result ./target", + "clean:root": "rm -rf ./result ./target ./packages", "clean": "yarn clean:workspaces && yarn clean:root", "lint": "yarn workspaces foreach --verbose run lint", "install:acvm_js": "yarn workspace @noir-lang/acvm_js run install:from:nix", diff --git a/noir/scripts/bootstrap_native.sh b/noir/scripts/bootstrap_native.sh new file mode 100755 index 000000000000..26cd44704aa9 --- /dev/null +++ b/noir/scripts/bootstrap_native.sh @@ -0,0 +1,14 @@ +#!/bin/bash +set -eu + +cd $(dirname "$0")/.. + +# If this project has been subrepod into another project, set build data manually. +if [ -f ".gitrepo" ]; then + export SOURCE_DATE_EPOCH=$(date +%s) + export GIT_DIRTY=false + export GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo) +fi + +# Build native. +cargo build --features="noirc_frontend/aztec" --release \ No newline at end of file diff --git a/noir/scripts/bootstrap_packages.sh b/noir/scripts/bootstrap_packages.sh new file mode 100755 index 000000000000..98632a7c277e --- /dev/null +++ b/noir/scripts/bootstrap_packages.sh @@ -0,0 +1,30 @@ +#!/bin/bash +set -eu + +cd $(dirname "$0")/.. + +./scripts/install_wasm-bindgen.sh + +# If this project has been subrepod into another project, set build data manually. +if [ -f ".gitrepo" ]; then + export SOURCE_DATE_EPOCH=$(date +%s) + export GIT_DIRTY=false + export GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo) +fi + +export cargoExtraArgs="--features noirc_frontend/aztec" + +yarn +yarn build + +yarn workspaces foreach pack + +rm -rf packages && mkdir -p packages +tar zxfv acvm-repo/acvm_js/package.tgz -C packages && mv packages/package packages/acvm_js +tar zxfv compiler/source-resolver/package.tgz -C packages && mv packages/package packages/source-resolver +tar zxfv compiler/wasm/package.tgz -C packages && mv packages/package packages/noir_wasm +tar zxfv tooling/noir_codegen/package.tgz -C packages && mv packages/package packages/noir_codegen +tar zxfv tooling/noir_js/package.tgz -C packages && mv packages/package packages/noir_js +tar zxfv tooling/noir_js_backend_barretenberg/package.tgz -C packages && mv packages/package packages/backend_barretenberg +tar zxfv tooling/noir_js_types/package.tgz -C packages && mv packages/package packages/types +tar zxfv tooling/noirc_abi_wasm/package.tgz -C packages && mv packages/package packages/noirc_abi \ No newline at end of file diff --git a/noir/scripts/install_wasm-bindgen.sh b/noir/scripts/install_wasm-bindgen.sh new file mode 100755 index 000000000000..5e9f91275063 --- /dev/null +++ b/noir/scripts/install_wasm-bindgen.sh @@ -0,0 +1,10 @@ +#!/bin/bash +set -eu + +cd $(dirname "$0")/.. + +# Install wasm-bindgen-cli. +if [ "$(wasm-bindgen --version | cut -d' ' -f2)" != "0.2.86" ]; then + echo "Building wasm-bindgen..." + RUSTFLAGS="-Ctarget-feature=-crt-static" cargo install -f wasm-bindgen-cli --version 0.2.86 +fi diff --git a/noir/yarn.lock b/noir/yarn.lock index 9c6a447d718a..6ae655f8ce2c 100644 --- a/noir/yarn.lock +++ b/noir/yarn.lock @@ -8290,6 +8290,7 @@ __metadata: "@docusaurus/preset-classic": ^2.4.0 "@easyops-cn/docusaurus-search-local": ^0.35.0 "@mdx-js/react": ^1.6.22 + "@noir-lang/noir_js": "workspace:*" axios: ^1.4.0 clsx: ^1.2.1 docusaurus-plugin-typedoc: 1.0.0-next.18 diff --git a/yarn-project/Dockerfile b/yarn-project/Dockerfile index 6a87e5515afb..c450af53b178 100644 --- a/yarn-project/Dockerfile +++ b/yarn-project/Dockerfile @@ -10,6 +10,7 @@ COPY . . RUN yarn workspace @aztec/foundation build && \ yarn workspace @aztec/noir-compiler build && \ yarn workspace @aztec/noir-contracts noir:build:all && \ + yarn workspace @aztec/noir-protocol-circuits noir:build && \ yarn tsc -b # Build aztec.js web artifact diff --git a/yarn-project/acir-simulator/package.json b/yarn-project/acir-simulator/package.json index f5c2a79bfbc6..848a5ad4ae29 100644 --- a/yarn-project/acir-simulator/package.json +++ b/yarn-project/acir-simulator/package.json @@ -33,7 +33,7 @@ "@aztec/circuits.js": "workspace:^", "@aztec/foundation": "workspace:^", "@aztec/types": "workspace:^", - "@noir-lang/acvm_js": "0.30.0", + "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js", "levelup": "^5.1.1", "memdown": "^6.1.1", "tslib": "^2.4.0" diff --git a/yarn-project/aztec.js/src/artifacts/ecdsa_account_contract.json b/yarn-project/aztec.js/src/artifacts/ecdsa_account_contract.json index 07acc599ae6d..4fef4336d457 100644 --- a/yarn-project/aztec.js/src/artifacts/ecdsa_account_contract.json +++ b/yarn-project/aztec.js/src/artifacts/ecdsa_account_contract.json @@ -84,7 +84,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -147,7 +147,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -164,7 +164,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { diff --git a/yarn-project/aztec.js/src/artifacts/schnorr_account_contract.json b/yarn-project/aztec.js/src/artifacts/schnorr_account_contract.json index 567de36fa739..04edcd07a3aa 100644 --- a/yarn-project/aztec.js/src/artifacts/schnorr_account_contract.json +++ b/yarn-project/aztec.js/src/artifacts/schnorr_account_contract.json @@ -135,7 +135,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { diff --git a/yarn-project/aztec.js/src/artifacts/schnorr_single_key_account_contract.json b/yarn-project/aztec.js/src/artifacts/schnorr_single_key_account_contract.json index e987e31dfcc4..67f2ef0ed0b4 100644 --- a/yarn-project/aztec.js/src/artifacts/schnorr_single_key_account_contract.json +++ b/yarn-project/aztec.js/src/artifacts/schnorr_single_key_account_contract.json @@ -70,7 +70,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "H4sIAAAAAAAA/+1dB3gU1fed3U2jN6ULSBcsO8mSBAtSFLtiRQTFtAU0dEIRBFQUBQuKDRuiIlbsDRWwoqBi7w0VG6Jir/i/D878mGyibtx79z/3m5nvO9/JJi9v321vzsy8mXkvx7IOybL+t4XAvcHR1DY7k/rIrKbfvGh+LFZWkFtm59lF0dyexYU9orEexfmFdqHdo7BHaW5hXl5ZYaywoGdxz4JoTzuWV2bHe/TMi6PjTL4xRiXsNi7NErA7y+N2Z1Mf2QJ2Z3vc7pbUR0sBu1t63O421EcbAbvbeNzu9tRHewG723vc7s7UR2cBuzsz2+1s3OPsyjhOMzYzr7VDf80ImwnNwS3ALcGtwK3BO4DbgNuC24F3BLcHdwB3BHcCdwZ3AXf9f+KdCTshZsYvDeGXnTwwrm6ucTXyWLxM++6EiLUt390b9xzQna+vaIZrnDuDd8GYne/YlbCb+S6CTcgl5BFihB6EfEIBoZDQk7A7YQ/CnoS9CL0Ie6O/PoS+hH6EfQj7EvoT9iPsTziAcCDhIMLBhEMIhxIOIwwgHE44gnAk4SjC0YRjCAMJxxIGEY4jDCYMIRxPOIEwlHAioYhQTCghlBLKCHHCMMJwwgjCSYSTCeWEkfDBKMIkBLIWIWxV3lwSni021enXaIpbJsZvudhy2VPL9Z0Rq6q9Ga7fOX/PBNcn1KmmzyzX//XmscNOrLPerp+d73KPJeKhsYT+n8fijrHl+p3zd3cuJMbdxHqMqw4yq/kfd9vEdm7bswRsd39Pb9dn57tqu8aQ6YGxRDw0lnA1Y8nmHUtuLavyXOmMyb31dv2c7RpLLdaxxKKmv5wajKWWayy1Wceyda6vw9yn6aOua/yOrc7Y67j+XsdlW13ecWzJv9pWZZ86n93jC8YajDUYazDWYKzBWIOxBmMNxhqMNRhrMNZgrMFYg7EGYw3GGow1GGsw1mCswViDsQZjDcYajDUYazDWYKzBWIOxBmMNxhqMNRhrMNZgrMFYg7EGYw3G6u+x1nL9Luv/eSx1XGPIERtLLFqnmu+WWK/svv/D6dus+88LbftO3rXjsah7HbtzH7YzBue7Iq42B4a2jatAbFxb11m715FnJIyptmtM7tjzrmeP2s53JY6jlmscifVa20pHjcTMLWNWvWrGVtc1Dme+qOcat/Oz+16S+gm+NL9r4OrH+Z1z/2Id1+/C1XyHk0P1Xb9zxtfA9TtnDE6/2Vbl2Lr954ytNzia2pbr3PtoufqNJPiBIafsxF+45zbTfx/XOJzvirjaHB6q7N/q8tFdF7US2kncB5E4P+e4vlduH7X1/pI6VuUtlPC5t+tn93xdn3UsW33QwNV/b9d3uL+3Ie/32u7vDQHOdzi/j7h+LnU5qOG2HyvdY2g2E8961bRz/1wn4X/quP5eT9jm+q5x9HZ9dr7L1MIgl631qhl3xPU5sZ6yXL/rzTjuugnjjiSMzz3/uue7BgJj+TsfNnD5Jcv1s8xYtmqqxO927zccnyXqH957O2N57u90tmTu98xxjX9Y2YQ+FROGDxwxYVTZ+PEhVy9Oz/2q6TnsstqpxOruDnb+lm1Vcyd8b4vDDVE7nNC5l2+vb4d+RhPGEMYSxhHGEyYQKggTCZMIkwlTCKcQphKmEU4lTCfMIMwknEY4nXAGYRbhTMJZhNmEswnnEOYQ5hLOJZxHOB9OCiFQZiw51rbPYxI+j034PC7h8/iEzxMSPlckfJ6Y8HlSwufJCZ+nJHw+JeHz1ITP0xI+n5rweXrC5xkJn2cmfD4t4fPpCZ/PSPg8K+HzmQmfz0r4PDvh89kJn89J+Dwn4fPchM/nJnw+L+Hz+VblwxOzOcXbGxxNbatUM6k+4mU0Y18ts3kP8/7Of/91nGVxs0XtMUx9mViMZfRfK8/7b0vX9rjU+8qFzfZ4Rv+19rL/Yv8bpz0htb6iLpvtCkb/7eBV/+VWGqc98b/3FU2w2Z7E6L82HvRffrzKOO3J/62vwmpstqcw+q+t1/xXWO047VNq3lfB39hsT2X0Xzsv+a/gb8dpT6tZX7n/YLN9KqP/dvSK/wr+cZz29OT7KvkXm+0ZjP5r7wX/FfzrOO2ZyfUVTcJm+zRG/3X4//ZfNKlx2qf/e189krTZPoPRfx3/P/0XS3qc9qx/7CsWr4HN9pmM/uv0/+W/ghqN0z7r7/sqrKHN9mxG/3X+f/Bfz3iNx2mfXX1f0f9gs30Oo/+6pNt/0f80TntO1b7s/2izPZfRf13T6b/S/zxO+9zKfeWlYLN9HqP/dkqT/3LjKY3TPt/iO5foPmeXqv+6pcl/0dQ2m/E8m92a0X/dlfiP8TyR3YbRfzsr8R/jeQ67HaP/dlHiP8bjdLs9o/92VeI/xuNMuyOj/3ZT4j/G4yS7M6P/okr8x6jz7a6M/rOV+I9Rp9rdGP2Xq8R/jDrL3pnRf3lK/MeoE+xdGf0XU+I/xv2cHWX0Xw8l/mOcp+1cRv/lK/Ef4zxjxxj9V6DEf4x1YjPmjM3pP+f2n52tra9d2gXs9G9eU2TWue0GjoJtcC44DxwD9wDngwvAheCe4N3Be4D3BO8F7gXeG9wb3AfcF9wPvA94X3B/8H7g/cEHgA8EHwQ+GHwI+FDwYeAB4MPBR4CPBB8FPhp8DHgg+FjwIPBx4MHgIeDjwSeAh4JPBBeBi8El4FJwGTgOHgYeDh4BPgl8MrgcPBLcztq6OesdnXWQzvpIZ92ks57SWWd5Nng22Fmv6azjdNZ3Ous+Twc760Rngp11pc56U2cdqrM+1Vm36qxndda5OutfnXWxznpZZx2ts77WWXfrrMd11uk663eddb0XWJU37vXRF1h886tzW5MzHybW9iiwWXY/L8GucIJdqY4lzOijeXx9RdP1WrkWFu9c7WwXWlVfLWVZlV/JxW2LlfA9if6rbwneoCAVnAsF+r3I4isgKbsv4o9RJTHGPZFw+nQ+oy9NISTePyQVM6a+opLjbK5knM0s/onZsHNP38WESwiXEi4jXE5YQLiCcCXhKsLVhGsICwnXWpXvg6vuvYGRBF9of2dmjssOK8He+pbIe/tK3XfbWQn+TPSb259mrC3wc9mosRVlFWUDKorLR5T0rxhVMmHE6FH9isrL3YngfImTEJFqjEz8vfvhAs4N3e6b9J3/y3ZxiLsyzOzY0qrqjWiKW8Sqmq2OszjHf6klMwMx+yPX7YtF4Ousym+VdNqYxPirGp+FXD+H0Sb8D21Cf9PP31WgmJxzjDOG/5kwGK7vuA4OTew3VflwnSWTYNznry5lsHnrvXTx+CIF/gsz+4/T5utdfdmFebm5BXmmXWEpnVotLcktzM0tLY5FS6JFJbllPWN2z3gsN5ZXUlpSTH0W2fFovKikZ7xw67jSdex6PV9flY5db7CCY1eW4Nwg0O9iy9vHrsbuxfwxqnasHBPdYoF+b7R4C9MU4Y3gdKm0yyyZnQBzXlRSaUvAN1k+U2nGcCmVdhMcyl0kN1kyCcat0i5jsNlRaUsU+I9bpXHafLOlT6XdbPHuDJztFitQaSzBuUWg31stb6s0Y/et/DESUWk3Yazc/d5m8RamKcLbrPSqtMstmZ0Ac15UUmm3g5daPlNpxnAplbYUDuUukqWWTIJxq7TLGWx2VNrtCvzHrdI4bb7D0qfS7rB4dwbOdqcVqDSW4Nwp0O9dlrdVmrH7Lv4Yiai0pRgrd793W7yFaYrwbiu9Ku1qS2YnwJwXlVTaPeB7LZ+pNGO4lEq7Fw7lLpJ7LZkE41ZpVzPY7Ki0exT4j1ulcdp8n6VPpd1n8e4MnO1+K1BpLMG5X6DfByxvqzRj9wP8MRJRafdirNz9PmjxFqYpwget9Kq0ayyZnQBzXlRSaQ+Bl1k+U2nGcCmVtgwO5S6SZZZMgnGrtGsYbHZU2kMK/Met0jhtftjSp9Ietnh3Bs72iBWoNJbgPCLQ76OWt1WasftR/hiJqLRlGCt3v8st3sI0RbjcSq9KW2jJ7ASY86KSSlsBXmn5TKUZw6VU2ko4lLtIVloyCcat0hYy2OyotBUK/Met0jhtfszSp9Ies3h3Bs72uBWoNJbgPC7Q7xOWt1WasfsJ/hiJqLSVGCt3v09avIVpivBJq6py4IqZuRd1voAfnhKOfzS1bcsd/08J2H1Mtrfz/mIhuwdm6xAOjPGxB2Z7O8ebC8X6OI/n+CVCdg9WkuOM8bEHezzHmwnF+gSP5/i1QnYPVZLjjPGxh3o8x+9FrC3efkXGukzRWFemcawcj/qTqPdij+f+AiG7S5TMc4zxsUs8HusrhGIdT1OsPXTsaMeZH2NsHoblnBg0+to84vQ68E3gpeDahKcRx2xr2wO1FuDvV4CvBF8Fvhe8DLwS3IiwytWfczKyK/6eyOaKyTM1bP9sDduvrmH7NTVs/1wN2z9fw/Yv1LD92hq2f7GG7V+qYfuXa9j+lRq2f7WG7V+rYfvXa9j+DVf78N+0zyG8mWS7t5Js93aS7d5Jst27SbZ7L8l27yfZ7oMk232YZLt1Sbb7KMl2HyfZ7pMk261Pst2nSbb7zNVuINqtwt+vtarP20R+BvwseDV4Dfg58PPgF8BrwS+CXwK/DH4F/Cr4NfDr4DfAb4LfAr8Nfgf8Lvg98PvgD8AfgteBPwJ/DP4EvB78KfizJP0TcHq4O+Fzq+r8ezH+/jT4c3BjwhdW5Y1b+7Vk7OtLi09HBk9grjxOvz+BeRF+3kD4irCR8DXhG8K3hE2E7wjfE34g/Ej4ifAz4RfCr4TfCL8T/rC2LjAyNfYXvsA8cDdMiBAyCJmELEI2IYdQi1CbUIdQl1CPUJ/QgNCQ0IjQmNCEsB1he0JTQjNCc0ILQktCK0Jrwg6ENoS2hHaEHQntCR0IHQmdCJ0JXQhdCTsRuhG6E3Ym7ELYlbAbwTjKrJ7KJeQRYoQehHxCAaGQ0JOwO2EPwp6EvQi9CHsTehP6EPoS+hH2IexL6E/Yj7A/4QDCgYSDCAcTDiEcSjiMMIBwOOEIwpGEowhHE44hDCQcSxhEOI4wmDCEcDzhBMJQwomEIkIxoYRQSigjxAnDCMMJIwgnEU4mmCcyjySMIowmjCGMJYwjjCdMIFQQJhImESYTphBOIUwlTCOcSphOmEGYSTiNcDrhDMIswpmEswizCWcTziHMIcwNBU/0dtsr80TvIjuVJ3o3wc8lReXlA8aNmFg0ocx5nnfI1ZXT/SKwqmd5f2lV9UM0xS1dq3E3WjL7MmZ/VFqNey6ccF7IZ6txjeFSq3GNMw0S+01ViJo+mcYouhp3I4PNzmrcc0Pe9x/3RQpOm8939aVlNe75jHFyj/eCULAalyU4F4T4+53HmPRSds8LscdI5Or2eRgrd78XMhemKULTZ9hK3z1TX1syOwHmvKik0i6CE+b7TaVdJKjSjDPnCxTJfCUq7WsGmx2VdlHI+/7jVmmcNl+sUKVdLKTSLglUGk9wLhFQaZd6XKUZuy9VotLmY6zc/V4moNIuS7NK+8aS2Qkw50UllXY5nLDAbyrtckGVZpy5QKBIFihRad8w2OyotMtD3vcft0rjtPkKhSrtCiGVdmWg0niCc6WASrvK4yrN2H2VEpW2AGPl7vdqAZV2dZpV2g+WzE6AOS8qqbRr4ISFflNp1wiqNOPMhQJFslCJSvuBwWZHpV0T8r7/uFUap83XKlRp1wqptEWBSuMJziIBlXadx1Wasfs6JSptIcbK3e/1Airt+jSrtB8tmZ0Ac15UUmk3wAmL/abSbhBUacaZiwWKZLESlfYjg82OSrsh5H3/cas0TptvVKjSbhRSaUsClcYTnCUCKu0mj6s0Y/dNSlTaYoyVu9+bBVTazWlWaT9ZMjsB5ryopNJugRNu9ZtKu0VQpRln3ipQJLcqUWk/MdjsqLRbQt73H7dK47T5NoUq7TYhlXZ7oNJ4gnO7gEpb6nGVZuxeqkSl3Yqxcvd7h4BKuyPNKm2u0E6AOS8qqbQ74YS7/KbS7hRUacaZdwkUyV1KVNpchgnXUWl3hrzvP26Vxmnz3QpV2t1CKu2eQKXxBOceAZV2r8dVmrH7XiUq7S6Mlbvf+wRU2n0huTeuOE8N4fbD/SHZ+EdT27Y84et+gfgP9/iT+jcI2T0iW4dwYIyPPSLb2zneXCjW5R7P8a+E7B6pJMcZ42OP9HiONxOK9RiP5/jPQnaPVZLjjPGxx3o8x41WvT9Nujqa2rZlKbuWsS5WNNZb0zhWjrfDSMxNEzxep98K2V2hZE5mjI9d4fFYbxKK9WQlb4fhPI7itNnEw/12GHMsYJ7obJ7pZXg+eAHYvB3mAcTR/XaYb/F/m8Dfgb8HL8T/LwbfCjZvh3nQ1Z/zBNoz8PdZ4DPBZ4Fng88G1yU85OpnHvp5EH//GeP4Bfwr+Dfw7+A/wM6TrR38BbbQXwgcBkfAGeBMcBY4G5wDruX4E1zHsQNcD1wf3ADc0PEbuDG4CXg78PbgpuBm4ObgFuCW4Fbg1uAdwG3AbcHtwDuC24M7gDuCO4E7g7uAu4J3AncDdwfvDN4FvCt4N3AUbINzwXngGLgHOB9cAC4E9wTvDt4DvCd4L3Av8N7g3uA+4L7gfuB9wPuC+4P3A+8PPgB8IPgg8MHgQ8CHgg8DDwAfDj4CfCT4KPDR4GPAA8HHggeBjwMPBg8BHw8+ATwUfCK4CFwMLgGXgsvAcfAw8HDwCPBJ4JPB5eCR4FHg0eAx4LHgceDx4AngCvBE8CTwZPAU8CngqeBp4FPB08EzwDPBp4FPBz8EPgc8x8lvwrLQtnnJuTBkziuavz+AdsuceiY8HNraBsS23/gSfSf2m+q+7ZGQt7WHeTvHFxa/3Y8y2p2uC6E7WLzawdmWh4ILoSzBWR7i73dFyNsXQo3dK0LsMRIV9Jw+Xck3kaTtlT+cE4nkOFsrGWcri39iNlwPPz9GHx4nPEF4kvAU4WnCKsIzhGcJqwlrCM8Rng8Fr2hx2yvzipZoaSqvaGmBn8tGja0oqygbUFFcPqLEeUlLv6LycnciOF/iJISaF7WY2bGNVdUb0RS3dC3ifSIkMwMx+6PSIt4X4IS1IZ8t4jWGSy3iNc5cK3D8tVYowbgX8T7BIJmcRbwvhLzvP+7rBZw2v+jqS8si3hcZ4+Qe70vBsStPcF4SOHZ92ePHrsbul4WOXSV2FC8L7IBeYS5MU4Smz7CVvlutnlSo0l6FE17zm0p7VVClGWe+JlAkrylRaU8yqrRXQ973H7dK47T5dYUq7XUhlfZGoNJ4gvOGgEp70+Mqzdj9phKV9hrGyt3vWwIq7a00q7SnFKq0t+GEd/ym0t4WVGnGme8IFMk7SlTaU4wq7e2Q9/3HrdI4bX5XoUp7V0ilvReoNJ7gvCeg0t73uEozdr+vRKW9g7Fy9/uBgEr7IM0qbbVClfYhnLDObyrtQ0GVZpy5TqBI1ilRaasZVdqHIe/7j1ulcdr8kUKV9pGQSvs4UGk8wflYQKV94nGVZuz+RIlKW4excve7XkClrU+zSlujUKV9Cid85jeV9qmgSjPO/EygSD5TotLWMKq0T0Pe9x+3SuO0+XOFKu1zIZX2RaDSeILzhYBK+9LjKs3Y/aUSlfYZxsrd7wYBlbYhzSrtOYUq7Ss4YaPfVNpXgirNOHOjQJFsVKLSnmNUaV+FvO8/bpXGafPXClXa10Iq7ZtApfEE5xsBlfatx1WasftbJSptI8bK3e8mAZW2KST3CHBzL+pKAT98F5KNfzS1bcsd/98J2H2Kxx8da+6cl7B7qpLHFDLGx57q8ccUthbK8ekez/HHhXJ8hpIcZ4yPPcPjOd5KKMdP93iOPy+U42coyXHG+NhneDzH1yHWFm+/ImP9TNFYN6ZxrByP1Zao97M8nvtPC81zs5XMc4zxsWd7PNarhGI9R8ljtTmPTeYIPlbb6GvzeNe14NfA74DNY7W/Rxzdj9V+Gn9fBX4G/Cx4Hfgz8Eaweaz2D67+nJORXS08hjmBzRWTH2vY/qcatv+5hu1/qWH7X2vY/rcatv+9hu3/qGH7P2vYfnMN2/9Vw/amWGvSPlTD9uEato/UsH2Gq334b9rnEDKTbJeVZLvsJNvlJNmuVpLtaifZrk6S7eom2a5eku3qJ9muQZLtGibZrlGS7Ron2a5Jku22c7UbiHY/YH5+PlR93ibyj2j3E/hn8C/gX8G/gX8H/wH+E7wZ/BfYDNxwCBwGR8AZ4ExwFjgbnAOuBa4NrgOuC64Hrg9uAG4IbgRuDG4C3i6cnH8CTg93J2xfzfz7GPLpe/D2TjwJTcNVV8lw61/zOtaWrv6Z+uVcKWMn/sLtj2b40Dzss5UyxvDlLmONA3onDI7rO02CzLf4D5LOFTpIiqQ2zmjCOO1mYT6b3XGKprbZUv7jPqHA6b8W/9BXYUFZcbwgllcUjcWLqZ/8eFleUW5PO16YR93nxeziorJoaay4ID+WXxgvSNs7I1rwxbzSypmW4WDlDEtwWoYFrhIxJr2U3a3C7DESORPdHGPl7vf8NO2AojXcEsfJmUutGXdAnP5zhIwZXx8rfevDU9khxytvJdUMV0T17oAPbf5B9fatxmeJqrev9e+qt7p+/lX1cgfJ80u7wluDwj1B7RDmL7A2KDD3xr3WnDFedhvGya8tX7HHHX+25fdnleJnzANWf7YL89als3EfgTRntHlH5h0G95xhaq+dwFw0z+OXco3dOwrYfaGSo2zG+Njpsplz/5hqX+0Z51ip/G4flpkvOGMtcYr60RC/3R0Y911GhJuzLc7ZGNO3OfXvwL1x29GROW+lxtmJb5y5kuPszDfOPMlxduEbZ8zkr7ks5RxMmpw1eWViZvzRJVy9DdHUNrErC13D3tcqXQXm8p0Y7c6wti2jcm+cfpXw7U5h74+xG/cYJRK0m0CCdmdOUPfbUbUkaHcFCbqzwBi3bGHmhHKr11T72kXBEYBEUe6qYG/ZVMDuiz1+RsMU4S4Cdl/izXUXVca5G2M9Msba5vSf8E7sf0d03LnJPWdIjHG3sKVjJ9aGsa8oY9GYgo5YVTf2y2eWTKC4x9layThbMY7TfS14EX62KcfMA8vyCDFCD0I+oYBQSOhJ2J2wB2FPwl6EXoS9TW4S+hD6EvoR9iHsS+hP2I+wP+EAwoGEgwgHEw4hHEo4jDCAcDjhCMKRhKMIRxOOIQwkHEsYRDiOMJgwhHA84QTCUMKJhCJCMaGEUEooI8QJwwjDCSMIJxFOJpQTRhJGEUYTxhDGEsYRxhMmECoIEwmTCJMJUwinEKYSphFOJUwnzCDMJJxGOJ1wBmEW4UzCWYTZhLMJ5xDmEOYSziWcRzifcAFhHuFCwkWE+YSLCZcQLiVcRricsIBwBeFKwlWEqwnXEBYSriUsIlxHuJ5wA2Ex4UbCEsJNhJsJtxBuJdxGuJ2wlHAH4U7CXYS7CfcQ7iXcR7if8ADhQcJDhGWEhwmPEB4lLCesIKwkPEZ4nPAE4UnCU4SnCasIzxCeJawmrCE8R3ie8AJhLeFFwkuEBsjFLXeq4Oew63eRhNqqZVVdT+Le8fZmqheBRXdbTi/nuOywEuytD1uyWL+3yDbflWlV3hIX9/Wuxp9b7vLAzyVF5eUDxo2YWDShrH/FqJIJI0aPck8pTvfO1BKpxrzE32e4XOGcocp0/c75v2wXh7jn2JXUoXtRDlO/0XStezJzN9eYqxkuV9+Vnov5Mj68EvbZan9juNRzMY0zDbiPMl8RSjDutUruQkj1uZgvh73vvzCz/zhtftXVl5bnYr7KGCf3eF8LB6v7WYLzWpi/39cZk17K7tcF1El1Y+WY6F4X2AG9wVyYxp2mz7CVvtXpMYUq7U18eMtvKu1NQZVmnPmWQJG8pUSlxRhV2pth7/uPW6Vx2vy2QpX2tpBKeydQaTzBeUdApb3rcZVm7H5XiUp7C2Pl7vc9AZX2XppVWg+FKu19fPjAbyrtfUGVZpz5gUCRfKBEpfVgVGnvh73vP26VxmnzhwpV2odCKm1doNJ4grNOQKV95HGVZuz+SIlK+wBj5e73YwGV9nGaVdruClXaJ/iw3m8q7RNBlWacuV6gSNYrUWm7M6q0T8Le9x+3SuO0+VOFKu1TIZX2WaDSeILzmYBK+9zjKs3Y/bkSlbYeY+Xu9wsBlfZFmlXaHgpV2pf4sMFvKu1LQZVmnLlBoEg2KFFpezCqtC/D3vcft0rjtPkrhSrtKyGVtjFQaTzB2Sig0r72uEozdn+tRKVtwFi5+/1GQKV9k2aVtqdClfYtPmzym0r7VlClGWduEiiSTUpU2p6MKu3bsPf9x63SOG3+TqFK+05IpX0fqDSe4HwvoNJ+8LhKM3b/oESlbcJYufv9UUCl/ZhmlfaSQpX2Ez787DeV9pOgSjPO/FmgSH5WotJeYlRpP4W97z9ulcZp8y8KVdovQirt10Cl8QTnVwGV9pvHVZqx+zclKu1njJW7398FVNrv4arKgStmK0NbnxrC7Yc/wrLxj6a2bXnC1x8Cdl+e7e28N0/KkrB7gZKXUjDGx17g8cd1thbK8as8nuO5Qjl+tZIcZ4yPfbXHc7yVUI5f6/Ec30soxxcpyXHG+NiLPJ7jPyPWFm+/ImNdr2isGxSNdVMax5rqHGKGKTE33eDxOs0XmpMXK5mTGeNjL/Z4rAuEYn2TkhfdcR5H3cT81mbzeFXnJKY5FthsbX2gpOG3wB+AaxP+RByzrW2PaM3H3wvAheCe4PXgDeBN4EaEza7+nCfQPou/rwavAT8Hfh78Argu4S9XP/PQz2b8fS9wL/De4N7gPuC+4H7gfcD7gvuD9wPvDz4AfCD4IPDB4EPAh4IPAw8AHw4+Anwk+Cjw0eBjwAPBx4IHgY8DDwYPAR8PPgE8FHwiuAhcDC4Bl4LLwHHwMPBw8AjwSeCTweXgkeBR4NHgMeCx4HHg8eAJ4ArwRPAk8GTwFPAp4KngaeBTwdPBM8AzwaeBTwefAZ4FPhN8Fng2+GzwOeA54Lngc8Hngc8HXwCeB74QfBF4Pvhi8CXgS8GXgS8HLwBfAb4SfBX4avA14IXga8GLwNeBrwffAF4MvhG8BHwT+GbwLeBbwbeBbwcvBd8BvhN8F/hu8D3ge8H3ge8HPwB+EPwQeBn4YfAj4EfBy8ErwCvBj4EfBz8BfhL8FPhp8CrwM+C/wGvBL4K7EcxVGmdeci4M2fj7n2DzB8ONCaFI1RUG3Ptj89K+L139M/XLucqgyku03f4Iw5GRiM9WGRjDl7uMNQ7onTA4ru90koRbtN3izfcXRRPGaYcjfDa74xRNbbNvUXKAw+m/jH/oq7CgrDheEMsrisbixdRPfrwsryi3px0vzKPu82J2cVFZtDRWXJAfyy+MF0TTteogI8Ir1J0tMxKsOmAJTmaEv98sxqSXsjsrwh4jkTNjEYyVu9/b0rQDitZwSxwnZy5lM+6AbmM+A2EmMTO+Plb61tamskOOV95KqhmuiOrNQYLV+gfV27canyWq3r7Wv6ve6vr5V9XLHSSvL4sxAckRmKByIvwFVgsF5t641+kyxsuuxTj51eYr9rjjz9r8/qxS/Ix5wOrPOhHeunQ27iOQCKPNdZl3GBJLCOsIzEVLPX5pydhdV8DuO5QcZTPGx75DyeW0HMa6rsc4x0rld72IzHzBGWuJs4+PhPjtrs+47zIi3P0CU9N3V2sbzN9rW9vEuvldR/J7J0JnQhcUhpYztw0i3t8XNBColYaMdmcgJxI3Tr9K+LZhxPtjbMQ9RokEbSSQoI2ZE9R9pK8lQRsrSNAmQgdO7ArLrQ5S7Ws7BQpLoii3V7C3DAnYfbfHjxhNEW4nYPc93ryuXWWcTRnrkTHWNqf/hHdi/7seyp2b2yvYiTXlHKNWOdxVwRibBYGK2h3D3h9j8yBQUbuTgkC1CAIVtTsrCFTLIFBRu4uCQLXiDJQ5z1rH2na+1ewAzdxqytZkRKtI5QByHwG0Zj4NU8fSl3StFSjYHbx+nnAldbiDwCFqm+A8od1GQYK29XqCSl2daxfMoFuK3+tj3FHDDLqjwAzaPphB7fYKZtAO6brSEk1ty3VXe6rJ2TGYPe2OCpKzk4bZs5PA7Nk5mD3tzgoStIuS2TOPc/bsGsyedlcFybmThtlzJ4HZs1swe9rdFCRodyWzp92AcR31zoyrCkxyZlv6klPDReFduK+MaAyUhovCuwaB0nFReLcgUDouCkeDQOm4KGxzXxQ2zwd0LgqbHaCZW03ZmoywhS8K5zKr9rqWvqTLVaDa8zQcVuYJHFbGmBPUeYinpgSNKUjQHhouCj8qcFE4P5hBVVwULtAwgxYIzKCFwQxqFyqYQXv68aLw7sHsae+uIDn30DB77iEwe+4ZzJ72ngoSdC8/XhTuFcyedi8Fybm3htlzb4HZs3cwe9q9FSRoHy0XhbuG+ZKzr8cf/dCG+mgnUJT3e/wRCOaxsm0F7H5AySMQ+jHmJWOs7QcU5E0HgbzZx+OPSjF2dxGwe18FdncXsLu/x+02+wWJB8ktU1DfOwvY/bCS/cJ+jPsFxljbD3s8b0y99BDIm+UK6iVfwO4VSuplf8Z6YYy1vUJBvfQUyJsDFOxX9xKw+0AFdvcRsPsgBXb3FbD7cY/XtzmHYvYN3HY/oWS/cDDjfoEx1jan/yKuvHFv7Lfa8/VV6TVyh0SC18ixBOeQCH+/hzLemSNl96ER9hiJvjWC06eHMU5wEWtb0bk3L08kkuNsp2ScbS3+idlwPfw8gJLicMIRhCMJRxGOJhxDGEg4ljCIcBxhMGEIoQH+1/1WirDrd5EEX9Syqr5uz30FsDeTfQI7ky1v38hx2WEl2FsftmTxfm+p+a5Mq/KWuNPqXY0/zVhb4OeyUWMryirKBlQUl48o6V8xqmTCiNGj+hWVl7sTwfkSJyEi1RiZ+PsMl0Oc21MyXb9z/i/bxSHuyjCzY3urqjeiKW4RKz0vhzxC6lot7zhz3b44HllwQsRnr0Q3hv+ZMBiu7zDOPEHg+PUEoQSLMNt/BINkKsNb746PeN9/3GspOG0e6urLLszLzS3IM+0KS6N2rLQktzA3t7Q4Fi2JFpXklvWM2T3jsdxYXklpSTH1WWTHo/Gikp7xwq3jStex61DGOLnHe2Jw7MoTnBMFjl2LPH7sauwuEjp2ldhRFAnsgIqZC9MUoekzbKXvFd5HKlRpJci7Ur+ptBJBlWacWSpQJKVKVNqRjCqtJOJ9/3GrNE6byxSqtDIhlRYPVBpPcOICKm2Yx1WasXuYEpVWirFy9ztcQKUNT7NKO0qhShuBvDvJbypthKBKM848SaBITlKi0o5iVGkjIt73H7dK47T5ZIUq7WQhlVYeqDSe4JQLqLSRHldpxu6RSlTaSRgrd7+jBFTaqDSrtEEKVdpo5N0Yv6m00YIqzThzjECRjFGi0gYxqrTREe/7j1ulcdo8VqFKGyuk0sYFKo0nOOMEVNp4j6s0Y/d4JSptDMbK3e8EAZU2Ic0q7TiFKq0CeTfRbyqtQlClGWdOFCiSiUpU2nGMKq0i4n3/cas0TpsnKVRpk4RU2uRApfEEZ7KASpvicZVm7J6iRKVNxFi5+z1FQKWdkmaVNlihSpuKvJvmN5U2VVClGWdOEyiSaUpU2mBGlTY14n3/cas0TptPVajSThVSadMDlcYTnOkCKm2Gx1WasXuGEpU2DWPl7nemgEqbGamqHLhi1p76OEzAD6dFZOMfTW3bcsf/aQJ2P53t7bw3d85L2L0qW4dwYIyPvcrjj1pqJ5Tjqz2e44cL5fgaJTnOGB97jcdzvK1Qjr/g8RwfIpTja5XkOGN87LUez/ExiLXF26/IWCcqGuu0NI411bo09SNR7y97PPePFprnXlEyzzHGx37F47E+RijWr6cp1h46drQ5bTbxMA/Dck4MGn292dr6+B/DpeCTwLUJpyOO2da2B2odjb8fAx4IPhY8BjwRPA3ciHCGqz9nyu5qbf17IpsrJrNq2P7MGrY/q4btZ9ew/dk1bH9ODdvPqWH7uTVsf24N259Xw/bn17D9BTVsP6+G7S+sYfuLath+vqt9+G/a5xAuTrLdJUm2uzTJdpcl2e7yJNstSLLdFUm2uzLJdlcl2e7qJNtdk2S7hUm2uzbJdouSbHddku2ud7UbiHZnYH4eEqk+bxN5FtqdCT4LPBt8Nvgc8BzwXPC54PPA54MvAM8DXwi+CDwffDH4EvCl4MvAl4MXgK8AXwm+Cnw1+BrwQvC14EXg68DXJ+mfgNPD3Qk3VDP/DkCcTgffAG5MWBypukqGW+uvoAG5XzEYTW3b8l7Ng4WObxO3/9i3nfgLt39vxNiXRHy28sYYvtxl7BLXxTTugy4n6bgPut70+MGmUxzcdr8ldLAZSW2c0YRx2jdG+GxewtjX22nyXzS1zWbMb5sxZ2wp/3Hv7Djz76Z/6KuwoKw4XhDLK4rG4sXUT368LK8ot6cdL8yj7vNidnFRWbQ0VlyQH8svjBek7d0l7jFHU9zc4705EqzgYgnOzRH+fm9hTHopu28RUozcO9olGCt3v+97dAeUOE7OXLqVbzKyOf3nCGAzvj5W+u5TWJKCP+KVt5JqhitytHQbEuz2fzha6luNzxKPlvpa/360VF0//3q0xB0kry8xNAG5TWCCui3CX2C3o8DcG7diZoyXfTvj5LeUr9jjjj+X8vuzSvHf5lF/3sFcl87GfQTCedR6J/MOQ2I59h0Cc9GHHj/LY+y+U8DudUqOshnjY6fLZs79Y6p93cU4x0rl910RmfmCM9YSZ60l3i7/iYKz1vsL2L1eyduT72asR8ZY2+sV5M0BAnlzj8fnCWP3gQJ236vA7oME7L6P0W5zksKcIHDOVpvaNvlkfHsfTmKYl7Y6JzPM5fuOJBY6EToTujjCARv3XHM/41zj0atFYpr7foHce4Ax9zKsbS8Edm+cfpXw7QMR74/xQe4xSiTogwIJ+hBzgta39CXoQwoSdJnQCSr2I9nTGI9kH1ZwJCtRlI94XKkZuxcL2P25x1WCKcKHBez+QsmR7KOM9cgYa5vTf8I7sf+tO+HOzUcU7MQe1bITa8/Y13LGojEFHbGqbtyB2tGSCRT3ONspGWdbxnG61zQsws8rKClWEh4jPE54gvAk4SnC04RVhGcIzxJWE9YQniM8T3iBsJbwIuElwsuEVwivEl4jvE54g/Am4S3C24R3CO8S3iO8T/iA8CFhHeEjwseETwjrCZ8SPiN8TviC8CVhA+ErwkbC14RvCN8SNhG+I3xP+IHwI+Enws+EXwi/En4j/E74g/AnYTPhL1MUNHOHCGFChJBByCRkEbIJOYRahNqEOoS6hHqE+oQGhIaERoTGhCaE7QjbE5oSmhGaE1oQWhJaEVoTdiC0IbQltCPsSGhP6EDoSOhE6EzoQuhK2InQjdCdsDNhF8KuhN0IZs9jE3IJeYQYoQchn1BAKCT0JOxO2IOwJ2EvQi/C3oTehD6EvoR+hH0I+xL6E/Yj7E84gHAg4SDCwYRDCIcSDiMMIBxOOIJwJOEowtGEYwgDCccSBhGOIwwmDCEcTziBMDRj26mJWlbVxZy1XPOWe+1N2Kq8Zbl+7s1ULwKLR7ecBsxx2WEl2FsftmSxfm+Rbb4r06q8JS5S7V2NP81Ym+DnkqLy8gHjRkwsmlDWv2JUyYQRo0e5pxSne2dqiVRjXuLvM1yucG6cznT9zvm/bBeHuOdY80S45ZGqfoimuEWs9Kzfe0xKHPGOs9Jzhk9E5IsyfHa3kzFc6jnDxpkG3EeZpk+mMYrepfIYwxkk5znDJ2Z433/c62c4bS529aXlOcPFjHFyj7ckI7hLhSU4JRn8/ZYyJr2U3aUZ7DESuUulCGPl7reMuTBNEZo+w1b67rJ4XKFKiyPvhvlNpcUFVZpx5jCBIhmmRKU9zqjS4hne9x+3SuO0ebhClTZcSKWNCFQaT3BGCKi0kzyu0ozdJylRacMwVu5+TxZQaSenWaU9oVCllSPvRvpNpZULqjTjzJECRTJSiUp7glGllWd433/cKo3T5lEKVdooIZU2OlBpPMEZLaDSxnhcpRm7xyhRaSMxVu5+xwqotLFpVmnPKFRp45B34/2m0sYJqjTjzPECRTJeiUp7hlGljcvwvv+4VRqnzRMUqrQJQiqtIlBpPMGpEFBpEz2u0ozdE5WotPEYK3e/kwRU2qQ0q7RnFaq0yci7KX5TaZMFVZpx5hSBIpmiRKU9y6jSJmd433/cKo3T5lMUqrRThFTa1ECl8QRnqoBKm+ZxlWbsnqZEpU3BWLn7PVVApZ2aZpW2WqFKm468m+E3lTZdUKUZZ84QKJIZSlTaakaVNj3D+/7jVmmcNs9UqNJmCqm00wKVxhOc0wRU2ukeV2nG7tOVqLQZGCt3v2cIqLQz0qzShgrtBJjzopJKm4W8O9NvKm2WoEozzjxToEjOVKLShjJMuI5Km5Xhff9xqzROm89SqNLOElJpswOVxhOc2QIq7WyPqzRj99lKVNqZGCt3v+cIqLRzMqoqB66YOU8N4fbDnAzZ+EdT27Y84WuOQPy/yvZ23psnZUnYvVHJy1UY42Nv9PjjOtsJ5fi3Hs/xlUI5vklJjjPGx97k8RxvK5TjP3g8x9cI5fiPSnKcMT72jx7PcaNV56RJV0dT27YsZdcy1imKxjojjWNNdQ4xtS4xN/3i8Tp9UmhO/lXJnMwYH/tXj8f6KaFY/6HkhY2cx1GcNpt4mMerOlOlORbYbG19oKThYeCR4NqEuYhjtrXtEa1P4v+eAj8NXgUej/+fAp4BbkQ419Wf8wTagfj7seBB4OPAg8FDwHUJ57n6mYd+zsXf12Acz4GfB78AXgt+EfwS+GXwK+BXwa+BXwe/AX4T/Bb4bfA74HfB74HfB38A/hC8DvwR+GPwJ+D14E/Bn4E/B38B/hK8AfwVeCP4a/A34G/Bm8Dfgb8H/wD+EfwT+GfwL+Bfwb+Bfwf/Af4TvBn8F9hCvELgMDgCzgBngrPA2eAccC0nX8F1nDwB1wPXBzcAN3TyEtwY3AS8HXh7cFNwM3BzcAtwS3ArcGvwDuA24LbgduAdwe3BHcAdwZ3AncFdwF3BO4G7gbuDdwbvAt4VvBs4CrbBueA8cAzcA5wPLgAXgnuCdwfvAd4TvBe4F3hvcG9wH3BfcD/wPuB9wf3B+4H3Bx8APhB8EPhg8CHgQ8GHgQeADwcfAT4SfBT4aPAx4PPAx4NPcPxPON81LzkXhlYg3+ei3flOvhEuyKi6woBbe5iXyzbgWwO65WWM+0W2jZepX85VC1VeLu/27zzsAC/M8NmqBWP4cpexxgG9EwbH9Z1O0nGLwM0K3ky7n4Ddf3nzPVDRhHHa8zL4bL6QsS/znoN0+C+a2mYz5rfNmDO2lP+4d3ac+XfRP/RVWFBWHC+I5RVFY/Fi6ic/XpZXlNvTjhfmUfd5Mbu4qCxaGisuyI/lF8YLoula/eIeczTFzT3e+RnB6heW4MzP4O/3Ys6JUsjuizPYYyRyhvZCjJW73wyP7oASx8mZS5fwTUY2p/8cAWzG18dK3xrvC1PwR7zyVlLNcEWOli5F3V72D0dLfavxWeLRUl/r34+WquvnX4+WuIPk9eVZJiCXCkxQl2bwF9hlKDD3xq2YGeNlX8Y4+V3OV+xxx5+X8/uzSvFf6lF/LmCuS2fjPgLhPGq9gnmHIbGUdYHAXJSV4+052Nh9hYDd2UqOshnjY6fLZs79Y6p9Xck4x0rl95UZMvMFZ6wlzlq3Ezh7W9vj85k5a91PwO46aTroTXWcVzHWI2Os7ToK8mYfgby52uPzhLF7XwG7r1Fgd38Buxcy2m1OUpilRs75RlPbJp+MbxfiJIa59O6czOhK6EhioROhM6GLIxywcc811zLONR69WiSmua8V0CSLGHMvA7mVuHH6VcK3izK8P8bruMcokaDXCSTo9cwJ2sjSl6DXK0jQG4ROULEfyc5hPJJdrOBIVqIob/S4UjN2XyBgd32PH5GYIlwsYHcDJUeySxjrkTHWNqf/hHdi/1t3wp2bNyrYiS3hHKNWOdxVwRhvCgIVtc1xu9fHeHMQqKjdSUGgbgkCFbU7KwjUrUGgonYXBYG6jTNQ5nxtE2vbeVuzAzRzqylbkxG3ZVQOIPcRwO3Mp2GaWPqS7nYFCnap188TmufKLRU4RL0jOE9o36EgQe+UOk/IfS7hLh9cFdc6Ex8W8f4Y79YwE98tMBPfE8zE9j0KZuJ7vZ6gK4XW19ynYy117mERPpvvD/S7fb+ConxAw17jAYG9xoPBXsN+UEGCPqRhryGxOnGZjr1GHude4+Fgr2E/rKAoH9Gw13hEYK/xaLDXsB9VkKDLNew1JNZ2r1By3+a1jKviVnI++ID6aGBV3Zj69/Uiise4ryRqDJSGRRSPB4HSsYjiiSBQOhZRPBkESsciiqe4F1FsZ21bRGF2gGZuNWVrMuIp4UUUTzMfrWxn6Uu6pxUcrazScDi9SuBw+hnmBK1v6UvQZxQk6LNaFlGsZjwU/ITxdt/12cFMrGERxRoNM/EagZn4uWAmtp9TMBM/r+HE5gECJzZf8OEiirWBfrfXKijKFzXsNV4U2Gu8FOw17JcUJOjLGvYaBwrsNV7x4SKKV4O9hv2qgqJ8TcNe4zWBvcbrwV7Dfl1Bgr6hYa9xkMBe400liyjuZ9xrvOXxRwu1pz7uEpiMGnv8ETvLKcZ3CtjdRMkjdt5mzEvGWNtNPJ43pl7uE8ibpgrq5V4Bu5spqZd3GOuFMdZ2MwX1skwgb1oqqJeHBOxupaRe3mWsF8ZY260U1MsKgbxpo6BelgvY3VZJvbzHWC+MsbbbKqgXiQdqt1dQLysF7O6gpF7eZ6wXxljbHRTUy7MCedNZQb2sFrC7i5J6+YCxXhhjbXdRUC/PC+RNNwX18oKA3d2V1MuHjPXCGGu7u4J6eVkgb3ZVUC+vCNi9m5J6WcdYL4yxtndTUC9vCORNroJ6eVPA7jwl9fIRY70wxtrOU1AvbwnkTb7H7TbXpJcLXJMvUFIvHzPWC2OsbU7/RVx5497Yb8Hm6yvqHu8nGdteWBiuJheyBGyxEr4n0X/1q/kd65dLBOeTDP5+1zM+GUTK7vUZ7DESfZs2p08/ZZzgIta2onNvXp5IJMfZUck4O1j8E7Phevj5M8qxzwlfEL4kbCB8RdhI+JrwDeFbwibCd4TvM7Y9EaGWVXVyr+XKs5Drd+7J32xZrp97M9knsDPZ8tbdHJcdVoK99WFLFu/3lprvyrQqb4k7rd7V+NOMtQV+Lhs1tqKsomxARXH5iJL+FaNKJowYPapfUXm5OxGcL3ESIlKNkYm/z3A5JBs/Z7p+5/xftotD3JVhZsfOVlVvRFPcIlbVbHWcxTn+L6Tu9OYdZ67bFz8g8j9mbAt4yOUv8+e/qvFZyPVzGG3C/9Am9Df9/F0Fisk5xzhj+J8Jg+H6DuPMHwWOX38USrAIs/1fMEimsvjW7YcM7/svzOw/Tpt/cvVlF+bl5hbkmXaFpVE7VlqSW5ibW1oci5ZEi0pyy3rG7J7xWG4sr6S0pJj6LLLj0XhRSc944dZxpevY9SfGOLnH+3Nw7MoTnJ8Fjl1/8fixq7H7F6FjV4kdxS8CO6BfmQvTFKHpM4ziSIdK+1KhSvsNefe731Tab4IqzTjzd4Ei+V2JSvuSUaX9luF9/3GrNE6b/1Co0v4QUml/BiqNJzh/Cqi0zR5XacbuzUpU2u8YK3e/fwmotL/SrNI2KFRpjjQLZfpMpRlrpVSaceYWJPSbapGYPpnGKKrSNjCqNCvT+/7jVmmcNocz9am0cCbvzuB/eZ4ZqDSW4EQy+fvNYEx6KbszMtljJKLSQhgrd7+ZzIVpitD0mU6V9q1ClZaFvMv2m0rLElRpxpnZAkWSrUSlfcuo0rIyve8/bpXGaXOOQpWWI6TSagUqjSc4tQRUWm2PqzRjd20lKi0bY+Xut46ASquTZpW2SaFKq4u8q+c3lVZXUKUZZ9YTKJJ6SlTaJkaVVjfT+/7jVmmcNtdXqNLqC6m0BoFK4wlOAwGV1tDjKs3Y3VCJSquHsXL320hApTVKs0r7TqFKa4y8a+I3ldZYUKUZZzYRKJImSlTad4wqrXGm9/3HrdI4bd5OoUrbTkilbR+oNJ7gbC+g0pp6XKUZu5sqUWlNMFbufpsJqLRmmVWVA1fMzL2onwqsz2ueKRv/aGrbljv+mwvEf/ccb+e9uXNewu49cnQIB8b42Ht4/FFLHYVyvJfHc/xzoRzfW0mOM8bH3tvjOd5BKMf7ejzHvxfK8X5KcpwxPnY/j+e4ue7bPE26OpratuXym5axNknjWFNelm3J1Ht/j+f+V0Lz3H5K5jnG+Nj7eTzWG4VifWCaYu2hY0eb02YTD/MwLOfEoNHXm62tj/8x/DvYrCI3XJvQAnHMtrY9UOsrtNsI/hr8DTgb/18P3ATciNDS1Z9zMrKrtfXviWyumLSqYfvWNWy/Qw3bt6lh+7Y1bN+uhu13rGH79jVs36GG7TvWsH2nGrbvXMP2XWrYvmsN2+9Uw/bdXO3Df9M+h9A9yXY7J9lulyTb7Zpku92SbBdNsp2dZLvcJNvlJdkulmS7Hkm2y0+yXUGS7QqTbNczyXa7u9oNRLuWmJ+/z6g+bxO5Fdq3Bu8AbgNuC24H3hHcHtwB3BHcCdwZ3AXcFbwTuBu4O3hn8C7gXcG7gaNgG5wLzgPHwD3A+eACcCG4J3j3zOT8E3B6uDthj2rm38+Qxy0Qrz3AjQl7ZlZdJcOt9Q+lL3C/sj2a2mYfRn19LPSciMTtP/ZtJ/7C7d+9cGzey28rb4zhy13G9nJdTOM+6HKSjvug6+Acbx9sOsXBbfchOTKFluJ7KKIJ47T3YlxM0Iuxr0PT5L9oapvNmN82Y87YUv7j3tlx5t/e/9BXYUFZcbwgllcUjcWLqZ/8eFleUW5PO16YR93nxeziorJoaay4ID+WXxgvSNu7S/YWWsHVO1jBxRQcgRVcfTy+gsvY3UfJFZFeGCt3v0d4dAeUOE7OXOrLNxnZnP5zBLAZXx8rffcp9ErBH/HKW0k1wxU5WuqHut3nH46W+lbjs8Sjpb7Wvx8tVdfPvx4tcQfJ60sMTUD6SSzREFhiug8KzL1xK2bGeNn7ME5++/IVe9zx5778/qxS/P086s/+zHXpbNxHIJxHrfsx7zAklmP3F5iLjvL4WR5j934Cdh+t5CibMT52umzm3D+m2tf+jHOsVH7vnykzX3DGWuKs9WqBs7fHKjhr/YGA3YO8eda6yjgPYKxHxljbgzyeN6ZeXhDImyEK6uVDAbuPV1IvBzLWC2Os7eMV1MsrAnlzooJ6WSdgd5GSejmIsV4YY20XKaiXNwXyplRBvXwkYHeZkno5mLFeGGNtc/rPnExvam27qmo0qNmvmrniYJxsb2ZtO+lulpl1pIPaToTOhC5hy5KMwSGMMfDoqgaxc0OHCBw7H8p47JyB3ErcOP0q4dtDM70/xsO4xyiRoIcJJOgA5gRtaulL0AEKEvRwoQsp7GdcmzOecT1CwRlXiaI80uNnXI3dewrYPdzjKsEU4RECdo9QovCPYqxHxljbnP4T3on9b30kd24eqWAndpSWnVhnxr6OZiwaU9ARq+rGHahOlkyguMfZUck4OzCO0732bhF+PoZybCDhWMIgwnGEwYQhhOMJJxCGEk4kFBGKCSWEUkIZIU4YRhhOGEE4iXAyoZwwkjCKMJowhjCWMI4wnjCBUEGYSJhEmEyYQjiFMJUwjXAqYTphBmEm4TTC6YQzCLMIZxLOIswmnE04hzCHMJdwLuE8wvmECwjzCBcSLiLMJ1xMuIRwKeEywuWEBYQrCFcSriJcTbiGsJBwLWER4TrC9YQbCIsJNxKWEG4i3Ey4hXAr4TbC7YSlhDsIdxLuItxNuIdwL+E+wv2EBwgPEh4iLCM8THiE8ChhOWEFYSXhMcLjhCcITxKeIjxNWEV4hvAsYTVhDeE5wvOEFwhrCS8SXiK8THiF8CrhNcLrhDcIbxLeIrxNeIfwLuE9wvuEDwgfEtYRPiJ8TPiEsJ7wKeEzwueELwhfEjYQviJsJHxN+IbwLWET4TvC94QfCD8SfiI0QC6atZ+JNx3Ucs1b7jWiYavyluX6uTdTvQjc5LDlNGCOyw4rwd76sCWL9XuLbPNdmVblLfFmit7V+NOMtQl+LikqLx8wbsTEogll/StGlUwYMXqUe0pxunemlkg15iX+PsPlCucBH5mu3zn/l+3iEPcca55cenRmVT9EU9zStc7czN1cY65muFx9V3oe/s/w9y+ZPrsr1xgu9Tx840wD7qPMX4QSjHttuLsQUn0e/s+Z3vdfmNl/nDb/6upLy/Pwf2WMk3u8v2UGd1OyBOe3TP5+f2dMeim7fxdQJ9WNlWOi+11gB/QHc2GaIjR9hq303Q04SKFK+xN5t9lvKu1PQZVmnLlZoEg2K1FpgxhV2p+Z3vcft0rjtPkvhSrtLyGVZmRYoNJS7NMEx3iKu99QlrdVmrE7lMUeIxGVthlj5e43nMWv0kyf6VRpxylUaRHkXUaWz1SaMVxKpRlnZggUSUaWTIJxq7TjGFVaJMv7/uNWaZw2Z2bpU2mZzDsDZ8sKVBpPcLIEVFq2x1WasTtbiUrLwFi5+80RUGk5aVZpQxWqtFrIu9p+U2m1BFWacWZtgSKprUSlDWVUabWyvO8/bpXGaXMdhSqtjpBKqxuoNJ7g1BVQafU8rtKM3fWUqLTaGCt3v/UFVFr9NKu0ExWqtAbIu4Z+U2kNBFWacWZDgSJpqESlncio0hpked9/3CqN0+ZGClVaIyGV1jhQaTzBaSyg0pp4XKUZu5soUWkNMVbufrcTUGnbpVmlFSlUadsj75r6TaVtL6jSjDObChRJUyUqrYhRpW2f5X3/cas0TpubKVRpzYRUWvNApfEEp7mASmvhcZVm7G6hRKU1xVi5+20poNJaplml/aRQpbVC3rX2m0prJajSjDNbCxRJayUq7SdGldYqy/v+41ZpnDbvoFCl7SCk0toEKo0nOG0EVFpbj6s0Y3dbJSqtNcbK3W87AZXWLquqcuCKmfPUEG4/7JglG/9oatuWJ3ztKBD/8hxv5715UpaE3SOVvASMMT72SI8/rrOjUI6P8XiODxTK8bFKcpwxPvZYj+d4B6Ecn+DxHC8WyvEKJTnOGB+7wuM5brTqjmnS1dHUti1L2bWMtaGisTZN41hTvoPakpmbJnu8TgcLzclTlMzJjPGxp3g81kOEYj1NyYuFOY+jOG028TCPV3VOYppjgc3W1gdKGt4MNvclGq5NaI84ZlvbHtE6GO2GgI8HnwCujf9vCG4KbkTo4OrPmbK/xv99A/4WvAn8Hfh7cF1CR1c/89BPB3xPMdqVgEvBZeA4eBh4OHgE+CTwyeBy8EjwKPBo8BjwWPA48HjwBHAFeCJ4EngyeAr4FPBU8DTwqeDp4BngmeDTwKeDzwDPAp8JPgs8G3w2+BzwHPBc8Lng88Dngy8AzwNfCL4IPB98MfgS8KXgy8CXgxeArwBfCb4KfDX4GvBC8LXgReDrwNeDbwAvBt8IXgK+CXwz+BbwreDbwLeDl4LvAN8Jvgt8N/ge8L3g+8D3gx8APwh+CLwM/DD4EfCj4OXgFeCV4MfAj4OfAD8Jfgr8NHgV+Bnws+DV4DXg58DPg18ArwW/CH4J/DL4FfCr4NfAr4PfAL8Jfgv8Nvgd8Lvg98Dvgz8AfwheB/4I/DH4E/B68Kfgz8Cfg78AfwneAP4KvBHcEfPMD/j8I7gboZNrXnIuDB2Dv7fH/3UCNyZ0zqq6woBbe5iXbl6bwdefeZnl+xnbxsvUL+eqBTvxF27/dsGOp6vfVi0Yw5e7jO3quhDBLQKdpOMWgdMVvOn1fQG7Z3jzPVDRhHHaXRgvxHZl7GtmmvwXTW2zGfPbZswZe6aSA23O/NvpH/oqLCgrjhfE8oqisXgx9ZMfL8sryu1pxwvzqPu8mF1cVBYtjRUX5MfyC+MF0XStftlJaPVLt2D1C09wugmsfunu8dUvxu7uSs7QdsVYufud5dEdUOI4OXNpZ77JyJ7FfCbMTGJmfH2s9K3x7pqCP+KVt5JqhitytLQL6nbXfzha6luNzxKPlvpa/360VF0//3q0xB0kry/PMgHZRWCC2kVged6uKDD3xq2YGeNl78o4+e3GV+xxx5+78fuzSvHv4lF/RpWsv+c8arWZdxgSS1mjAnPRWR4/y2PstgXsnq3kKJsxPvZsJZd1d2Gs61zGOVYqv3OzZOYLzlhLnLW+S+Ds7RwFZ63fFrB7rjfPWlcZZx5jPTLG2p7r8bwx9XKfQN6cr6Be3hGw+wIl9RJjrBfGWNsXKKiXZQJ5c5GCenlXwO75SuqlB2O9MMbanq+gXlYI5M2lCurlPQG7L1NSL/mM9cIYa5vTf+Zkegtr21VVo0HNftXMFfk42d7S2nbSvSuhIx3UdiJ0JnQJW5ZkDAoYY+DRVQ1i54YKBI6dCxmPnTOQW4kbp18lfFuY5f0x9uQeo0SC9hRI0N2ZE7SFpS9Bd1eQoHsIXUhhP+O6I+MZ1z0VnHGVKMq9PH7G1djdWcDuKzyuEkwR7ilg95VKFH4vxnpkjLXN6T/hndj/1kdy5+ZeCnZivTjHqFUOd1Uwxr2DQEVtc9zu9TH2DgIVtTspCFSfIFBRu7OCQPUNAhW1uygIVD/OQJnzta2sbedtt+wAzbpNgsmIflmVA8h9BLAP82mYVpa+pNtHgYLd1+vnCc3zT/cVOETtH5wntPsrSND9pM4Tcp9L2N8Hq7e0zsSfZnh/jAdomIkPEJiJDwxmYvtABTPxQVpm4oN9si7Q2cK8gc51z5apxuKQ4DjAPkRBcR+qYe9zqMDe57Bg72MfpiBBB2jZ+xzuk1W2zsa898nj3PscEex97CMUFPeRGvY+RwrsfY4K9j72UQoS9Ggte59jfLBm3SR6M0tfomtYKDGQ+2qhxkBpWChxbBAoHQslBgWB0rFQ4rggUDoWSgzmXijR2tq2UMLsAM3casrWZMRg4YUSQ5iPAFpb+pJuiIIjgOM1HKIeL3CIegJzgja19CXoCQoSdKiWQ9QTGQ9Rj2U8RB2UE8zEGhZKFGmYiYsEZuLiYCa2ixXMxCVaZuJSxpl4CONMfLwPF0qUBccBdpmC4o5r2PvEBfY+w4K9jz1MQYIO17L3GcG49zmRce9T5MOFEicFex/7JAXFfbKGvc/JAnuf8mDvY5crSNCRWvY+oxj3PqWMe58yjz8ypjP1sb9AgV/jcbuPpgtE+wnYvVDJo3JGM9YLY6zthQrq5WCBvLlOQb0cJGD39UrqZQxjvTDG2r5eQb0cLpA3NyqolwECdi9RUi9jGeuFMdb2EgX1coxA3tyioF6OFrD7ViX1Mo6xXhhjbd+qoF6GCuTNUgX1cqKA3XcoqZfxjPXCGGv7DgX1UiKQN3crqJdSAbvvUVIvExjrhTHW9j0K6mW4QN7cr6BeRgjY/YCSeqlgrBfGWNsPKKiXkQJ5s0xBvYwSsPthJfUykbFeGGNtP+zxvFmfIXP9ZbnH7TYXlkcL2L1CSb1MYqwXxljbKxTUi8T1l8cV1MsYAbufUFIvkxnrhTHW9hMK6kXi+svTCuplrIDdq5TUyxTGemGMtb1KQb1IXH9ZraBexgnYvUZJvZzCWC+MsbbXKKgXiesQLyiol/ECdq9VUi9TGeuFMdb2WgX1InEd4mUF9TJBwO5XlNTLNMZ6YYy1/YqCepG4DvG6gnqpELD7DSX1cipjvTDG2n5DQb1IXId4W0G9TBSw+x0l9TKdsV4YY21L+S/MnD8hxljMyNJhc5jR5plKbI4w2nyaEpszGG0+XYnNmYw2n6HE5ixGm2cpsTmb0eYzldjcjdHms5TY3JXR5tk+tPlsH9p8jg9tnuNDm+f60OZzfWjzeT60+Xwf2nyBD22e50ObL/ShzRf50Ob5PrT5Yh/afIkPbb7UhzZf5kObL/ehzQt8aPMVPrT5Sh/afJUPbb7ahzZf40ObF/rQ5mt9aPMiH9p8nQ9tvt6HNt/gQ5sX+9DmG31o8xIf2nyTD22+2Yc23+JDm2/1oc23+dDm231o81If2nyHD22+04c23+VDm+/2oc33+NDme31o830+tPl+H9r8gA9tftCHNj/kQ5uX+dDmh31o8yM+tPlRH9q83Ic2r/ChzSt9aPNjPrT5cR/a/IQPbX7ShzY/5UObn/ahzat8aPMzPrT5WR/avNqHNq/xoc3P+dDm531o8ws+tHmtD21+0Yc2v+RDm1/2oc2v+NDmV31o82s+tPl1H9r8hg9tftOHNr/lQ5vf9qHN7/jQ5nd9aPN7PrT5fR/a/IEPbf7Qhzav86HNH/nQ5o99aPMnPrR5vQ9t/tSHNn/mQ5s/96HNX/jQ5i99aPMGH9r8lQ9t3uhDm7/2oc3f+NDmb31o8yYf2vydD23+3oc2/+BDm3/0oc0/+dDmn31o8y8+tPlXH9r8mxKbJ2Xx2fy7EpsnM9r8hxKbpzDa/KcSm09htHmzEpunMtr8lxKbpzHabGXrsPlURptDSmyezmhzWInNnJok4kObM3xoc6YPbc7yoc3ZPrQ5x4c21/KhzbWV2JzDaHMdJTbXYrS5rhKbazPaXE+JzXUYba6vxOa6jDY3UGJzPUabGyqxuT6jzY2U2NyA0ebGSmxuyGhzEyU2N2K0eTslNjdmtHl7JTY3YbS5qRKbt2O0uZkSm7dntLm5EpubMtrcgtHmpugnBJsjhAxCJoFOT5vLB5Y5JjTHSOaYwWhooymNxjKaw+yDzT7JzNFmzjI1bHLaxLgpfm+2ZoTmhBaEloRWhNaEHQhtCG0J7Qg7EtoTOhA6EjoROhO6EK5EXzNoYDMJpxFOJ5xBmEU4k3AWYTbhbMI5hDmEuYRzCecRzidcQJhHuJBwEWE+4WLCJQTz3njzHnXzXnHznm3z3mnzHmbzXmLznl7z3lrzHlfzXlPznk/z3kvzHkjzXkTznkDz3jzzHjnzXjXznjHz3i3zHirzXibzniLz3h7zHhvzXhfznhPz3g/zHgzzXgjzngTz3gDzHH3zXHnznHXz3HHzHG7zXGrznGbz3GLzHF/zXFvznFfz3FPzHFDzXEzznEjz3ETzHEHzXD3znDnz3DXzHDLzXC7znCrz3CbzHCPzXB/znBvz3BfzHBTzXBDznAzz3AjzHAXzXAFzn72579zch23uSzb36Zr7Vs19nOa+RnOfn7nvzdwHZu6LMvcJmftmzH0k5r4Kc5+BWXdv1qGbddlmnbJZt2vWsZp1nWado1n3Z9bBmXVhZp2UWTdk1tGYdSVmnYVZd2Cuw5vr0uY6rbluaa7jmcQ013nMdQ9zHcCcFzfnic15U3Me0ZxXM+eZzHkXcx7CHJeb41Rz3GaOY4yuNzrX6D6jg4wuMPtJs98w86iZV0ydhVz1UQc/D8AvW+Nz0YQJZSPHTGg3YXS7otLSdpNGTBjebvTEsnHx8tGT/g9pkk+q5UIGAA==", "verificationKey": "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" }, { diff --git a/yarn-project/bootstrap.sh b/yarn-project/bootstrap.sh index 98abdbef7e51..d76df86f6a8f 100755 --- a/yarn-project/bootstrap.sh +++ b/yarn-project/bootstrap.sh @@ -1,18 +1,29 @@ #!/bin/bash set -eu -# Navigate to script folder cd "$(dirname "$0")" -if [ "$(uname)" = "Darwin" ]; then - # works around https://github.com/AztecProtocol/aztec3-packages/issues/158 - echo "Note: not sourcing nvm on Mac, see github #158" -else - \. ~/.nvm/nvm.sh +CMD=${1:-} + +if [ -n "$CMD" ]; then + if [ "$CMD" = "clean" ]; then + git clean -fdx + exit 0 + else + echo "Unknown command: $CMD" + exit 1 + fi fi -set +eu # nvm runs in our context - don't assume it's compatible with these flags -nvm install -set -eu + +# if [ "$(uname)" = "Darwin" ]; then +# # works around https://github.com/AztecProtocol/aztec3-packages/issues/158 +# echo "Note: not sourcing nvm on Mac, see github #158" +# else +# \. ~/.nvm/nvm.sh +# fi +# set +eu # nvm runs in our context - don't assume it's compatible with these flags +# nvm install +# set -eu yarn install --immutable @@ -25,9 +36,9 @@ done # Run remake bindings before building Aztec.nr contracts or l1 contracts as they depend on files created by it. yarn workspace @aztec/circuits.js remake-bindings yarn workspace @aztec/circuits.js remake-constants +yarn workspace @aztec/noir-protocol-circuits noir:build (cd noir-contracts && ./bootstrap.sh) -(cd .. && l1-contracts/bootstrap.sh) # We do not need to build individual packages, yarn build will build the root tsconfig.json yarn build diff --git a/yarn-project/noir-compiler/package.json b/yarn-project/noir-compiler/package.json index 47824bd6f847..2232e05b0213 100644 --- a/yarn-project/noir-compiler/package.json +++ b/yarn-project/noir-compiler/package.json @@ -47,8 +47,8 @@ "dependencies": { "@aztec/foundation": "workspace:^", "@ltd/j-toml": "^1.38.0", - "@noir-lang/noir_wasm": "0.18.0-6ca33a2.aztec", - "@noir-lang/source-resolver": "0.18.0-6ca33a2.aztec", + "@noir-lang/noir_wasm": "portal:../../noir/packages/noir_wasm", + "@noir-lang/source-resolver": "portal:../../noir/packages/source-resolver", "base64-js": "^1.5.1", "commander": "^9.0.0", "fs-extra": "^11.1.1", diff --git a/yarn-project/noir-compiler/src/noir_artifact.ts b/yarn-project/noir-compiler/src/noir_artifact.ts index 6d7d1a090ef4..38032dcef94e 100644 --- a/yarn-project/noir-compiler/src/noir_artifact.ts +++ b/yarn-project/noir-compiler/src/noir_artifact.ts @@ -8,7 +8,15 @@ export interface NoirFunctionAbi { /** The parameters of the function. */ parameters: ABIParameter[]; /** The witness indices of the parameters. Indexed by parameter name. */ - param_witnesses: Record; + param_witnesses: { + /** input */ + input: { + /** start */ + start: number; + /** end */ + end: number; + }[]; + }; /** The return type of the function. */ return_type: ABIType; /** The witness indices of the return type. */ diff --git a/yarn-project/noir-protocol-circuits/.gitignore b/yarn-project/noir-protocol-circuits/.gitignore index 3046a0a17362..2173ed9152eb 100644 --- a/yarn-project/noir-protocol-circuits/.gitignore +++ b/yarn-project/noir-protocol-circuits/.gitignore @@ -1,3 +1,4 @@ proofs/ Prover.toml -Verifier.toml \ No newline at end of file +Verifier.toml +src/target \ No newline at end of file diff --git a/yarn-project/noir-protocol-circuits/package.json b/yarn-project/noir-protocol-circuits/package.json index 3206b3936b9a..2b4b8351e533 100644 --- a/yarn-project/noir-protocol-circuits/package.json +++ b/yarn-project/noir-protocol-circuits/package.json @@ -12,9 +12,9 @@ "clean": "rm -rf ./dest .tsbuildinfo", "formatting": "run -T prettier --check ./src && run -T eslint ./src", "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src", - "noir:build": "cd src && nargo compile --no-backend && rm -rf ./target/debug_*", + "noir:build": "cd src && ../../../noir/target/release/nargo compile && rm -rf ./target/debug_*", "noir:types": "yarn ts-node --esm src/scripts/generate_ts_from_abi.ts && yarn formatting:fix", - "noir:test": "cd src && nargo test", + "noir:test": "cd src && ../../../noir/target/release/nargo test", "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --passWithNoTests" }, "inherits": [ @@ -32,10 +32,10 @@ "@aztec/circuits.js": "workspace:^", "@aztec/foundation": "workspace:^", "@aztec/noir-compiler": "workspace:^", - "@noir-lang/acvm_js": "^0.30.0", - "@noir-lang/backend_barretenberg": "^0.7.10", - "@noir-lang/noir_js": "^0.16.0", - "@noir-lang/noirc_abi": "^0.16.0", + "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js", + "@noir-lang/backend_barretenberg": "portal:../../noir/packages/backend_barretenberg", + "@noir-lang/noir_js": "portal:../../noir/packages/noir_js", + "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi", "tslib": "^2.4.0" }, "devDependencies": { diff --git a/yarn-project/noir-protocol-circuits/src/index.ts b/yarn-project/noir-protocol-circuits/src/index.ts index 03ec2defd4f9..97671183a7c6 100644 --- a/yarn-project/noir-protocol-circuits/src/index.ts +++ b/yarn-project/noir-protocol-circuits/src/index.ts @@ -14,7 +14,7 @@ import { import { NoirCompiledCircuit } from '@aztec/noir-compiler'; import { WasmBlackBoxFunctionSolver, createBlackBoxSolver, executeCircuitWithBlackBoxSolver } from '@noir-lang/acvm_js'; -import { abiDecode, abiEncode } from '@noir-lang/noirc_abi'; +import { Abi, abiDecode, abiEncode } from '@noir-lang/noirc_abi'; import PrivateKernelInitJson from './target/private_kernel_init.json' assert { type: 'json' }; import PrivateKernelInitSimulatedJson from './target/private_kernel_init_simulated.json' assert { type: 'json' }; @@ -229,7 +229,7 @@ export async function executeBaseRollup(baseRollupInputs: BaseRollupInputs): Pro * */ async function executePrivateKernelInitWithACVM(input: InitInputType): Promise { - const initialWitnessMap = abiEncode(PrivateKernelInitSimulatedJson.abi, input, null); + const initialWitnessMap = abiEncode(PrivateKernelInitSimulatedJson.abi as Abi, input as any); // Execute the circuit on those initial witness values // @@ -247,7 +247,7 @@ async function executePrivateKernelInitWithACVM(input: InitInputType): Promise { - const initialWitnessMap = abiEncode(PrivateKernelInnerSimulatedJson.abi, input, null); + const initialWitnessMap = abiEncode(PrivateKernelInnerSimulatedJson.abi as Abi, input as any); // Execute the circuit on those initial witness values // @@ -275,7 +275,7 @@ async function executePrivateKernelInnerWithACVM(input: InnerInputType): Promise ); // Decode the witness map into two fields, the return values and the inputs - const decodedInputs: DecodedInputs = abiDecode(PrivateKernelInnerSimulatedJson.abi, _witnessMap); + const decodedInputs: DecodedInputs = abiDecode(PrivateKernelInnerSimulatedJson.abi as Abi, _witnessMap); // Cast the inputs as the return type return decodedInputs.return_value as ReturnType; @@ -285,7 +285,7 @@ async function executePrivateKernelInnerWithACVM(input: InnerInputType): Promise * Executes the ordering private kernel with the given inputs using the acvm. */ async function executePrivateKernelOrderingWithACVM(input: OrderingInputType): Promise { - const initialWitnessMap = abiEncode(PrivateKernelOrderingSimulatedJson.abi, input, null); + const initialWitnessMap = abiEncode(PrivateKernelOrderingSimulatedJson.abi as Abi, input as any); // Execute the circuit on those initial witness values // @@ -303,7 +303,7 @@ async function executePrivateKernelOrderingWithACVM(input: OrderingInputType): P ); // Decode the witness map into two fields, the return values and the inputs - const decodedInputs: DecodedInputs = abiDecode(PrivateKernelOrderingSimulatedJson.abi, _witnessMap); + const decodedInputs: DecodedInputs = abiDecode(PrivateKernelOrderingSimulatedJson.abi as Abi, _witnessMap); // Cast the inputs as the return type return decodedInputs.return_value as FinalReturnType; @@ -315,7 +315,7 @@ async function executePrivateKernelOrderingWithACVM(input: OrderingInputType): P async function executePublicKernelPrivatePreviousWithACVM( input: PublicPrivatePreviousInputType, ): Promise { - const initialWitnessMap = abiEncode(PublicKernelPrivatePreviousSimulatedJson.abi, input, null); + const initialWitnessMap = abiEncode(PublicKernelPrivatePreviousSimulatedJson.abi as Abi, input as any); const decodedBytecode = Buffer.from(PublicKernelPrivatePreviousSimulatedJson.bytecode, 'base64'); // Execute the circuit const _witnessMap = await executeCircuitWithBlackBoxSolver( @@ -328,7 +328,7 @@ async function executePublicKernelPrivatePreviousWithACVM( ); // Decode the witness map into two fields, the return values and the inputs - const decodedInputs: DecodedInputs = abiDecode(PublicKernelPrivatePreviousSimulatedJson.abi, _witnessMap); + const decodedInputs: DecodedInputs = abiDecode(PublicKernelPrivatePreviousSimulatedJson.abi as Abi, _witnessMap); // Cast the inputs as the return type return decodedInputs.return_value as PublicPrivatePreviousReturnType; } @@ -339,7 +339,7 @@ async function executePublicKernelPrivatePreviousWithACVM( async function executePublicKernelPublicPreviousWithACVM( input: PublicPublicPreviousInputType, ): Promise { - const initialWitnessMap = abiEncode(PublicKernelPublicPreviousSimulatedJson.abi, input, null); + const initialWitnessMap = abiEncode(PublicKernelPublicPreviousSimulatedJson.abi as Abi, input as any); const decodedBytecode = Buffer.from(PublicKernelPublicPreviousSimulatedJson.bytecode, 'base64'); // Execute the circuit const _witnessMap = await executeCircuitWithBlackBoxSolver( @@ -352,7 +352,7 @@ async function executePublicKernelPublicPreviousWithACVM( ); // Decode the witness map into two fields, the return values and the inputs - const decodedInputs: DecodedInputs = abiDecode(PublicKernelPublicPreviousSimulatedJson.abi, _witnessMap); + const decodedInputs: DecodedInputs = abiDecode(PublicKernelPublicPreviousSimulatedJson.abi as Abi, _witnessMap); // Cast the inputs as the return type return decodedInputs.return_value as PublicPublicPreviousReturnType; @@ -362,7 +362,7 @@ async function executePublicKernelPublicPreviousWithACVM( * Executes the root rollup with the given inputs using the acvm. */ async function executeRootRollupWithACVM(input: RootRollupInputType): Promise { - const initialWitnessMap = abiEncode(RootRollupJson.abi, input, null); + const initialWitnessMap = abiEncode(RootRollupJson.abi as Abi, input as any); // Execute the circuit on those initial witness values // @@ -379,7 +379,7 @@ async function executeRootRollupWithACVM(input: RootRollupInputType): Promise { - const initialWitnessMap = abiEncode(MergeRollupJson.abi, input, null); + const initialWitnessMap = abiEncode(MergeRollupJson.abi as Abi, input as any); // Execute the circuit on those initial witness values // @@ -406,7 +406,7 @@ async function executeMergeRollupWithACVM(input: MergeRollupInputType): Promise< }, ); - const decodedInputs: DecodedInputs = abiDecode(MergeRollupJson.abi, _witnessMap); + const decodedInputs: DecodedInputs = abiDecode(MergeRollupJson.abi as Abi, _witnessMap); // Cast the inputs as the return type return decodedInputs.return_value as MergeRollupReturnType; @@ -416,7 +416,7 @@ async function executeMergeRollupWithACVM(input: MergeRollupInputType): Promise< * Executes the base rollup with the given inputs using the acvm. */ async function executeBaseRollupWithACVM(input: BaseRollupInputType): Promise { - const initialWitnessMap = abiEncode(BaseRollupJson.abi, input, null); + const initialWitnessMap = abiEncode(BaseRollupJson.abi as Abi, input as any); // Execute the circuit on those initial witness values // @@ -434,7 +434,7 @@ async function executeBaseRollupWithACVM(input: BaseRollupInputType): Promise