diff --git a/.github/workflows/pull-request-write.yml b/.github/workflows/pull-request-write.yml index 3be1e937..45b6a27d 100644 --- a/.github/workflows/pull-request-write.yml +++ b/.github/workflows/pull-request-write.yml @@ -17,6 +17,40 @@ env: OCTOLYTICS_DIMENSION_REPOSITORY_ID: 590614152 jobs: + build-lint-all: + name: "build-lint-all" + runs-on: + - buildjet-32vcpu-ubuntu-2204 + concurrency: + group: build-lint-all-${{ github.ref }} + cancel-in-progress: true + steps: + - name: cachix-install-nix-action + uses: cachix/install-nix-action@be4cef7b776998e97233d6e0b84c538eb8122d76 + with: + install_url: https://releases.nixos.org/nix/${{ env.NIX_VERSION }}/install + nix_path: nixpkgs=channel:${{ env.NIXPKGS_CHANNEL }} + extra_nix_config: | + sandbox = relaxed + narinfo-cache-negative-ttl = 0 + system-features = kvm + http2 = true + - name: cachix-cachix-action + uses: cachix/cachix-action@298387a7aea14d6564aa5d6ead79272878339c8b + with: + authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}" + name: ${{ env.CACHIX_NAME }} + - name: nix-channel-env + run: | + nix-channel --add https://nixos.org/channels/${{ env.NIXPKGS_CHANNEL }} nixpkgs + nix-channel --update + nix profile install nixpkgs#git + - uses: actions/checkout@v3 + with: + ref: ${{ github.event.pull_request.head.sha }} + persist-credentials: false + - run: nix build .#lint-all + build-and-publish-draft: # as soon as it will be slow, can # 1. run in parallel @@ -59,8 +93,6 @@ jobs: mkdir out nix build .#release --print-build-logs --show-trace --no-update-lock-file cp ./result/lib/* ./result/bin/* ./out - - name: linters (clippy, fmt, documentation) - run: nix build .#lint - name: action-gh-release # so we do not allow non team members to do releases if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request_target' && github.event.pull_request.head.repo.id != env.OCTOLYTICS_DIMENSION_REPOSITORY_ID) || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.id == env.OCTOLYTICS_DIMENSION_REPOSITORY_ID) }} diff --git a/.gitignore b/.gitignore index 37cc43db..f94abdf3 100644 --- a/.gitignore +++ b/.gitignore @@ -31,6 +31,8 @@ result *.log out .secret +terraform/**/*.pem +.env # Local .terraform directories **/.terraform/* @@ -39,9 +41,6 @@ out *.tfstate *.tfstate.* -# Crash log files -crash.log -crash.*.log # Exclude all .tfvars files, which are likely to contain sensitive data, such as # password, private keys, and other secrets. These should not be part of version @@ -67,4 +66,4 @@ override.tf.json .terraformrc terraform.rc -!terraform.tfstate.sops +!**.sops \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index 73eb6027..a741fb0d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2445,7 +2445,7 @@ dependencies = [ [[package]] name = "golden-gate-node" -version = "0.0.0" +version = "0.0.1" dependencies = [ "async-trait", "clap", diff --git a/docs/net.md b/docs/net.md new file mode 100644 index 00000000..24208d37 --- /dev/null +++ b/docs/net.md @@ -0,0 +1,12 @@ + +# How to add new net + +1. Buy domain and move it to AWS (other providers possible, so this is already encoded) and enable proper limits and billing +2. You have to enable AWS login locally mighty enough. Nix will eat what you have (like awscli2) +3. Tell `domain`, admin `email`, state encryption "age" key to nix via `email` and `domain` attributes in `flake.nix` +4. Set `UPTIME_TOKEN` into env. +5. run `terraform/base.nix` to apply base layer with node image +6. Generate `gen-node-key` for `.secret/node-a`, `-b`, etc +7. Run `terraform/testnet.nix` to deploy testnet and bind it to DNS +8. Get `ip` from `output` of 6, and put it into `flake.nix` for `deploy-testnet-node-a`, `deploy-testnet-node-b`, etc +9. Run relevant nix scripts diff --git a/docs/validator.md b/docs/validator.md new file mode 100644 index 00000000..fd50a9fa --- /dev/null +++ b/docs/validator.md @@ -0,0 +1,8 @@ +# How to add more validators + +0. [You are running net](net.md) +1. `gen-node-key` for `.secret/node-d` +2. Add `node-d` into `terraform/testnet.nix` in places where `node-b` mentioned (instances, zones, keys). Run. +3. Copy `node-d` IP. +4. In `flake.nix` add `node-d` in all places where mentioned `node-b`. Run `deploy-node-d` routine. +5. Follow [guide](../examples/adding-new-validator/README.md) on how to get validator public keys set and add it into chain. diff --git a/examples/adding-new-validator/README.md b/examples/adding-new-validator/README.md index 24140bbb..c45e3443 100644 --- a/examples/adding-new-validator/README.md +++ b/examples/adding-new-validator/README.md @@ -42,26 +42,29 @@ As you can see, Alice and Bob are producing blocks, and I have connected to the ![The image shows that validator are running](images/initial.png) * We have to allowlist Charlie initially. How to allowlist the validator user see in the [guide](../adding-user-to-allowlist/README.md) * Go to Develop/RPC tab in the block explorer. -* Submit RPC to the author.rotateKeys() +* Submit RPC to the `author.rotateKeys()` ![The image shows example output of the rotate_keys](images/rotate_keys.png) * Copy the received key * In our example is: `0xdc97a6016d31900481e291be8d7d6149156109ee9132d3eb8965140e3104384453ec873dc7f96e4e3119931120668939f36dc643a33b3ee3f12d75cf406df9094835ea42bfcfc8468ba7777d5701d28992c7f79032d81c88fededacf3dea357e` * We have received three keys. (can be more later one). Each key is 32 bytes (64 symbols omitting initial 0x). -You have to split them into three separate parts as below - * Aura: `0xdc97a6016d31900481e291be8d7d6149156109ee9132d3eb8965140e31043844` - * Grandpa: `0x53ec873dc7f96e4e3119931120668939f36dc643a33b3ee3f12d75cf406df909` - * I'm online: `0x4835ea42bfcfc8468ba7777d5701d28992c7f79032d81c88fededacf3dea357e` -* Go to the Developer/Extrinsics and submit the session.setKeys transaction + +You have to split them into three separate parts as below (Runtime Calls -> sessionKeys -> decodeSessionKey): + +* Aura: `0xdc97a6016d31900481e291be8d7d6149156109ee9132d3eb8965140e31043844` +* Grandpa: `0x53ec873dc7f96e4e3119931120668939f36dc643a33b3ee3f12d75cf406df909` +* I'm online: `0x4835ea42bfcfc8468ba7777d5701d28992c7f79032d81c88fededacf3dea357e` +* Go to the Developer/Extrinsics and submit the `session.setKeys` transaction ![The image shows how to set_keys with given data](images/set_keys.png) * Fill the data with your keys * proof: `0x` * Submit the transaction and sign it. -* Go to the Developer/Sudo tab and choose validatorManager.registerValidator transaction +* Go to the Developer/Sudo tab and choose `validatorManager.registerValidator` transaction + +![The image shows example how to register validator](images/adding_validator.png) - ![The image shows example how to register validator](images/adding_validator.png) * Submit sudo and sign the transaction. * The validator is supposed to become active in two sessions. Verify that it is working. diff --git a/flake.lock b/flake.lock index b25e1c4f..147b7cb6 100644 --- a/flake.lock +++ b/flake.lock @@ -154,6 +154,21 @@ } }, "flake-utils_4": { + "locked": { + "lastModified": 1678901627, + "narHash": "sha256-U02riOqrKKzwjsxc/400XnElV+UtPUQWpANPlyazjH0=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "93a2b84fc4b70d9e089d029deacc3583435c2ed6", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "flake-utils_5": { "locked": { "lastModified": 1634851050, "narHash": "sha256-N83GlSGPJJdcqhUxSCS/WwW5pksYf3VP1M13cDRTSVA=", @@ -230,6 +245,42 @@ "type": "github" } }, + "nixlib": { + "locked": { + "lastModified": 1679187309, + "narHash": "sha256-H8udmkg5wppL11d/05MMzOMryiYvc403axjDNZy1/TQ=", + "owner": "nix-community", + "repo": "nixpkgs.lib", + "rev": "44214417fe4595438b31bdb9469be92536a61455", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "nixpkgs.lib", + "type": "github" + } + }, + "nixos-generators": { + "inputs": { + "nixlib": "nixlib", + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1679464055, + "narHash": "sha256-RiZpwkbm1GeKRqrTtGGsEDieJyplMSRG1bQzOZgY378=", + "owner": "nix-community", + "repo": "nixos-generators", + "rev": "d5cd198c80ee62a801a078ad991c99c0175971cf", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "nixos-generators", + "type": "github" + } + }, "nixpkgs": { "locked": { "lastModified": 1677534593, @@ -278,6 +329,26 @@ "type": "github" } }, + "nixpkgs-terraform-providers-bin": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1679532506, + "narHash": "sha256-ZyWIpRVdlzash46WWQUb2fqFuFWQAvjAhGbpF9qU06U=", + "owner": "nix-community", + "repo": "nixpkgs-terraform-providers-bin", + "rev": "dc01babcab88fa95ac00cd4796909545edf0f66f", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "nixpkgs-terraform-providers-bin", + "type": "github" + } + }, "nixpkgs_2": { "locked": { "lastModified": 1678230755, @@ -327,8 +398,11 @@ "crane": "crane", "devenv": "devenv", "flake-utils": "flake-utils_3", + "nixos-generators": "nixos-generators", "nixpkgs": "nixpkgs_2", + "nixpkgs-terraform-providers-bin": "nixpkgs-terraform-providers-bin", "rust-overlay": "rust-overlay_2", + "substrate": "substrate", "terranix": "terranix" } }, @@ -380,11 +454,59 @@ "type": "github" } }, + "rust-overlay_3": { + "inputs": { + "flake-utils": [ + "substrate", + "flake-utils" + ], + "nixpkgs": [ + "substrate", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1679710743, + "narHash": "sha256-zB6vEMoOmXZyqD/yNu1DYqtYvQaPERjWEnmhK8ovlWk=", + "owner": "oxalica", + "repo": "rust-overlay", + "rev": "8ba8bdaee0dfb4b7ad8b1f398e4f24d4dee89760", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "rust-overlay", + "type": "github" + } + }, + "substrate": { + "inputs": { + "flake-utils": "flake-utils_4", + "nixpkgs": [ + "nixpkgs" + ], + "rust-overlay": "rust-overlay_3" + }, + "locked": { + "lastModified": 1679773020, + "narHash": "sha256-/Nc2c4eTNIpFwi+Q8YyaGDXz0fdjRZDUamCuavjT6hk=", + "owner": "dzmitry-lahoda-forks", + "repo": "substrate", + "rev": "8e8e54d99f5f86da1ff984646dc6cba3597a42f8", + "type": "github" + }, + "original": { + "owner": "dzmitry-lahoda-forks", + "repo": "substrate", + "rev": "8e8e54d99f5f86da1ff984646dc6cba3597a42f8", + "type": "github" + } + }, "terranix": { "inputs": { "bats-assert": "bats-assert", "bats-support": "bats-support", - "flake-utils": "flake-utils_4", + "flake-utils": "flake-utils_5", "nixpkgs": [ "nixpkgs" ], diff --git a/flake.nix b/flake.nix index 5cd9d6c9..f78a3d91 100644 --- a/flake.nix +++ b/flake.nix @@ -10,12 +10,10 @@ # rust version rust-overlay = { url = "github:oxalica/rust-overlay"; - inputs = { nixpkgs.follows = "nixpkgs"; flake-utils.follows = "flake-utils"; }; - }; # mac/linux arm/x86 support @@ -27,12 +25,29 @@ inputs.nixpkgs.follows = "nixpkgs"; }; + # virtual machine images - assembling VM is simple and fast as OCI image :) + nixos-generators = { + url = "github:nix-community/nixos-generators"; + inputs.nixpkgs.follows = "nixpkgs"; + }; + # terraform generator to manage clouds/managed services terranix = { url = "github:terranix/terranix"; inputs.nixpkgs.follows = "nixpkgs"; }; + # fixed derivation for terraform packages + nixpkgs-terraform-providers-bin = { + url = "github:nix-community/nixpkgs-terraform-providers-bin"; + inputs.nixpkgs.follows = "nixpkgs"; + }; + + # for subkey + substrate = { + url = "github:dzmitry-lahoda-forks/substrate/8e8e54d99f5f86da1ff984646dc6cba3597a42f8"; + inputs.nixpkgs.follows = "nixpkgs"; + }; }; nixConfig = { @@ -42,302 +57,813 @@ }; # inputs and systems are know ahead of time -> we can evalute all nix -> flake make nix """statically typed""" - outputs = { self, nixpkgs, devenv, rust-overlay, crane, flake-utils, terranix, ... } @ inputs: - flake-utils.lib.eachDefaultSystem (system: - let + outputs = { self, nixpkgs, devenv, rust-overlay, crane, flake-utils, terranix, nixos-generators, nixpkgs-terraform-providers-bin, substrate } @ inputs: + let + email = ""; + domain = "ggchain.technology"; + org = "ggchaintesta"; + region = "eu-west-1"; + # could generate dynamic nixos module to be referenced + bootnode = "34-244-81-67"; + bootnode-peer = "12D3KooWP3E64xQfgSdubAXpVrJTxL6a2Web2uiwC4PBxyEJFac3"; + # can use envvars override to allow run non shared "cloud" for tests + age-pub = "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5"; + + per_system = flake-utils.lib.eachDefaultSystem + (system: + let + + overlays = [ (import rust-overlay) (substrate.overlays) ]; + pkgs = import nixpkgs { + inherit system overlays; + }; + + # not optimal as not all packages requires this, + # but many build.rs do - so we add little bit slowness for simplificaiton and reproduceability + rust-native-build-inputs = with pkgs; [ clang pkg-config gnumake ]; + + # reusable env for shell and builds + rust-env = with pkgs; { + LD_LIBRARY_PATH = pkgs.lib.strings.makeLibraryPath [ + pkgs.stdenv.cc.cc.lib + pkgs.llvmPackages.libclang.lib + ]; + LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib"; + PROTOC = "${pkgs.protobuf}/bin/protoc"; + ROCKSDB_LIB_DIR = "${pkgs.rocksdb}/lib"; + RUSTUP_TOOLCHAIN = "nightly-2022-12-20"; # could read from toml for dylint + }; + + darwin = pkgs.lib.optionals pkgs.stdenv.isDarwin (with pkgs.darwin.apple_sdk; [ + frameworks.Security + ]); + + common-attrs = rust-env // { + buildInputs = with pkgs; [ openssl zstd ]; + nativeBuildInputs = with pkgs; + rust-native-build-inputs ++ [ openssl ] ++ darwin; + doCheck = false; + cargoCheckCommand = "true"; + src = rust-src; + pname = "..."; + version = "..."; + }; + + common-wasm-deps-attrs = common-attrs // { + cargoExtraArgs = + "--package 'golden-gate-runtime-*' --target wasm32-unknown-unknown --no-default-features --features=aura,with-rocksdb-weights"; + RUSTFLAGS = + "-Clink-arg=--export=__heap_base -Clink-arg=--import-memory"; + }; + + common-wasm-attrs = common-wasm-deps-attrs // { + installPhase = '' + runHook preInstall + mkdir --parents $out/lib + cp ./target/wasm32-unknown-unknown/release/wbuild/golden-gate-runtime-*/golden_gate_runtime_*.compact.compressed.wasm $out/lib + runHook postInstall + ''; + }; + + + # calls `cargo vendor` on package deps + common-wasm-deps = + craneLib.buildDepsOnly (common-wasm-attrs // { }); + + doclint = pkgs.writeShellApplication rec { + name = "doclint"; + text = '' + ${pkgs.lib.meta.getExe pkgs.nodePackages.markdownlint-cli2} "**/*.md" "#.devenv" "#target" "#terraform" + ''; + }; + + # rust used by ci and developers + rust-toolchain = + pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml; + craneLib = (crane.mkLib pkgs).overrideToolchain rust-toolchain; + + # do not consier target to be part of source + rust-src = pkgs.lib.cleanSourceWith { + src = pkgs.lib.cleanSource ./.; + filter = pkgs.nix-gitignore.gitignoreFilterPure + (name: type: + # nix files are not used as part of build + ( + (type == "regular" && pkgs.lib.strings.hasSuffix ".nix" name) + == false + && + (type == "directory" && ".github" == name) == false + && (type == "directory" && "terraform" == name) == false + + # risky, until we move code into separate repo as rust can do include_str! as doc, but good optimization + && (type == "regular" && pkgs.lib.strings.hasSuffix ".md" name) == false + && (type == "regular" && pkgs.lib.strings.hasSuffix ".json" name) == false + && (type == "regular" && pkgs.lib.strings.hasSuffix ".gitignore" name) == false + ) + ) + [ ./.gitignore ] ./.; + }; + + common-native-release-attrs = common-attrs // rec { + cargoExtraArgs = "--package ${pname}"; + pname = "golden-gate-node"; + version = "0.1.0"; + }; + + common-native-release-deps = + craneLib.buildDepsOnly (common-native-release-attrs // { }); + common-wasm-release-deps = craneLib.buildDepsOnly common-wasm-deps-attrs; + + golden-gate-runtimes = craneLib.buildPackage (common-wasm-attrs // rec { + pname = "golden-gate-runtimes"; + cargoArtifacts = common-wasm-release-deps; + }); + + golden-gate-node = craneLib.buildPackage (common-native-release-attrs // { + cargoArtifacts = common-native-release-deps; + nativeBuildInputs = common-native-release-attrs.nativeBuildInputs ++ [ pkgs.git ]; # parity does some git hacks in build.rs + }); + + fmt = craneLib.cargoFmt (common-attrs // { + cargoExtraArgs = "--all"; + rustFmtExtraArgs = "--color always"; + }); + + cargoClippyExtraArgs = "-- -D warnings"; + + clippy-node = craneLib.cargoClippy (common-native-release-attrs // { + inherit cargoClippyExtraArgs; + cargoArtifacts = golden-gate-node.cargoArtifacts; + }); + + clippy-wasm = craneLib.cargoClippy (common-wasm-deps-attrs // { + inherit cargoClippyExtraArgs; + cargoArtifacts = golden-gate-runtimes.cargoArtifacts; + }); + + + + # really need to run as some points: + # - light client emulator (ideal for contracts) + # - multi node local fast (fast druation low security) + # - multi local slow (duration and security as in prod) + # - here can apply above to remote with something if needed (terranix/terraform-ng works) + # for each + # - either start from genesis + # - of from fork (remote prod data) + # all with - archieval and logging enabled + single-fast = pkgs.writeShellApplication rec { + name = "single-fast"; + text = '' + ${pkgs.lib.meta.getExe golden-gate-node} --dev + ''; + }; + + # we do not use existing Dotsama tools as they target relay + parachains + # here we can evolve into generating arion/systemd/podman/k8s output (what ever will fit) easy + multi-fast = pkgs.writeShellApplication rec { + name = "multi-fast"; + text = '' + WS_PORT_ALICE=''${WS_PORT_ALICE:-9944} + WS_PORT_BOB=''${WS_PORT_BOB:-9945} + WS_PORT_CHARLIE=''${WS_PORT_CHARLIE:-9946} + ( ${pkgs.lib.meta.getExe golden-gate-node} --chain=local --rpc-cors=all --alice --tmp --ws-port="$WS_PORT_ALICE" &> alice.log ) & + ( ${pkgs.lib.meta.getExe golden-gate-node} --chain=local --rpc-cors=all --bob --tmp --ws-port="$WS_PORT_BOB" &> bob.log ) & + ( ${pkgs.lib.meta.getExe golden-gate-node} --chain=local --rpc-cors=all --charlie --tmp --ws-port="$WS_PORT_CHARLIE" &> charlie.log ) & + echo https://polkadot.js.org/apps/?rpc=ws://127.0.0.1:"$WS_PORT_ALICE"#/explorer + ''; + }; + + tf-init = pkgs.writeShellApplication rec { + name = "tf-init"; + text = '' + # here you manually obtain login key + aws configure + ''; + }; + + cloud-tools = with pkgs; [ + awscli2 + terraform + sops + age + nixos-rebuild + ]; + + # seldom to change node image to terraform onto cloud as template + node-image = nixos-generators.nixosGenerate { + system = "x86_64-linux"; + modules = [ + ./flake/nixos-amazon.nix + ] ++ [ ({ ... }: { amazonImage.sizeMB = 16 * 1024; }) ] + ; + format = "amazon"; + }; + + # send variables to terraform + terraformattrs = { + TF_VAR_VALIDATOR_NAME = org; + TF_VAR_AWS_REGION = region; + }; + + terraformtestnet = terraformattrs // { + TF_VAR_DOMAIN_NAME = domain; + }; + + terraformbase = terraformattrs // { + TF_VAR_NODE_IMAGE = "\"$(find ${node-image} -type f -name '*.vhd')\""; + }; + + + # generates node secrtekey and gets public key of + gen-node-key = pkgs.writeShellApplication { + name = "gen-node-key"; + runtimeInputs = [ pkgs.subkey pkgs.jq ]; + text = '' + KEY_PATH=$1 + subkey generate --output-type=json --scheme=sr25519 > "$KEY_PATH".sr25519.json + subkey inspect --scheme ed25519 --output-type=json "$(jq --raw-output .secretSeed "$KEY_PATH".sr25519.json)" > "$KEY_PATH".ed25519.json + + echo "Address/AuthorityId/IAmOnline/Aura:" + jq --raw-output .ss58Address "$KEY_PATH".sr25519.json + + echo "GRANDPA:" + jq --raw-output .ss58Address "$KEY_PATH".ed25519.json + + echo "Peer identity (libp2p):" + jq --raw-output .secretSeed "$KEY_PATH".ed25519.json | subkey inspect-node-key + ''; + }; + + inspect-node-key = pkgs.writeShellApplication { + name = "inspect-node-key"; + runtimeInputs = [ pkgs.subkey pkgs.jq ]; + text = '' + KEY_PATH=$1 + echo "Address/AuthorityId/IAmOnline/Aura:" + jq --raw-output .ss58Address "$KEY_PATH".sr25519.json + + echo "GRANDPA:" + jq --raw-output .ss58Address "$KEY_PATH".ed25519.json + + echo "Peer identity (libp2p):" + jq --raw-output .secretSeed "$KEY_PATH".ed25519.json | subkey inspect-node-key + ''; + }; + + # need to generalize for generic TF_VAR consumption + mkTerraformRun = tfname: config: attrs: pkgs.writeShellApplication (rec { + name = " + tf-${tfname}"; + runtimeInputs = cloud-tools; + text = + # just way to put attrs as export variables + with builtins; concatStringsSep "\n" (attrValues (mapAttrs (name: value: "${name}=${value} && export ${name}") attrs)) + + '' + + cd ./terraform/${tfname} + # generate terraform input from nix + cp --force ${config} config-${tfname}.tf.json + + # silly check to avoid providers rechek all the time (nixified version would be more robust) + if [[ ! -d .terraform/providers ]]; then + terraform init --upgrade + fi + + # decrypt secret state (should run only on CI eventually for safety) + # if there is encrypted state, decrypt it + if [[ -f terraform-${tfname}.tfstate.sops ]]; then + # uses age, so can use any of many providers (including aws) + echo "decrypting state" + sops --decrypt --age ${age-pub} terraform-${tfname}.tfstate.sops > terraform-${tfname}.tfstate + # testing that we can finally reencrypt + sops --encrypt --age ${age-pub} terraform-${tfname}.tfstate > terraform-${tfname}.tfstate.sops + fi + + # so we can store part of changes before exit + set +o errexit + # apply state to cloud, eventually should manually approve in CI + terraform "$@" # for example `-- apply -auto-approve` + TERRAFORM_RESULT=$? + set -o errexit + + # encrypt update state back and push it (later in CI special job) + echo "encrypting current state" + if [[ -f terraform-${tfname}.tfstate ]]; then + sops --encrypt --age ${age-pub} terraform-${tfname}.tfstate > terraform-${tfname}.tfstate.sops + fi + + if [[ -f terraform-${tfname}.tfstate.backup ]]; then + echo "encrypting backup state" + sops --encrypt --age ${age-pub} terraform-${tfname}.tfstate.backup > terraform-${tfname}.tfstate.backup.sops + fi + + exit $TERRAFORM_RESULT + ''; + }); + + tf-testnet = mkTerraformRun "testnet" tf-config-testnet terraformtestnet; + tf-base = mkTerraformRun "base" tf-config-base terraformbase; + + + tf-config-base = terranix.lib.terranixConfiguration { + inherit system; + modules = [ ./flake/terraform/base.nix ]; + }; + tf-config-testnet = terranix.lib.terranixConfiguration { + inherit system; + modules = [ ./flake/terraform/testnet.nix ]; + }; + + mkNixosAwsRemoteRebuild = ip: region: name: pkgs.writeShellApplication + { + name = "deploy-" + name; + runtimeInputs = [ pkgs.nixos-rebuild ]; + text = '' + # builds node locally and delta copies nix store to remote machine, and applies nix config + # should read from tfstate here to avoid cp paste of name + NIX_SSHOPTS="-i ./terraform/testnet/id_rsa.pem" + export NIX_SSHOPTS + # first run will be slow, so can consider variouse optimization later + nixos-rebuild switch --fast --flake .#${name} --target-host root@ec2-${ip}.${region}.compute.amazonaws.com + ''; + }; + in + rec { + + packages = flake-utils.lib.flattenTree + rec { + inherit golden-gate-runtimes golden-gate-node gen-node-key single-fast multi-fast tf-base tf-testnet node-image inspect-node-key doclint fmt clippy-node clippy-wasm; + subkey = pkgs.subkey; + node = golden-gate-node; + lint-all = pkgs.symlinkJoin { + name = "lint-all"; + paths = [ doclint fmt clippy-node clippy-wasm ]; + }; + release = pkgs.symlinkJoin { + name = "release"; + paths = [ node golden-gate-runtimes ]; + }; + default = release; + # we should prune 3 things: + # - running process + # - logs/storages of run proccess + # - system prunce of nix cache/oci images + prune-running = pkgs.writeShellApplication rec { + name = "prune-running"; + text = '' + pkill golden-gate-nod + ''; + }; - overlays = [ (import rust-overlay) ]; - pkgs = import nixpkgs { - inherit system overlays; - }; + deploy-testnet-node-a = mkNixosAwsRemoteRebuild bootnode region "testnet-node-a"; + deploy-testnet-node-b = mkNixosAwsRemoteRebuild "34-243-72-53" region "testnet-node-b"; + deploy-testnet-node-c = mkNixosAwsRemoteRebuild "54-246-50-70" region "testnet-node-c"; + deploy-testnet-node-d = mkNixosAwsRemoteRebuild "3-253-35-79" region "testnet-node-d"; + + run-testnet-node-a = pkgs.writeShellApplication { + name = "run-testnet-node-a"; + runtimeInputs = [ pkgs.subkey pkgs.jq golden-gate-node ]; + text = '' + + RUST_LOG=info,libp2p=info,grandpa=info + export RUST_LOG + NODE_KEY=$(jq --raw-output .secretSeed /root/ed25519.json) + rm -r -f chains + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme=sr25519 \ + --suri "$NODE_KEY" \ + --key-type aura \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme ed25519 \ + --suri "$NODE_KEY" \ + --key-type gran \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node --node-key "$NODE_KEY" --unsafe-ws-external --validator --rpc-methods=unsafe --unsafe-rpc-external --rpc-cors=all --blocks-pruning archive --chain=testnet --name=node-a --base-path=/root/ + ''; + }; - # not optimal as not all packages requires this, - # but many build.rs do - so we add little bit slowness for simplificaiton and reproduceability - rust-native-build-inputs = with pkgs; [ clang pkg-config gnumake ]; + run-testnet-node-b = pkgs.writeShellApplication { + name = "run-testnet-node-b"; + runtimeInputs = [ pkgs.subkey pkgs.jq golden-gate-node ]; + text = '' + RUST_LOG=info,libp2p=info,grandpa=info + export RUST_LOG + NODE_KEY=$(jq --raw-output .secretSeed /root/ed25519.json) + rm -r -f /root/chains + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme=sr25519 \ + --suri "$NODE_KEY" \ + --key-type aura \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme ed25519 \ + --suri "$NODE_KEY" \ + --key-type gran \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node --node-key "$NODE_KEY" --unsafe-ws-external --validator --rpc-methods=unsafe --unsafe-rpc-external --rpc-cors=all --blocks-pruning archive --chain=testnet --name=node-b --base-path=/root/ --bootnodes=/ip4/34.244.81.67/tcp/30333/p2p/${bootnode-peer} + ''; + }; - # reusable env for shell and builds - rust-env = with pkgs; { - LD_LIBRARY_PATH = pkgs.lib.strings.makeLibraryPath [ - pkgs.stdenv.cc.cc.lib - pkgs.llvmPackages.libclang.lib + run-testnet-node-c = pkgs.writeShellApplication { + name = "run-testnet-node-c"; + runtimeInputs = [ pkgs.subkey pkgs.jq golden-gate-node ]; + text = '' + RUST_LOG=info,libp2p=info,grandpa=info + export RUST_LOG + NODE_KEY=$(jq --raw-output .secretSeed /root/ed25519.json) + rm -r -f /root/chains + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme=sr25519 \ + --suri "$NODE_KEY" \ + --key-type aura \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme ed25519 \ + --suri "$NODE_KEY" \ + --key-type gran \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node --node-key "$NODE_KEY" --unsafe-ws-external --validator --rpc-methods=unsafe --unsafe-rpc-external --rpc-cors=all --blocks-pruning archive --chain=testnet --name=node-c --base-path=/root/ --bootnodes=/ip4/34.244.81.67/tcp/30333/p2p/${bootnode-peer} + ''; + }; + run-testnet-node-d = pkgs.writeShellApplication { + name = "run-testnet-node-d"; + runtimeInputs = [ pkgs.subkey pkgs.jq golden-gate-node ]; + text = '' + RUST_LOG=info,libp2p=info,grandpa=info + export RUST_LOG + NODE_KEY=$(jq --raw-output .secretSeed /root/ed25519.json) + rm -r -f /root/chains + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme=sr25519 \ + --suri "$NODE_KEY" \ + --key-type aura \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node key insert \ + --base-path=/root/ \ + --chain=testnet \ + --scheme ed25519 \ + --suri "$NODE_KEY" \ + --key-type gran \ + --keystore-path ~/chains/remote_testnet/keystore + + golden-gate-node --node-key "$NODE_KEY" --unsafe-ws-external --validator --rpc-methods=unsafe --unsafe-rpc-external --rpc-cors=all --blocks-pruning archive --chain=testnet --name=node-d --base-path=/root/ --bootnodes=/ip4/34.244.81.67/tcp/30333/p2p/${bootnode-peer} + ''; + }; + }; + + devShells = { + default = devenv.lib.mkShell { + inherit inputs pkgs; + modules = + let + + dylib = { + buildInputs = with pkgs; [ openssl ] ++ darwin; + nativeBuildInputs = rust-native-build-inputs; + doCheck = false; + }; + rust-deps = pkgs.makeRustPlatform { + inherit pkgs; + # dylint needs nightly + cargo = pkgs.rust-bin.beta.latest.default; + rustc = pkgs.rust-bin.beta.latest.default; + }; + cargo-dylint = with pkgs; rust-deps.buildRustPackage (rec { + pname = "cargo-dylint"; + version = "2.1.5"; + src = fetchCrate { + inherit pname version; + sha256 = "sha256-kH6dhUFaQpQ0kvzNyLIXjFAO8VNa2jah6ZaDO7LQKO0="; + }; + + cargoHash = "sha256-YvQI3H/4eWe6r2Tg8qHJqfnw/NpuGHtkRuTL4EzF0xo="; + cargoDepsName = pname; + } // dylib); + dylint-link = with pkgs; rust-deps.buildRustPackage (rec { + pname = "dylint-link"; + version = "2.1.5"; + src = fetchCrate { + inherit pname version; + sha256 = "sha256-oarEYhv0i2wAPmahx0vgWN3kmfEsK3s6D3+qkOqF9pc="; + }; + + cargoHash = "sha256-pMr9hddHAIyIclHRpxqdUaHphjSAVDnvfNjWGDA2EM4="; + cargoDepsName = pname; + } // dylib); + # can `cargo-contract` and nodejs ui easy here + in + [ + { + packages = with pkgs; + [ + rust-toolchain + binaryen + llvmPackages.bintools + dylint-link + nodejs-18_x + nodePackages.markdownlint-cli2 + jq + subkey + ] + ++ rust-native-build-inputs ++ darwin ++ cloud-tools; + env = rust-env; + # can do systemd/docker stuff here + enterShell = '' + echo ggshell + ''; + + # GH Codespace easy to run (e.g. for Mac users, low spec machines or Frontend developers or hackatons) + devcontainer.enable = true; + } + ]; + }; + }; + } + ); + in + per_system // { + nixosConfigurations = + let + # nixos config for one and only one system + # so it is invere of packages (packages for all systems) + system = "x86_64-linux"; + overlays = [ + (import rust-overlay) + (_: _: { + golden-gate-node = per_system.packages.${system}.golden-gate-node; + }) ]; - LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib"; - PROTOC = "${pkgs.protobuf}/bin/protoc"; - ROCKSDB_LIB_DIR = "${pkgs.rocksdb}/lib"; - RUSTUP_TOOLCHAIN = "nightly-2022-12-20"; # could read from toml for dylint - }; - - darwin = pkgs.lib.optionals pkgs.stdenv.isDarwin (with pkgs.darwin.apple_sdk; [ - frameworks.Security - ]); - - common-attrs = rust-env // { - buildInputs = with pkgs; [ openssl zstd ]; - nativeBuildInputs = with pkgs; rust-native-build-inputs ++ [ openssl ] ++ darwin; - doCheck = false; - cargoCheckCommand = "true"; - src = rust-src; - pname = "..."; - version = "..."; - }; - - common-wasm-deps-attrs = common-attrs // { - cargoExtraArgs = - "--package 'golden-gate-runtime-*' --target wasm32-unknown-unknown --no-default-features --features=aura,with-rocksdb-weights"; - RUSTFLAGS = - "-Clink-arg=--export=__heap_base -Clink-arg=--import-memory"; - }; - - common-wasm-attrs = common-wasm-deps-attrs // { - installPhase = '' - runHook preInstall - mkdir --parents $out/lib - cp ./target/wasm32-unknown-unknown/release/wbuild/golden-gate-runtime-*/golden_gate_runtime_*.compact.compressed.wasm $out/lib - runHook postInstall - ''; - }; - - common-native-release-attrs = common-attrs // rec { - cargoExtraArgs = "--package ${pname}"; - pname = "golden-gate-node"; - version = "0.1.0"; - }; - - common-native-release-deps = - craneLib.buildDepsOnly (common-native-release-attrs // { }); - common-wasm-release-deps = craneLib.buildDepsOnly common-wasm-deps-attrs; - - - # rust used by ci and developers - rust-toolchain = - pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml; - craneLib = (crane.mkLib pkgs).overrideToolchain rust-toolchain; - - # do not consier target to be part of source - rust-src = pkgs.lib.cleanSourceWith { - src = pkgs.lib.cleanSource ./.; - filter = pkgs.nix-gitignore.gitignoreFilterPure - (name: type: - # nix files are not used as part of build - ( - (type == "regular" && pkgs.lib.strings.hasSuffix ".nix" name) - == false - && - (type == "directory" && ".github" == name) == false - && (type == "directory" && "terraform" == name) == false - - # risky, until we move code into separate repo as rust can do include_str! as doc, but good optimization - && (type == "regular" && pkgs.lib.strings.hasSuffix ".md" name) == false - ) - ) - - [ ./.gitignore ] ./.; - }; - - golden-gate-runtimes = craneLib.buildPackage (common-wasm-attrs // rec { - pname = "golden-gate-runtimes"; - cargoArtifacts = common-wasm-release-deps; - }); - - golden-gate-node = craneLib.buildPackage (common-native-release-attrs // { - cargoArtifacts = common-native-release-deps; - nativeBuildInputs = common-native-release-attrs.nativeBuildInputs ++ [ pkgs.git ]; # parity does some git hacks in build.rs - }); - - fmt = craneLib.cargoFmt (common-attrs // { - cargoExtraArgs = "--all"; - rustFmtExtraArgs = "--color always"; - }); - - cargoClippyExtraArgs = "-- -D warnings"; - - clippy-node = craneLib.cargoClippy (common-native-release-attrs // { - inherit cargoClippyExtraArgs; - cargoArtifacts = golden-gate-node.cargoArtifacts; - }); - - clippy-wasm = craneLib.cargoClippy (common-wasm-deps-attrs // { - inherit cargoClippyExtraArgs; - cargoArtifacts = golden-gate-runtimes.cargoArtifacts; - }); - - # really need to run as some points: - # - light client emulator (ideal for contracts) - # - multi node local fast (fast druation low security) - # - multi local slow (duration and security as in prod) - # - here can apply above to remote with something if needed (terranix/terraform-ng works) - # for each - # - either start from genesis - # - of from fork (remote prod data) - # all with - archieval and logging enabled - - single-fast = pkgs.writeShellApplication rec { - name = "single-fast"; - text = '' - ${pkgs.lib.meta.getExe golden-gate-node} --dev - ''; - }; - - # we do not use existing Dotsama tools as they target relay + parachains - # here we can evolve into generating arion/systemd/podman/k8s output (what ever will fit) easy - multi-fast = pkgs.writeShellApplication rec { - name = "multi-fast"; - text = '' - WS_PORT_ALICE=''${WS_PORT_ALICE:-9988} - WS_PORT_BOB=''${WS_PORT_BOB:-9989} - WS_PORT_CHARLIE=''${WS_PORT_CHARLIE:-9990} - ( ${pkgs.lib.meta.getExe golden-gate-node} --chain=local --rpc-cors=all --alice --tmp --ws-port="$WS_PORT_ALICE" &> alice.log ) & - ( ${pkgs.lib.meta.getExe golden-gate-node} --chain=local --rpc-cors=all --bob --tmp --ws-port="$WS_PORT_BOB" &> bob.log ) & - ( ${pkgs.lib.meta.getExe golden-gate-node} --chain=local --rpc-cors=all --charlie --tmp --ws-port="$WS_PORT_CHARLIE" &> charlie.log ) & - echo https://polkadot.js.org/apps/?rpc=ws://127.0.0.1:"$WS_PORT_ALICE"#/explorer - ''; - }; - - doclint = pkgs.writeShellApplication rec { - name = "doclint"; - text = '' - ${pkgs.lib.meta.getExe pkgs.nodePackages.markdownlint-cli2} "**/*.md" "#.devenv" "#target" - ''; - }; - - - tf-init = pkgs.writeShellApplication rec { - name = "tf-init"; - text = '' - # here you manually obtain login key - aws configure - ''; - }; + pkgs = import nixpkgs { + inherit system overlays; + }; + in + { + # so basically cp pasted config to remote node with node binry + # really should generate config after terraform run and load it dynamically + testnet-node-a = let name = "node-a"; in nixpkgs.lib.nixosSystem { + inherit system; + modules = [ + { + nixpkgs.overlays = [ + (_: _: { + golden-gate-node = pkgs.golden-gate-node; + }) + ]; + } + ./flake/web3nix-module.nix + ./flake/nixos-amazon.nix + ] + ++ [ + ({ ... }: { + web3nix.admin.email = email; + services.nginx.virtualHosts = { + "${name}.${domain}" = { + addSSL = true; + enableACME = true; + root = "/var/www/default"; + # just stub for root page, can route to any usefull info or landing + locations."/" = { + root = pkgs.runCommand "testdir" { } '' + mkdir "$out" + echo "here could be golden gate pwa" > "$out/index.html" + ''; + }; + locations."/substrate/client" = { + # any all to external servers is routed to node + proxyPass = "http://127.0.0.1:${builtins.toString 9944}"; + proxyWebsockets = true; + }; + }; + }; + security = { + acme = { + defaults.email = email; + acceptTerms = true; + }; + }; + environment.systemPackages = [ pkgs.golden-gate-node ]; + systemd.services.golden-gate-node = { + wantedBy = [ "multi-user.target" ]; + after = [ "network.target" ]; + description = "substrate-node"; + serviceConfig = + { + Type = "simple"; + User = "root"; + # yeah, tune each unsafe on release + ExecStart = "${pkgs.lib.meta.getExe per_system.packages.${system}.run-testnet-node-a}"; + Restart = "always"; + }; + }; - # can use envvars override to allow run non shared "cloud" for tests - age-pub = "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5"; - cloud-tools = with pkgs; [ - awscli2 - terraform - sops - age - ]; - tf-apply = pkgs.writeShellApplication rec { - name = "tf-apply"; - runtimeInputs = cloud-tools; - text = '' - cd ./terraform - # generate terraform input from nix - cp --force ${tf-config} config.tf.json - terraform init --upgrade - - # decrypt secret state (should run only on CI eventually for safety) - # if there is encrypted state, decrypt it - if [[ -f terraform.tfstate.sops ]]; then - # uses age, so can use any of many providers (including aws) - sops --decrypt --age ${age-pub} terraform.tfstate.sops > terraform.tfstate - fi - - # apply state to cloud, eventually should manually approve in CI - terraform apply -auto-approve - # encrypt update state back and push it (later in CI special job) - sops --encrypt --age ${age-pub} terraform.tfstate > terraform.tfstate.sops - # seems good idea to encrypt backup here too - ''; - }; + }) + ]; + }; + testnet-node-b = let name = "node-b"; in nixpkgs.lib.nixosSystem { + inherit system; + modules = [ + { + nixpkgs.overlays = [ + (_: _: { + golden-gate-node = pkgs.golden-gate-node; + }) + ]; + } + ./flake/web3nix-module.nix + ./flake/nixos-amazon.nix + ] + ++ [ + ({ ... }: { + web3nix.admin.email = email; + services.nginx.virtualHosts = { + "${name}.${domain}" = { + addSSL = true; + enableACME = true; + root = "/var/www/default"; + # just stub for root page, can route to any usefull info or landing + locations."/" = { + root = pkgs.runCommand "testdir" { } '' + mkdir "$out" + echo "here could be golden gate pwa" > "$out/index.html" + ''; + }; + locations."/substrate/client" = { + # any all to external servers is routed to node + proxyPass = "http://127.0.0.1:${builtins.toString 9944}"; + proxyWebsockets = true; + }; + }; + }; + security = { + acme = { + defaults.email = email; + acceptTerms = true; + }; + }; + environment.systemPackages = [ pkgs.golden-gate-node ]; + systemd.services.golden-gate-node = + { + wantedBy = [ "multi-user.target" ]; + after = [ "network.target" ]; + description = "substrate-node"; + serviceConfig = { + Type = "simple"; + User = "root"; + ExecStart = "${pkgs.lib.meta.getExe per_system.packages.${system}.run-testnet-node-b}"; + Restart = "always"; + }; + }; - tf-config = terranix.lib.terranixConfiguration { - inherit system; - modules = [ ./flake/terraform.nix ]; - }; - in - rec { - packages = flake-utils.lib.flattenTree rec { - inherit golden-gate-runtimes golden-gate-node single-fast multi-fast tf-config tf-apply doclint fmt clippy-node clippy-wasm; - node = golden-gate-node; - lint = pkgs.symlinkJoin { - name = "linting"; - paths = [ doclint fmt clippy-node clippy-wasm ]; - }; - release = pkgs.symlinkJoin { - name = "release"; - paths = [ node golden-gate-runtimes ]; - }; - default = release; - # we should prune 3 things: - # - running process - # - logs/storages of run proccess - # - system prunce of nix cache/oci images - prune-running = pkgs.writeShellApplication rec { - name = "prune-running"; - text = '' - pkill golden-gate-nod - ''; + }) + ]; }; - }; - - devShells = { - default = devenv.lib.mkShell { - inherit inputs pkgs; - modules = - let - dylib = { - buildInputs = with pkgs; [ openssl ] ++ darwin; - nativeBuildInputs = rust-native-build-inputs; - doCheck = false; + testnet-node-c = let name = "node-c"; in nixpkgs.lib.nixosSystem { + inherit system; + modules = [ + { + nixpkgs.overlays = [ + (_: _: { + golden-gate-node = pkgs.golden-gate-node; + }) + ]; + } + ./flake/web3nix-module.nix + ./flake/nixos-amazon.nix + ] + ++ [ + ({ ... }: { + web3nix.admin.email = email; + services.nginx.virtualHosts = { + "${name}.${domain}" = { + addSSL = true; + enableACME = true; + root = "/var/www/default"; + # just stub for root page, can route to any usefull info or landing + locations."/" = { + root = pkgs.runCommand "testdir" { } '' + mkdir "$out" + echo "here could be golden gate pwa" > "$out/index.html" + ''; + }; + locations."/substrate/client" = { + # any all to external servers is routed to node + proxyPass = "http://127.0.0.1:${builtins.toString 9944}"; + proxyWebsockets = true; + }; + }; }; - rust-deps = pkgs.makeRustPlatform { - inherit pkgs; - # dylint needs nightly - cargo = pkgs.rust-bin.beta.latest.default; - rustc = pkgs.rust-bin.beta.latest.default; + security = { + acme = { + defaults.email = email; + acceptTerms = true; + }; }; - cargo-dylint = with pkgs; rust-deps.buildRustPackage (rec { - pname = "cargo-dylint"; - version = "2.1.5"; - src = fetchCrate { - inherit pname version; - sha256 = "sha256-kH6dhUFaQpQ0kvzNyLIXjFAO8VNa2jah6ZaDO7LQKO0="; + environment.systemPackages = [ pkgs.golden-gate-node ]; + systemd.services.golden-gate-node = + { + wantedBy = [ "multi-user.target" ]; + after = [ "network.target" ]; + description = "substrate-node"; + serviceConfig = { + Type = "simple"; + User = "root"; + ExecStart = "${pkgs.lib.meta.getExe per_system.packages.${system}.run-testnet-node-c}"; + Restart = "always"; + }; }; - cargoHash = "sha256-YvQI3H/4eWe6r2Tg8qHJqfnw/NpuGHtkRuTL4EzF0xo="; - cargoDepsName = pname; - } // dylib); - dylint-link = with pkgs; rust-deps.buildRustPackage (rec { - pname = "dylint-link"; - version = "2.1.5"; - src = fetchCrate { - inherit pname version; - sha256 = "sha256-oarEYhv0i2wAPmahx0vgWN3kmfEsK3s6D3+qkOqF9pc="; - }; + }) + ]; + }; - cargoHash = "sha256-pMr9hddHAIyIclHRpxqdUaHphjSAVDnvfNjWGDA2EM4="; - cargoDepsName = pname; - } // dylib); - # can `cargo-contract` and nodejs ui easy here - in - [ - { - packages = with pkgs; - [ - rust-toolchain - binaryen - llvmPackages.bintools - dylint-link - nodejs-18_x - nodePackages.markdownlint-cli2 - - ] - ++ rust-native-build-inputs ++ darwin ++ cloud-tools; - env = rust-env; - # can do systemd/docker stuff here - enterShell = '' - echo ggshell - ''; + testnet-node-d = let name = "node-d"; in nixpkgs.lib.nixosSystem { + inherit system; + modules = [ + { + nixpkgs.overlays = [ + (_: _: { + golden-gate-node = pkgs.golden-gate-node; + }) + ]; + } + ./flake/web3nix-module.nix + ./flake/nixos-amazon.nix + ] + ++ [ + ({ ... }: { + web3nix.admin.email = email; + services.nginx.virtualHosts = { + "${name}.${domain}" = { + addSSL = true; + enableACME = true; + root = "/var/www/default"; + # just stub for root page, can route to any usefull info or landing + locations."/" = { + root = pkgs.runCommand "testdir" { } '' + mkdir "$out" + echo "here could be golden gate pwa" > "$out/index.html" + ''; + }; + locations."/substrate/client" = { + # any all to external servers is routed to node + proxyPass = "http://127.0.0.1:${builtins.toString 9944}"; + proxyWebsockets = true; + }; + }; + }; + security = { + acme = { + defaults.email = email; + acceptTerms = true; + }; + }; + environment.systemPackages = [ pkgs.golden-gate-node ]; + systemd.services.golden-gate-node = + { + wantedBy = [ "multi-user.target" ]; + after = [ "network.target" ]; + description = "substrate-node"; + serviceConfig = { + Type = "simple"; + User = "root"; + ExecStart = "${pkgs.lib.meta.getExe per_system.packages.${system}.run-testnet-node-d}"; + Restart = "always"; + }; + }; - # GH Codespace easy to run (e.g. for Mac users, low spec machines or Frontend developers or hackatons) - devcontainer.enable = true; - } - ]; + }) + ]; }; }; - } - ); -} \ No newline at end of file + }; +} + diff --git a/flake/nixos-amazon.nix b/flake/nixos-amazon.nix new file mode 100644 index 00000000..deaec7a5 --- /dev/null +++ b/flake/nixos-amazon.nix @@ -0,0 +1,64 @@ +({ pkgs, lib, config, options, specialArgs, modulesPath }: +let + ws_port = 9944; + allowedTCPPorts = [ 80 443 8080 8443 5000 5001 3000 9988 ws_port 9933 30333 9615 ]; +in +{ + system.stateVersion = "22.11"; + nix = { + package = pkgs.nixFlakes; + extraOptions = '' + experimental-features = nix-command flakes + sandbox = relaxed + ''; + settings = { + trusted-users = [ "root" "admin" ]; + extra-substituters = [ "https://cache.nixos.org" "https://golden-gate-ggx.cachix.org" ]; + extra-trusted-public-keys = [ "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" "golden-gate-ggx.cachix.org-1:h2zGCI9FqxUS7HxnZJDHaJzbN4iTsWvBcETdd+/0ZD4=" ]; + }; + }; + + imports = + [ "${toString modulesPath}/virtualisation/amazon-image.nix" ]; + services.openssh.passwordAuthentication = lib.mkForce true; + services.openssh.permitRootLogin = lib.mkForce "yes"; + + security = { + acme = { + acceptTerms = true; + }; + }; + services.nginx.enable = true; + services.nginx.virtualHosts = { + "_" = { + # addSSL = true; + #enableACME = true; + root = "/var/www/default"; + # just stub for root page, can route to any usefull info or landing + locations."/" = { + root = pkgs.runCommand "testdir" { } '' + mkdir "$out" + echo "golden gate base image" > "$out/index.html" + ''; + }; + locations."/substrate/client" = { + # any all to external servers is routed to node + proxyPass = "http://127.0.0.1:${builtins.toString ws_port}"; + proxyWebsockets = true; + }; + }; + }; + services.nginx.logError = "stderr debug"; + + networking.firewall = { + enable = true; + inherit allowedTCPPorts; + # not secure + allowedTCPPortRanges = [{ + from = 80; + to = 40000; + }]; + }; + + environment.systemPackages = with pkgs; [ git helix curl websocat jq]; # add here various substrate tools, like subkey, subxt +}) diff --git a/flake/terraform.nix b/flake/terraform.nix deleted file mode 100644 index 0b138d09..00000000 --- a/flake/terraform.nix +++ /dev/null @@ -1,35 +0,0 @@ -{ config, lib, options, specialArgs }: -let - var = options.variable; - # really should do TF_VAR so can arbitrary global suffixes and experimentation - projet-name = "ggchain"; - # just ensure we do not to modify manually - tags = { - tool = "terranix"; - }; -in -rec { - provider = { - aws = { - region = "eu-west-1"; - }; - }; - - resource = { - aws_s3_bucket = { - terraform-backend = { - # just for testing - bucket = "new-just-some-storage-${projet-name}"; - inherit tags; - }; - }; - }; - - backend = { - local = { - # that value is decrypted by script, update, and encrypted back - path = "terraform.tfstate"; - }; - }; - -} diff --git a/flake/terraform/base.nix b/flake/terraform/base.nix new file mode 100644 index 00000000..cb5f12e8 --- /dev/null +++ b/flake/terraform/base.nix @@ -0,0 +1,241 @@ +# just link i used to steal config +# https://zimbatm.com/notes/deploying-to-aws-with-terraform-and-nix +# https://xeiaso.net/blog/paranoid-nixos-aws-2021-08-11 +# https://github.com/dzmitry-lahoda/web3nix +# security setup of some resources basically low to speed up, needs iterations of hardening +{ config, lib, options, specialArgs }: +let + var = options.variable; + + # just ensure we do not to modify manually + # really need to map all resources and automatically tag + tags = { + tool = "terranix"; + }; + volume_size_gb = 82; +in +rec { + variable = { + NODE_IMAGE = { + type = "string"; + }; + + AWS_REGION = { + type = "string"; + }; + + # assuming that it can be run by other validators + VALIDATOR_NAME = { + type = "string"; + description = "should be more than 3 but less then 12 symbols, only lower case letters"; + }; + }; + + provider = { + aws = { + region = "\${var.AWS_REGION}"; + }; + }; + + output = { + ami-a = { + value = "\${resource.aws_ami.node-image-base.id}"; + }; + }; + + # just for running some machines, here will be nixos-generators based VM uploaded to S3 with running validator + data = { + # Permissions for the AWS instance + aws_iam_policy_document = { + machine = { + statement = { + sid = "1"; + # not secure + actions = [ + "s3:ListAllMyBuckets" + "s3:GetBucketLocation" + "s3:ListBucket" + "s3:GetObject" + "s3:GetBucketLocation" + ]; + + resources = [ + "arn:aws:s3:::*" + ]; + }; + }; + }; + + }; + resource = { + # A bunch of IAM resources needed to give permissions to the instance + aws_iam_role = { + machine = { + name = "\${var.VALIDATOR_NAME}"; + + assume_role_policy = '' + { + "Version": "2012-10-17", + "Statement": [ + { + "Action": "sts:AssumeRole", + "Principal": { + "Service": "ec2.amazonaws.com" + }, + "Effect": "Allow", + "Sid": "" + } + ] + } + ''; + }; + vmimport = { + inherit tags; + name = "vmimport\${var.VALIDATOR_NAME}" ; + assume_role_policy = '' + { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Principal": { "Service": "vmie.amazonaws.com" }, + "Action": "sts:AssumeRole", + "Condition": { + "StringEquals":{ + "sts:Externalid": "vmimport" + } + } + } + ] + } + ''; + }; + + }; + + aws_iam_role_policy = { + machine = { + name = "\${var.VALIDATOR_NAME}"; + role = "\${aws_iam_role.machine.name}"; + policy = "\${data.aws_iam_policy_document.machine.json}"; + }; + + vmimport_policy = { + name = "vmimport\${var.VALIDATOR_NAME}"; + role = "\${aws_iam_role.vmimport.id}"; + policy = '' + { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": [ + "s3:ListBucket", + "s3:GetObject", + "s3:GetBucketLocation" + ], + "Resource": [ + "''${aws_s3_bucket.deploy.arn}", + "''${aws_s3_bucket.deploy.arn}/*" + ] + }, + { + "Effect": "Allow", + "Action": [ + "s3:GetBucketLocation", + "s3:GetObject", + "s3:ListBucket", + "s3:PutObject", + "s3:GetBucketAcl" + ], + "Resource": [ + "''${aws_s3_bucket.deploy.arn}", + "''${aws_s3_bucket.deploy.arn}/*" + ] + }, + { + "Effect": "Allow", + "Action": [ + "ec2:ModifySnapshotAttribute", + "ec2:CopySnapshot", + "ec2:RegisterImage", + "ec2:Describe*" + ], + "Resource": "*" + } + ] + } + ''; + }; + + }; + + + aws_s3_bucket = { + deploy = { + bucket = "deploy-instance-storage-\${var.VALIDATOR_NAME}"; + inherit tags; + }; + }; + + + aws_s3_object = { + nixos-a = { + bucket = "\${aws_s3_bucket.deploy.bucket}"; + key = "nixos-amazon-\${var.VALIDATOR_NAME}.vhd"; + + source = "\${var.NODE_IMAGE}"; + source_hash = "\${filemd5(var.NODE_IMAGE)}"; + + + lifecycle = { + ignore_changes = [ + "key" + "etag" + ]; + }; + }; + }; + + aws_ebs_snapshot_import = { + nixos-a = { + disk_container = { + format = "VHD"; + user_bucket = { + s3_bucket = "\${aws_s3_bucket.deploy.bucket}"; + s3_key = "\${aws_s3_object.nixos-a.key}"; + }; + }; + role_name = "\${aws_iam_role.vmimport.name}"; + }; + }; + + aws_ami = { + node-image-base = { + name = "node-image-base-\${var.VALIDATOR_NAME}"; + architecture = "x86_64"; + virtualization_type = "hvm"; + root_device_name = "/dev/xvda"; + ena_support = true; + sriov_net_support = "simple"; + + ebs_block_device = { + device_name = "/dev/xvda"; + snapshot_id = "\${aws_ebs_snapshot_import.nixos-a.id}"; + volume_size = volume_size_gb; + delete_on_termination = true; + volume_type = "gp3"; + }; + }; + }; + }; + + + backend = { + local = { + # that value is decrypted by script, update, and encrypted back + path = "terraform-base.tfstate"; + }; + }; + +} diff --git a/flake/terraform/testnet.nix b/flake/terraform/testnet.nix new file mode 100644 index 00000000..abb1dfdf --- /dev/null +++ b/flake/terraform/testnet.nix @@ -0,0 +1,396 @@ +# just link i used to steal config +# https://zimbatm.com/notes/deploying-to-aws-with-terraform-and-nix +# https://xeiaso.net/blog/paranoid-nixos-aws-2021-08-11 +# https://github.com/dzmitry-lahoda/web3nix +# security setup of some resources basically low to speed up, needs iterations of hardening +{ config, lib, options, specialArgs }: +let + var = options.variable; + + # just ensure we do not to modify manually + tags = { + tool = "terranix"; + }; + disk_size_in_gb = 84; + instance_type = "t2.medium"; +in +rec { + variable = { + # for PD.js and Metamask connection + DOMAIN_NAME = { + type = "string"; + }; + + AWS_REGION = { + type = "string"; + }; + + # assuming that it can be run by other validators + VALIDATOR_NAME = { + type = "string"; + description = "should be more than 3 but less then 12 symbols, only lower case letters"; + }; + }; + terraform = { + required_providers = { + acme = { + source = "vancluever/acme"; + version = "2.13.1"; + }; + uptime = { + source = "onesdata/uptime"; + version = "1.0.1"; + }; + }; + }; + provider = { + aws = { + region = "\${var.AWS_REGION}"; + }; + acme = { + server_url = "https://acme-staging-v02.api.letsencrypt.org/directory"; + }; + uptime = { }; + }; + + output = { + node_public_dns_a = { + value = "\${resource.aws_instance.node-a.public_dns}"; + }; + node_public_ip_a = { value = "\${resource.aws_instance.node-a.public_ip}"; }; + + ssh_a = { value = "ssh -i ./terraform/testnet/id_rsa.pem root@\${resource.aws_instance.node-a.public_dns}"; }; + + node_public_dns_b = { + value = "\${resource.aws_instance.node-b.public_dns}"; + }; + node_public_ip_b = { value = "\${resource.aws_instance.node-b.public_ip}"; }; + + ssh_b = { value = "ssh -i ./terraform/testnet/id_rsa.pem root@\${resource.aws_instance.node-b.public_dns}"; }; + + node_public_dns_c = { + value = "\${resource.aws_instance.node-c.public_dns}"; + }; + node_public_ip_c = { value = "\${resource.aws_instance.node-c.public_ip}"; }; + + ssh_c = { value = "ssh -i ./terraform/testnet/id_rsa.pem root@\${resource.aws_instance.node-c.public_dns}"; }; + + node_public_dns_d = { + value = "\${resource.aws_instance.node-d.public_dns}"; + }; + node_public_ip_d = { value = "\${resource.aws_instance.node-d.public_ip}"; }; + + ssh_d = { value = "ssh -i ./terraform/testnet/id_rsa.pem root@\${resource.aws_instance.node-d.public_dns}"; }; + }; + + # just for running some machines, here will be nixos-generators based VM uploaded to S3 with running validator + data = { + local_sensitive_file = { + node-a-key-ed = { + filename = "\${path.module}/../../.secret/node-a.ed25519.json"; + }; + node-a-key-sr = { + filename = "\${path.module}/../../.secret/node-a.sr25519.json"; + }; + + node-b-key-ed = { + filename = "\${path.module}/../../.secret/node-b.ed25519.json"; + }; + node-b-key-sr = { + filename = "\${path.module}/../../.secret/node-b.sr25519.json"; + }; + node-c-key-ed = { + filename = "\${path.module}/../../.secret/node-c.ed25519.json"; + }; + node-c-key-sr = { + filename = "\${path.module}/../../.secret/node-c.sr25519.json"; + }; + + node-d-key-ed = { + filename = "\${path.module}/../../.secret/node-d.ed25519.json"; + }; + node-d-key-sr = { + filename = "\${path.module}/../../.secret/node-d.sr25519.json"; + }; + }; + + # Permissions for the AWS instance + aws_iam_policy_document = { + machine = { + statement = { + sid = "1"; + # not secure + actions = [ + "s3:ListAllMyBuckets" + "s3:GetBucketLocation" + "s3:ListBucket" + "s3:GetObject" + "s3:GetBucketLocation" + ]; + + resources = [ + "arn:aws:s3:::*" + ]; + }; + }; + }; + + }; + resource = + let + mkSubZoneA = name: ip: { + zone_id = "\${aws_route53_zone.primary.zone_id}"; + name = "${name}.\${var.DOMAIN_NAME}"; + type = "A"; + ttl = 300; + # better use elastic ip to split machine from IP and make IP more stable (sta) + records = [ ip ]; + }; + + mkUpTime = name: { + name = "Node"; + address = "${name}.\${var.DOMAIN_NAME}"; + contact_groups = [ "Default" ]; + interval = 1; + locations = [ "US East" "United Kingdom" ]; + }; + + mkMonitoredZone = name: ip: { + uptime_check_http = { + "${name}" = mkUpTime name; + }; + aws_route53_health_check = { + "${name}" = { + fqdn = "\${aws_route53_record.${name}.name}"; + port = 443; + type = "HTTPS"; + resource_path = "/"; + failure_threshold = "5"; + request_interval = "30"; + inherit tags; + }; + }; + aws_route53_record = { + "${name}" = mkSubZoneA name ip; + }; + }; + + a = mkMonitoredZone "node-a" "\${aws_instance.node-a.public_ip}"; + b = mkMonitoredZone "node-b" "\${aws_instance.node-b.public_ip}"; + c = mkMonitoredZone "node-c" "\${aws_instance.node-c.public_ip}"; + d = mkMonitoredZone "node-d" "\${aws_instance.node-d.public_ip}"; + + monitored-zones = builtins.foldl' lib.recursiveUpdate {} [a b c d]; + in + monitored-zones // { + # generate a SSH key-pair + tls_private_key = { + machine = { + algorithm = "RSA"; + }; + }; + + # Record the SSH public key into AWS + aws_key_pair = { + machine = { + key_name = "centralization-risk-\${var.VALIDATOR_NAME}"; + public_key = "\${tls_private_key.machine.public_key_openssh}"; + }; + }; + + acme_registration = { + reg = { + account_key_pem = "\${tls_private_key.machine.private_key_pem}"; + email_address = "\${aws_route53domains_registered_domain.nodes.admin_contact[0].email}"; + }; + }; + # move to web layer to avoid rebuilds + acme_certificate = { + certificate = { + account_key_pem = "\${acme_registration.reg.account_key_pem}"; + common_name = "\${aws_route53_zone.primary.name}"; + subject_alternative_names = [ "*.\${aws_route53_zone.primary.name}" ]; + + dns_challenge = { + provider = "route53"; + config = { + AWS_DEFAULT_REGION = "\${var.AWS_REGION}"; + AWS_HOSTED_ZONE_ID = "\${aws_route53_zone.primary.zone_id}"; + AWS_PROPAGATION_TIMEOUT = 900; + AWS_POLLING_INTERVAL = 60; + AWS_MAX_RETRIES = 100; + }; + }; + }; + }; + + # Store the private key locally. This is going to be used by the deploy_nixos module below + # to deploy NixOS. + local_sensitive_file = + { + machine_ssh_key = { + content = "\${tls_private_key.machine.private_key_pem}"; + filename = "id_rsa.pem"; + file_permission = "0600"; + }; + }; + + aws_security_group = { + machine = { + name = "\${var.VALIDATOR_NAME}"; + }; + }; + + # A bunch of rules for the group + aws_security_group_rule = { + machine_ingress_ssh = { + description = "non secure access via all ports"; + type = "ingress"; + from_port = 0; + to_port = 65535; + protocol = "all"; + cidr_blocks = [ "0.0.0.0/0" ]; + security_group_id = "\${aws_security_group.machine.id}"; + }; + machine_egress_all = { + description = "Allow to connect to the whole Internet"; + type = "egress"; + from_port = 0; + to_port = 0; + protocol = "-1"; + cidr_blocks = [ "0.0.0.0/0" ]; + security_group_id = "\${aws_security_group.machine.id}"; + }; + }; + + # A bunch of IAM resources needed to give permissions to the instance + aws_iam_role = { + machine = { + name = "machine-\${var.VALIDATOR_NAME}"; + + assume_role_policy = '' + { + "Version": "2012-10-17", + "Statement": [ + { + "Action": "sts:AssumeRole", + "Principal": { + "Service": "ec2.amazonaws.com" + }, + "Effect": "Allow", + "Sid": "" + } + ] + } + ''; + }; + vmimport = { + name = "vmimport-\${var.VALIDATOR_NAME}"; + assume_role_policy = '' + { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Principal": { "Service": "vmie.amazonaws.com" }, + "Action": "sts:AssumeRole", + "Condition": { + "StringEquals":{ + "sts:Externalid": "vmimport" + } + } + } + ] + } + ''; + }; + + }; + + aws_iam_role_policy = { + machine = { + name = "\${var.VALIDATOR_NAME}"; + role = "\${aws_iam_role.machine.name}"; + policy = "\${data.aws_iam_policy_document.machine.json}"; + }; + }; + + aws_instance = + let + mkNode = key: { + ami = "ami-05173ee0952a97126"; # us tf data either from cloud or from backend file + inherit instance_type; + security_groups = [ + "\${aws_security_group.machine.name}" + ]; + key_name = "\${aws_key_pair.machine.key_name}"; + inherit tags; + associate_public_ip_address = true; + root_block_device = { + volume_size = disk_size_in_gb; + }; + + # not ideal, better mount via user_data in script/cloud-init + # or mount volume or build image + provisioner = { + file = [{ + source = "\${path.module}/../../.secret/${key}.ed25519.json"; + destination = "ed25519.json"; + connection = { + type = "ssh"; + user = "root"; + private_key = "\${local_sensitive_file.machine_ssh_key.content}"; + host = "\${self.public_ip}"; + }; + } + { + source = "\${path.module}/../../.secret/${key}.sr25519.json"; + destination = "sr25519.json"; + connection = { + type = "ssh"; + user = "root"; + private_key = "\${local_sensitive_file.machine_ssh_key.content}"; + host = "\${self.public_ip}"; + }; + }]; + }; + + # really can mount keys and chain data storage here via ebs_block_device + }; + in + { + node-a = mkNode "node-a"; + node-b = mkNode "node-b"; + node-c = mkNode "node-c"; + node-d = mkNode "node-d"; + }; + + aws_route53domains_registered_domain = { + nodes = { + domain_name = "\${var.DOMAIN_NAME}"; + registrant_privacy = false; + admin_privacy = false; + tech_privacy = false; + inherit tags; + name_server = [ + { name = "\${aws_route53_zone.primary.name_servers[0]}"; } + { name = "\${aws_route53_zone.primary.name_servers[1]}"; } + { name = "\${aws_route53_zone.primary.name_servers[2]}"; } + { name = "\${aws_route53_zone.primary.name_servers[3]}"; } + ]; + }; + }; + + aws_route53_zone = { + primary = { + name = "\${var.DOMAIN_NAME}"; + }; + }; + }; + backend = { + local = { + # that value is decrypted by script, update, and encrypted back + path = "terraform-testnet.tfstate"; + }; + }; +} diff --git a/flake/web3nix-module.nix b/flake/web3nix-module.nix new file mode 100644 index 00000000..03b02a24 --- /dev/null +++ b/flake/web3nix-module.nix @@ -0,0 +1,18 @@ +# specific setups and tunes for hosting parity substrate p2p nodey +{ pkgs, config, ... }: +with pkgs.lib; +let + cfg = config.web3nix; +in +{ + + options = { + web3nix.admin.email = pkgs.lib.mkOption { + type = types.str; + }; + }; + + config = { + security.acme.defaults.email = cfg.admin.email; + }; +} diff --git a/node/Cargo.toml b/node/Cargo.toml index 11ea51b4..c3db953d 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "golden-gate-node" -version = "0.0.0" +version = "0.0.1" license = "Unlicense" build = "build.rs" description = "A fresh FRAME-based Substrate node, ready for hacking." diff --git a/node/src/command.rs b/node/src/command.rs index 3114396b..fade760e 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -59,6 +59,10 @@ impl SubstrateCli for Cli { Ok(match id { "dev" => Box::new(chain_spec::development_config()?), "" | "local" => Box::new(chain_spec::local_testnet_config()?), + // on """release""", replace with included resource + "testnet" | "remote-testnet" | "testnet-remote" => { + Box::new(runtime::remote_testnet_config()?) + } path => Box::new(chain_spec::ChainSpec::from_json_file( std::path::PathBuf::from(path), )?), diff --git a/node/src/runtime/chain_spec.rs b/node/src/runtime/chain_spec.rs new file mode 100644 index 00000000..288c4314 --- /dev/null +++ b/node/src/runtime/chain_spec.rs @@ -0,0 +1,154 @@ +use golden_gate_runtime_mainnet::WASM_BINARY; +use sc_service::ChainType; +use sp_core::{crypto::Ss58Codec, ed25519, sr25519, Pair, Public, H160, U256}; +use sp_runtime::traits::{IdentifyAccount, Verify}; + +use crate::runtime::{ + get_account_id_from_seed, testnet_genesis, AccountId, GenesisConfig, ValidatorIdentity, +}; + +pub type ChainSpec = sc_service::GenericChainSpec; + +/// Generate a crypto pair from seed. +pub fn get_from_seed(seed: &str) -> ::Public { + TPublic::Pair::from_string(&format!("//{seed}"), None) + .expect("static values are valid; qed") + .public() +} + +type AccountPublic = ::Signer; + +/// Generate an account ID from seed. +pub fn get_account_id_from_seed(seed: &str) -> AccountId +where + AccountPublic: From<::Public>, +{ + AccountPublic::from(get_from_seed::(seed)).into_account() +} + +#[derive(Debug, Clone)] +struct ValidatorIdentity { + id: AccountId, + grandpa: GrandpaId, + aura: AuraId, + im_online: ImOnlineId, +} + +fn authority_keys_from_seed(s: &str) -> ValidatorIdentity { + ValidatorIdentity { + id: AccountPublic::from(get_from_seed::(s)).into_account(), + aura: get_from_seed::(s), + grandpa: get_from_seed::(s), + im_online: get_from_seed::(s), + } +} + +fn authority_keys_from_pub(ed: &str, sr: &str) -> ValidatorIdentity { + ValidatorIdentity { + id: sr25519::Public::from_ss58check(sr) + .unwrap() + .into_account() + .into(), + aura: sr25519::Public::from_ss58check(sr) + .unwrap() + .into_account() + .into(), + grandpa: ed25519::Public::from_ss58check(ed) + .unwrap() + .into_account() + .into(), + im_online: sr25519::Public::from_ss58check(sr) + .unwrap() + .into_account() + .into(), + } +} + +pub fn development_config() -> Result { + let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; + + Ok(ChainSpec::from_genesis( + // Name + "Development", + // ID + "dev", + ChainType::Development, + move || { + testnet_genesis( + wasm_binary, + // Sudo account + get_account_id_from_seed::("Alice"), + // Pre-funded accounts + vec![ + // Alice pub in EVM is: 0xd43593c715fdd31c61141abd04a99fd6822c8558 + get_account_id_from_seed::("Alice"), + get_account_id_from_seed::("Bob"), + get_account_id_from_seed::("Alice//stash"), + get_account_id_from_seed::("Bob//stash"), + // Arrakis.TEST account in MetaMask + // Import known test account with private key + // 0x01ab6e801c06e59ca97a14fc0a1978b27fa366fc87450e0b65459dd3515b7391 + // H160 address: 0xaaafB3972B05630fCceE866eC69CdADd9baC2771 + AccountId::from_ss58check("5FQedkNQcF2fJPwkB6Z1ZcMgGti4vcJQNs6x85YPv3VhjBBT") + .unwrap(), + ], + // Initial PoA authorities + vec![ValidatorIdentity::from_seed("Alice")], + 42, + ) + }, + // Bootnodes + vec![], + // Telemetry + None, + // Protocol ID + None, + None, + // Properties + None, + // Extensions + None, + )) +} + +pub fn local_testnet_config() -> Result { + let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; + + Ok(ChainSpec::from_genesis( + // Name + "Local Testnet", + // ID + "local_testnet", + ChainType::Local, + move || { + testnet_genesis( + wasm_binary, + // Initial PoA authorities + // Sudo account + get_account_id_from_seed::("Alice"), + // Pre-funded accounts + vec![ + get_account_id_from_seed::("Alice"), + get_account_id_from_seed::("Bob"), + get_account_id_from_seed::("Charlie"), + ], + vec![ + ValidatorIdentity::from_seed("Alice"), + ValidatorIdentity::from_seed("Bob"), + ], + 42, + ) + }, + // Bootnodes + vec![], + // Telemetry + None, + // Protocol ID + None, + None, + // Properties + None, + // Extensions + None, + )) +} \ No newline at end of file diff --git a/node/src/runtime/testnet.rs b/node/src/runtime/testnet.rs index f407112c..385ad126 100644 --- a/node/src/runtime/testnet.rs +++ b/node/src/runtime/testnet.rs @@ -2,9 +2,12 @@ use std::{collections::BTreeMap, str::FromStr}; pub use golden_gate_runtime_testnet::{opaque::SessionKeys, *}; -use sp_core::{sr25519, H160, U256}; +use sc_service::ChainType; +use sp_core::{crypto::Ss58Codec, ed25519, sr25519, H160, U256}; use sp_runtime::traits::IdentifyAccount; +use crate::chain_spec::ChainSpec; + use super::{get_from_seed, AccountPublic}; #[derive(Debug, Clone)] @@ -137,3 +140,94 @@ pub fn testnet_genesis( im_online: Default::default(), } } + +pub fn remote_testnet_config() -> Result { + let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; + + Ok(ChainSpec::from_genesis( + "Remote Testnet", + "remote_testnet", + ChainType::Live, + move || { + testnet_genesis( + wasm_binary, + // Initial PoA authorities + // Sudo account + sr25519::Public::from_ss58check("5EHkPQgHPKLT4XTEkZcVWpwvLziBS3Qf2oUg94YAk79YVFdw") + .unwrap() + .into_account() + .into(), + // Pre-funded accounts + vec![ + sr25519::Public::from_ss58check( + "5EHkPQgHPKLT4XTEkZcVWpwvLziBS3Qf2oUg94YAk79YVFdw", + ) + .unwrap() + .into_account() + .into(), + sr25519::Public::from_ss58check( + "5HfttHcGC3JLXepPFmeLvgNaejUwhfC8icgxWwxFLqb6uJXU", + ) + .unwrap() + .into_account() + .into(), + sr25519::Public::from_ss58check( + "5GsmpjRRkTt8XRnyiupJUBbjEtYio7cjqM8DcArT7mdiZZF7", + ) + .unwrap() + .into_account() + .into(), + ], + vec![ + authority_keys_from_pub( + "5GWHWMD1eFZkkZZ2XRMSwhsbdXhwirfKHJm4LYh66khuwxgT", + "5EHkPQgHPKLT4XTEkZcVWpwvLziBS3Qf2oUg94YAk79YVFdw", + ), + authority_keys_from_pub( + "5Dos85SfdWJbh2RAkTLpViwjJXcSpkZjn9B5FGRCsCWQ4cT3", + "5HfttHcGC3JLXepPFmeLvgNaejUwhfC8icgxWwxFLqb6uJXU", + ), + authority_keys_from_pub( + "5DMjxJDSWR1uBQ8fN5o7fxUxpE3MeePf3b5f5iqTxm4KaLBY", + "5GsmpjRRkTt8XRnyiupJUBbjEtYio7cjqM8DcArT7mdiZZF7", + ), + ], + 888888, + ) + }, + // Bootnodes + vec![], + // Telemetry + None, + // Protocol ID + None, + None, + // Properties + None, + // Extensions + None, + )) +} + +fn authority_keys_from_pub(ed: &str, sr: &str) -> ValidatorIdentity { + ValidatorIdentity { + id: sr25519::Public::from_ss58check(sr) + .unwrap() + .into_account() + .into(), + session_keys: SessionKeys { + aura: sr25519::Public::from_ss58check(sr) + .unwrap() + .into_account() + .into(), + grandpa: ed25519::Public::from_ss58check(ed) + .unwrap() + .into_account() + .into(), + im_online: sr25519::Public::from_ss58check(sr) + .unwrap() + .into_account() + .into(), + }, + } +} diff --git a/terraform/.terraform.lock.hcl b/terraform/.terraform.lock.hcl deleted file mode 100644 index adcbc198..00000000 --- a/terraform/.terraform.lock.hcl +++ /dev/null @@ -1,24 +0,0 @@ -# This file is maintained automatically by "terraform init". -# Manual edits may be lost in future updates. - -provider "registry.terraform.io/hashicorp/aws" { - version = "4.59.0" - hashes = [ - "h1:fuIdjl9f2JEH0TLoq5kc9NIPbJAAV7YBbZ8fvNp5XSg=", - "zh:0341a460210463a0bebd5c12ce13dc49bd8cae2399b215418c5efa607fed84e4", - "zh:0544e9bbdd31d3551e7273bed7326d26a28653fd9c26b5cd06ac8ed76f188798", - "zh:3d13acd0363f0a48d2725cae9d224481df38dddb90ef4a66eb82303f0aa45a99", - "zh:416f5b92d41dce1d7ee1a1acb06ba8b0f10679eecee2fcc134853adbb09d9757", - "zh:80c9c3b901151cd697caa58bfa196816d4622e4ce11aa789e36efc460695313b", - "zh:8fc3659ebdae1ac9de899f57e5a3a50274a2e96c46aa2cf74be51ffdac56300a", - "zh:9b12af85486a96aedd8d7984b0ff811a4b42e3d88dad1a3fb4c0b580d04fa425", - "zh:a235b44ad074446a6138b3fb454dd0d234aacf7a1efea89d1eafac7284689d19", - "zh:a36a7f1cd7f9f6c45127d916a65b5441cc0430393535a5a3de4b646405c50c41", - "zh:c161c38727902271efa19020b95b69ebe0282989d575f31dff603a1d551bafd2", - "zh:d1562223347c49cbe3ff6e7295e25816a35dfef862d28cd8a7870e7be6ec8093", - "zh:e7a1d08bfe91d3789755ee587fc816907c3bea203342c717144c7459111ce20c", - "zh:e89d5a668c391669ed323d493c5ea131fe8833d562a6fe31f525bdcbe959056e", - "zh:f268ccd3e1a32ba7fd59bbf0c8d85611201c0c87462a2a5cddd02babde7b5fe8", - "zh:fe8c2eae8c367d2cb7cade250a8d5f6c411ac4a8214c46df0a1fd90d9eaf7152", - ] -} diff --git a/terraform/base/.terraform.lock.hcl b/terraform/base/.terraform.lock.hcl new file mode 100644 index 00000000..4b1b5102 --- /dev/null +++ b/terraform/base/.terraform.lock.hcl @@ -0,0 +1,24 @@ +# This file is maintained automatically by "terraform init". +# Manual edits may be lost in future updates. + +provider "registry.terraform.io/hashicorp/aws" { + version = "4.60.0" + hashes = [ + "h1:b2U4EncUaHCsQuiePo/yHZiH5ib0rx+P/qG4LC8pGlA=", + "zh:1853d6bc89e289ac36c13485e8ff877c1be8485e22f545bb32c7a30f1d1856e8", + "zh:4321d145969e3b7ede62fe51bee248a15fe398643f21df9541eef85526bf3641", + "zh:4c01189cc6963abfe724e6b289a7c06d2de9c395011d8d54efa8fe1aac444e2e", + "zh:5934db7baa2eec0f9acb9c7f1c3dd3b3fe1e67e23dd4a49e9fe327832967b32b", + "zh:5fbedf5d55c6e04e34c32b744151e514a80308e7dec633a56b852829b41e4b5a", + "zh:651558e1446cc05061b75e6f5cc6e2959feb17615cd0ace6ec7a2bcc846321c0", + "zh:76875eb697916475e554af080f9d4d3cd1f7d5d58ecdd3317a844a30980f4eec", + "zh:9b12af85486a96aedd8d7984b0ff811a4b42e3d88dad1a3fb4c0b580d04fa425", + "zh:a52528e6d6c945a6ac45b89e9a70a5435148e4c151241e04c231dd2acc4a8c80", + "zh:af5f94c69025f1c2466a3cf970d1e9bed72938ec33b976c8c067468b6707bb57", + "zh:b6692fad956c9d4ef4266519d9ac2ee9f699f8f2c21627625c9ed63814d41590", + "zh:b74311af5fa5ac6e4eb159c12cfb380dfe2f5cd8685da2eac8073475f398ae60", + "zh:cc5aa6f738baa42edacba5ef1ca0969e5a959422e4491607255f3f6142ba90ed", + "zh:dd1a7ff1b22f0036a76bc905a8229ce7ed0a7eb5a783d3a2586fb1bd920515c3", + "zh:e5ab40c4ad0f1c7bd4d5d834d1aa144e690d1a93329d73b3d37512715a638de9", + ] +} diff --git a/terraform/base/config-base.tf.json b/terraform/base/config-base.tf.json new file mode 100644 index 00000000..7c3dea4d --- /dev/null +++ b/terraform/base/config-base.tf.json @@ -0,0 +1,128 @@ +{ + "data": { + "aws_iam_policy_document": { + "machine": { + "statement": { + "actions": [ + "s3:ListAllMyBuckets", + "s3:GetBucketLocation", + "s3:ListBucket", + "s3:GetObject", + "s3:GetBucketLocation" + ], + "resources": [ + "arn:aws:s3:::*" + ], + "sid": "1" + } + } + } + }, + "output": { + "ami-a": { + "value": "${resource.aws_ami.node-image-base.id}" + } + }, + "provider": { + "aws": { + "region": "${var.AWS_REGION}" + } + }, + "resource": { + "aws_ami": { + "node-image-base": { + "architecture": "x86_64", + "ebs_block_device": { + "delete_on_termination": true, + "device_name": "/dev/xvda", + "snapshot_id": "${aws_ebs_snapshot_import.nixos-a.id}", + "volume_size": 82, + "volume_type": "gp3" + }, + "ena_support": true, + "name": "node-image-base-${var.VALIDATOR_NAME}", + "root_device_name": "/dev/xvda", + "sriov_net_support": "simple", + "virtualization_type": "hvm" + } + }, + "aws_ebs_snapshot_import": { + "nixos-a": { + "disk_container": { + "format": "VHD", + "user_bucket": { + "s3_bucket": "${aws_s3_bucket.deploy.bucket}", + "s3_key": "${aws_s3_object.nixos-a.key}" + } + }, + "role_name": "${aws_iam_role.vmimport.name}" + } + }, + "aws_iam_role": { + "machine": { + "assume_role_policy": "{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Action\": \"sts:AssumeRole\",\n \"Principal\": {\n \"Service\": \"ec2.amazonaws.com\"\n },\n \"Effect\": \"Allow\",\n \"Sid\": \"\"\n }\n ]\n}\n", + "name": "${var.VALIDATOR_NAME}" + }, + "vmimport": { + "assume_role_policy": " {\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Principal\": { \"Service\": \"vmie.amazonaws.com\" },\n \"Action\": \"sts:AssumeRole\",\n \"Condition\": {\n \"StringEquals\":{\n \"sts:Externalid\": \"vmimport\"\n }\n }\n }\n ]\n}\n", + "name": "vmimport${var.VALIDATOR_NAME}", + "tags": { + "tool": "terranix" + } + } + }, + "aws_iam_role_policy": { + "machine": { + "name": "${var.VALIDATOR_NAME}", + "policy": "${data.aws_iam_policy_document.machine.json}", + "role": "${aws_iam_role.machine.name}" + }, + "vmimport_policy": { + "name": "vmimport${var.VALIDATOR_NAME}", + "policy": "{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"s3:ListBucket\",\n \"s3:GetObject\",\n \"s3:GetBucketLocation\"\n ],\n \"Resource\": [\n \"${aws_s3_bucket.deploy.arn}\",\n \"${aws_s3_bucket.deploy.arn}/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"s3:GetBucketLocation\",\n \"s3:GetObject\",\n \"s3:ListBucket\",\n \"s3:PutObject\",\n \"s3:GetBucketAcl\"\n ],\n \"Resource\": [\n \"${aws_s3_bucket.deploy.arn}\",\n \"${aws_s3_bucket.deploy.arn}/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"ec2:ModifySnapshotAttribute\",\n \"ec2:CopySnapshot\",\n \"ec2:RegisterImage\",\n \"ec2:Describe*\"\n ],\n \"Resource\": \"*\"\n }\n ]\n }\n", + "role": "${aws_iam_role.vmimport.id}" + } + }, + "aws_s3_bucket": { + "deploy": { + "bucket": "deploy-instance-storage-${var.VALIDATOR_NAME}", + "tags": { + "tool": "terranix" + } + } + }, + "aws_s3_object": { + "nixos-a": { + "bucket": "${aws_s3_bucket.deploy.bucket}", + "key": "nixos-amazon-${var.VALIDATOR_NAME}.vhd", + "lifecycle": { + "ignore_changes": [ + "key", + "etag" + ] + }, + "source": "${var.NODE_IMAGE}", + "source_hash": "${filemd5(var.NODE_IMAGE)}" + } + } + }, + "terraform": { + "backend": { + "local": { + "path": "terraform-base.tfstate" + } + } + }, + "variable": { + "AWS_REGION": { + "type": "string" + }, + "NODE_IMAGE": { + "type": "string" + }, + "VALIDATOR_NAME": { + "description": "should be more than 3 but less then 12 symbols, only lower case letters", + "type": "string" + } + } +} diff --git a/terraform/base/terraform-base.tfstate.backup.sops b/terraform/base/terraform-base.tfstate.backup.sops new file mode 100644 index 00000000..cd1a18c1 --- /dev/null +++ b/terraform/base/terraform-base.tfstate.backup.sops @@ -0,0 +1,20 @@ +{ + "data": "ENC[AES256_GCM,data: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,iv:dPHk+9J+IZy9SWyWouKhYjuqtRdlJ4NqRpB0oHNyh1Y=,tag:97aayk2eiiJylTL9sCTuGQ==,type:str]", + "sops": { + "kms": null, + "gcp_kms": null, + "azure_kv": null, + "hc_vault": null, + "age": [ + { + "recipient": "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5", + "enc": "-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBQLzFqNFZhSWFVZVdyaFJw\nNkgvQkZxYjR6L3JzaEIyYVI0blNvVWdwR2c4ClFXL2M5cCtiWmpTdTEyeCs4TmVZ\nbFlSaEY3cnB0ZlFzZElxSlNFMjZhMWMKLS0tIGdNYU51MDZKODRjc3BNUmxSaU52\nNTJDSE1CNjFmTHdQU1RhbUNMclR4SkUK9Ir/NeSz9s4wOSgz1BWqS8dK4kwe0CMu\nz1SNmkfCHys3URFEZpLwWpLEib9cM031EqzF0biTGjsvvYf7wamtIw==\n-----END AGE ENCRYPTED FILE-----\n" + } + ], + "lastmodified": "2023-03-29T22:43:44Z", + "mac": "ENC[AES256_GCM,data:v82bo/c8cxZyRdL9lXw1CwhppJtpFV0OtXpJSPW0hVjEpm3zJd6OgvfVSMNf8SK9z+54Ufs+KI57fD1oxvZomyKjm2Qr1NreK/Qy9n6VntTMEmJC5UUNyl2ATFSLOeMYN2abHPYKUY/0k/IOePVQ1APdxFe6m3tECMKwUV8MnN4=,iv:nHESDJs1QXgmbWFnSG61Nf7RpIbVquJxCbVKIHd83Z0=,tag:bCwQzzIFaM8YX0gJOUarkw==,type:str]", + "pgp": null, + "unencrypted_suffix": "_unencrypted", + "version": "3.7.3" + } +} \ No newline at end of file diff --git a/terraform/base/terraform-base.tfstate.sops b/terraform/base/terraform-base.tfstate.sops new file mode 100644 index 00000000..98a39485 --- /dev/null +++ b/terraform/base/terraform-base.tfstate.sops @@ -0,0 +1,20 @@ +{ + "data": "ENC[AES256_GCM,data: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,iv:eGSehjxnUOv6uNEe2eOuJMH59ERnfJ1iYIqdYsy6+d8=,tag:wdRtxyjICdy8HptgObnC7w==,type:str]", + "sops": { + "kms": null, + "gcp_kms": null, + "azure_kv": null, + "hc_vault": null, + "age": [ + { + "recipient": "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5", + "enc": "-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSAvc3JuZzlJdE13U3lwMHh6\nYXZoREpqR2laRkJVRW9BWDRpK2Q3OVlLTlZ3ClIrMUZSZEpIYTVVMUdvMGJiSy9p\nTWJLVFphL1Jod3pnOGU4WURWYWh2NnMKLS0tIFkwOHhWUTZ4QWVFY2hpN0IwbnNP\nUlVrQVJyU0NwRGdPTTJ0Q1JxMDVjbHcKVgYzsJxU5ofXfDzjjwtwbGfoVqtElpud\nK8V/beJGbRNxRG18d8qUplR+WRvcQTUwi8tP8KxUvYKujIAbYKVqrw==\n-----END AGE ENCRYPTED FILE-----\n" + } + ], + "lastmodified": "2023-03-29T22:43:44Z", + "mac": "ENC[AES256_GCM,data:OwcRtroYg6H0BKXiAD9odsNTtULiRpuF2onNc2yqBOJPZHpfsOkdZDENphoNx6krf4juXwYuJAUsI8EdBasKkT23x5LGOCp1BGc9Y3nHZggV1oUCfOcgPOT03XTr+Nf2aVdNudxQdVdBrTqIs/CAru/ARp999HPfEWwnCmRffss=,iv:ZKs+n0RtjHX+zeE0gN/IAXoFfLGdaysj4h5l4DvQgrQ=,tag:5xkGAi1igAyEWH1kbJM8rA==,type:str]", + "pgp": null, + "unencrypted_suffix": "_unencrypted", + "version": "3.7.3" + } +} \ No newline at end of file diff --git a/terraform/config.tf.json b/terraform/config.tf.json deleted file mode 100644 index 5c1e01ca..00000000 --- a/terraform/config.tf.json +++ /dev/null @@ -1,24 +0,0 @@ -{ - "provider": { - "aws": { - "region": "eu-west-1" - } - }, - "resource": { - "aws_s3_bucket": { - "terraform-backend": { - "bucket": "new-just-some-storage-ggchain", - "tags": { - "tool": "terranix" - } - } - } - }, - "terraform": { - "backend": { - "local": { - "path": "terraform.tfstate" - } - } - } -} diff --git a/terraform/terraform.tfstate.sops b/terraform/terraform.tfstate.sops deleted file mode 100644 index 0be686cd..00000000 --- a/terraform/terraform.tfstate.sops +++ /dev/null @@ -1,20 +0,0 @@ -{ - "data": "ENC[AES256_GCM,data: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,iv:8hX5/MIb6RP9RWI6kCydyrdbbt1/iCEKPFp2K8+hDUM=,tag:6y8uOJpP+gmPm5DVU834xQ==,type:str]", - "sops": { - "kms": null, - "gcp_kms": null, - "azure_kv": null, - "hc_vault": null, - "age": [ - { - "recipient": "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5", - "enc": "-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBpaklQUzFUclRpNDJJRWo0\nYlVuSlpITW1TTGpUenp6b0IwakNmMjRjVENnCmdaaWhHQnJLVk96STRlbjN5cTFP\nZit0NWY5YysrRjNrdG5US2FvT1FGbFUKLS0tIEp3UDJKem9jNDB4SDA3Y3Z2V2xN\nZDdWcysvVDhxaWtjdnBoVzhXakdja28KZTozHL0pnMVg1XwIbWcMetW6CO+GKxvx\nkfRrOBl27a8YJ4VAPzMlCwKKNzPZrsaw474nGfkXvDh5pzpHJ7xkNQ==\n-----END AGE ENCRYPTED FILE-----\n" - } - ], - "lastmodified": "2023-03-21T12:15:00Z", - "mac": "ENC[AES256_GCM,data:glXcxj8sDdHSnIsxywppszGWFeOknu/v8AsY2Zj4TafwSYhITqQSzE8Kc6qCS7/xmh5K+DszhzRkP9/X033OS1iWFK3mK5/1dWwm95vIIVDemNfzq9k646f5x19OqYIyP9uLt6rIQawJLKgiTOcoKVD+tJaQz8Pkjv3ioV5LYo4=,iv:hZeNlUE77A/WJy9ijbTMAQa+6nc0blrcTZN4MXInE6k=,tag:2TrgoP49iNDIci9rnubFbg==,type:str]", - "pgp": null, - "unencrypted_suffix": "_unencrypted", - "version": "3.7.3" - } -} \ No newline at end of file diff --git a/terraform/testnet/.terraform.lock.hcl b/terraform/testnet/.terraform.lock.hcl new file mode 100644 index 00000000..6cae7e74 --- /dev/null +++ b/terraform/testnet/.terraform.lock.hcl @@ -0,0 +1,103 @@ +# This file is maintained automatically by "terraform init". +# Manual edits may be lost in future updates. + +provider "registry.terraform.io/hashicorp/aws" { + version = "4.61.0" + hashes = [ + "h1:mJSchOA6VkYwEsi+tuspadRmyyE+FGZGYJFUt5kHV+M=", + "zh:051e2588410b7448a5c4c30d668948dd6fdfa8037700bfc00fb228986ccbf3a5", + "zh:082fbcf9706b48d0880ba552a11c29527e228dadd6d83668d0789abda24e5922", + "zh:0e0e72f214fb24f4f9c601cab088a2d8e00ec3327c451bc753911951d773214a", + "zh:3af6d38ca733ca66cce15c6a5735ded7c18348ad26040ebd9a59778b2cd9cf6c", + "zh:404898bc2258bbb9527fa06c72cb927ca011fd9bc3f4b90931c0912652c3f9e9", + "zh:4f617653b0f17a7708bc896f029c4ab0b677a1a1c987bd77166acad1d82db469", + "zh:5dbe393355ac137aa3fd329e3d24871f27012d3ba93d714485b55820df240349", + "zh:6067c2127eb5c879227aca671f101de6dcba909d0d8d15d5711480351962a248", + "zh:9b12af85486a96aedd8d7984b0ff811a4b42e3d88dad1a3fb4c0b580d04fa425", + "zh:a939f94461f91aa3b7ec7096271e2714309bd917fe9a03e02f68afb556d65e0f", + "zh:b21227b9082e5fafe8b7c415dc6a99c0d82da05492457377a5fe7d4acaed80e2", + "zh:b8d9f09ed5fc8c654b768b7bee1237eaf1e2287c898249e740695055fb0fe072", + "zh:d360e1e185b148ff6b1d0ed4f7d574e08f2391697ab43df62085b04a1a5b1284", + "zh:da962da17ddda744911cb1e92b983fa3874d73a28f3ee72faa9ddb6680a63774", + "zh:e2f1c4f5ebeb4fd7ef690178168a4c529025b54a91bb7a087dcea48e0b82737a", + ] +} + +provider "registry.terraform.io/hashicorp/local" { + version = "2.4.0" + hashes = [ + "h1:R97FTYETo88sT2VHfMgkPU3lzCsZLunPftjSI5vfKe8=", + "zh:53604cd29cb92538668fe09565c739358dc53ca56f9f11312b9d7de81e48fab9", + "zh:66a46e9c508716a1c98efbf793092f03d50049fa4a83cd6b2251e9a06aca2acf", + "zh:70a6f6a852dd83768d0778ce9817d81d4b3f073fab8fa570bff92dcb0824f732", + "zh:78d5eefdd9e494defcb3c68d282b8f96630502cac21d1ea161f53cfe9bb483b3", + "zh:82a803f2f484c8b766e2e9c32343e9c89b91997b9f8d2697f9f3837f62926b35", + "zh:9708a4e40d6cc4b8afd1352e5186e6e1502f6ae599867c120967aebe9d90ed04", + "zh:973f65ce0d67c585f4ec250c1e634c9b22d9c4288b484ee2a871d7fa1e317406", + "zh:c8fa0f98f9316e4cfef082aa9b785ba16e36ff754d6aba8b456dab9500e671c6", + "zh:cfa5342a5f5188b20db246c73ac823918c189468e1382cb3c48a9c0c08fc5bf7", + "zh:e0e2b477c7e899c63b06b38cd8684a893d834d6d0b5e9b033cedc06dd7ffe9e2", + "zh:f62d7d05ea1ee566f732505200ab38d94315a4add27947a60afa29860822d3fc", + "zh:fa7ce69dde358e172bd719014ad637634bbdabc49363104f4fca759b4b73f2ce", + ] +} + +provider "registry.terraform.io/hashicorp/tls" { + version = "4.0.4" + hashes = [ + "h1:pe9vq86dZZKCm+8k1RhzARwENslF3SXb9ErHbQfgjXU=", + "zh:23671ed83e1fcf79745534841e10291bbf34046b27d6e68a5d0aab77206f4a55", + "zh:45292421211ffd9e8e3eb3655677700e3c5047f71d8f7650d2ce30242335f848", + "zh:59fedb519f4433c0fdb1d58b27c210b27415fddd0cd73c5312530b4309c088be", + "zh:5a8eec2409a9ff7cd0758a9d818c74bcba92a240e6c5e54b99df68fff312bbd5", + "zh:5e6a4b39f3171f53292ab88058a59e64825f2b842760a4869e64dc1dc093d1fe", + "zh:810547d0bf9311d21c81cc306126d3547e7bd3f194fc295836acf164b9f8424e", + "zh:824a5f3617624243bed0259d7dd37d76017097dc3193dac669be342b90b2ab48", + "zh:9361ccc7048be5dcbc2fafe2d8216939765b3160bd52734f7a9fd917a39ecbd8", + "zh:aa02ea625aaf672e649296bce7580f62d724268189fe9ad7c1b36bb0fa12fa60", + "zh:c71b4cd40d6ec7815dfeefd57d88bc592c0c42f5e5858dcc88245d371b4b8b1e", + "zh:dabcd52f36b43d250a3d71ad7abfa07b5622c69068d989e60b79b2bb4f220316", + "zh:f569b65999264a9416862bca5cd2a6177d94ccb0424f3a4ef424428912b9cb3c", + ] +} + +provider "registry.terraform.io/onesdata/uptime" { + version = "1.0.1" + constraints = "1.0.1" + hashes = [ + "h1:4n1z4VCfxS+KSnT6vX4GR7r82AKi/zEngD93vXs4XZI=", + "zh:01f7b25227e1dcad60a509ed9e6ecf75def996aa5b0ed45900ee87e7b1f72e7f", + "zh:16c0ba1be5b781038a1aaef7be9cf36cad72b4b3e30bce5cd566a822b01119b6", + "zh:4053a66af114d440a70db426e317a6e700b786ccbfeeaf9ba8e18455b81d7953", + "zh:4a8986b04a037421096e9c97089a398e0415470141afc6e143d12c2b5b48783c", + "zh:57e3f5af4a91d3126cb0fd46279faf36543ace4068ff760b0e00dad6cb69e615", + "zh:6d557e70b3c45f014afb546b709f8151fa0038efd35e2e41d24f66c2c3a32060", + "zh:787b28d1f39b9f162c47fcbfa998841c94441d65a20541eb14ada7d600af0339", + "zh:973b6fd7fd682c44348ace0f2bab3a342b27d3ae80fd3439f6e8e880ace2a2db", + "zh:9c09e42a66b2b48acdbbe22bee1912d4ae7d6a3d3c4f8d66e1caaa3437c171e1", + "zh:c68c4c32fb15de9119d6ddc5a0bd6ea498e1e963f3187df83835e4ebd4587131", + "zh:da1849cd0b37cb0603cf0480e6c9ac9afcb5097e51f0357dfbccf33942038d82", + "zh:fd7a4f87f1863bf054fa068a62956e4117b7b78ce44506d8b0d9ed3a7a9a4ad3", + ] +} + +provider "registry.terraform.io/vancluever/acme" { + version = "2.13.1" + constraints = "2.13.1" + hashes = [ + "h1:pRHsmoJLPSu7KHPORKuqydH4H6oCTyRA86AvZ4QBWOA=", + "zh:0dad25b9f6f2afd20b5e32d1bca25b98dece832ba2de9991e3224649d4e83c75", + "zh:131c4c26fde40c793637612dab9c067ba3d6475211cfb3d02a6047f694d9ac75", + "zh:1330e825324ede347f7f67c6c0da0501f6dda57694c237169b0254535cac66bf", + "zh:20532f8f12f1f06c84e11d37912f4f96c9bd0a7873bfb2c527bbe0574f35468c", + "zh:344e91c424f90ea5d168bdfae3417b17041a9f3a8df322bc2dd3785fe5d4fe22", + "zh:55a709291b839f483afcfdbc196f2594f2f30716d64a81f9bef4bc0adf65c104", + "zh:5d78a5a72a1f60890ad3fda2f78549f5180b21ba768a8a4fea32259621f498cb", + "zh:7696e0f129872e1f18045cd737eb83d25bb8d41cac4d1ed9908d7b7f941dd743", + "zh:973bd32311f884f7f8c85459de9524bc6d5a8285cd13e62232ac5be399a8ae19", + "zh:9e667c5724292d3d1870c6f72e83ea418666ef294526b4a6f222c2dea16e4bb5", + "zh:e970ad73cd48abe459e9434bf10a7c1e7596b71f44dacffab6a548861acb0b0d", + "zh:f0b9106c52ebc39631aa6c467c807171e95c50c3475e85125850f83fccb96776", + "zh:f7024f2cba0816dbe3147ecf97763811a501bca41c5792328a5545b1a0742183", + ] +} diff --git a/terraform/testnet/config-testnet.tf.json b/terraform/testnet/config-testnet.tf.json new file mode 100644 index 00000000..541f3ca3 --- /dev/null +++ b/terraform/testnet/config-testnet.tf.json @@ -0,0 +1,536 @@ +{ + "data": { + "aws_iam_policy_document": { + "machine": { + "statement": { + "actions": [ + "s3:ListAllMyBuckets", + "s3:GetBucketLocation", + "s3:ListBucket", + "s3:GetObject", + "s3:GetBucketLocation" + ], + "resources": [ + "arn:aws:s3:::*" + ], + "sid": "1" + } + } + }, + "local_sensitive_file": { + "node-a-key-ed": { + "filename": "${path.module}/../../.secret/node-a.ed25519.json" + }, + "node-a-key-sr": { + "filename": "${path.module}/../../.secret/node-a.sr25519.json" + }, + "node-b-key-ed": { + "filename": "${path.module}/../../.secret/node-b.ed25519.json" + }, + "node-b-key-sr": { + "filename": "${path.module}/../../.secret/node-b.sr25519.json" + }, + "node-c-key-ed": { + "filename": "${path.module}/../../.secret/node-c.ed25519.json" + }, + "node-c-key-sr": { + "filename": "${path.module}/../../.secret/node-c.sr25519.json" + }, + "node-d-key-ed": { + "filename": "${path.module}/../../.secret/node-d.ed25519.json" + }, + "node-d-key-sr": { + "filename": "${path.module}/../../.secret/node-d.sr25519.json" + } + } + }, + "output": { + "node_public_dns_a": { + "value": "${resource.aws_instance.node-a.public_dns}" + }, + "node_public_dns_b": { + "value": "${resource.aws_instance.node-b.public_dns}" + }, + "node_public_dns_c": { + "value": "${resource.aws_instance.node-c.public_dns}" + }, + "node_public_dns_d": { + "value": "${resource.aws_instance.node-d.public_dns}" + }, + "node_public_ip_a": { + "value": "${resource.aws_instance.node-a.public_ip}" + }, + "node_public_ip_b": { + "value": "${resource.aws_instance.node-b.public_ip}" + }, + "node_public_ip_c": { + "value": "${resource.aws_instance.node-c.public_ip}" + }, + "node_public_ip_d": { + "value": "${resource.aws_instance.node-d.public_ip}" + }, + "ssh_a": { + "value": "ssh -i ./terraform/testnet/id_rsa.pem root@${resource.aws_instance.node-a.public_dns}" + }, + "ssh_b": { + "value": "ssh -i ./terraform/testnet/id_rsa.pem root@${resource.aws_instance.node-b.public_dns}" + }, + "ssh_c": { + "value": "ssh -i ./terraform/testnet/id_rsa.pem root@${resource.aws_instance.node-c.public_dns}" + }, + "ssh_d": { + "value": "ssh -i ./terraform/testnet/id_rsa.pem root@${resource.aws_instance.node-d.public_dns}" + } + }, + "provider": { + "acme": { + "server_url": "https://acme-staging-v02.api.letsencrypt.org/directory" + }, + "aws": { + "region": "${var.AWS_REGION}" + }, + "uptime": {} + }, + "resource": { + "acme_certificate": { + "certificate": { + "account_key_pem": "${acme_registration.reg.account_key_pem}", + "common_name": "${aws_route53_zone.primary.name}", + "dns_challenge": { + "config": { + "AWS_DEFAULT_REGION": "${var.AWS_REGION}", + "AWS_HOSTED_ZONE_ID": "${aws_route53_zone.primary.zone_id}", + "AWS_MAX_RETRIES": 100, + "AWS_POLLING_INTERVAL": 60, + "AWS_PROPAGATION_TIMEOUT": 900 + }, + "provider": "route53" + }, + "subject_alternative_names": [ + "*.${aws_route53_zone.primary.name}" + ] + } + }, + "acme_registration": { + "reg": { + "account_key_pem": "${tls_private_key.machine.private_key_pem}", + "email_address": "${aws_route53domains_registered_domain.nodes.admin_contact[0].email}" + } + }, + "aws_iam_role": { + "machine": { + "assume_role_policy": "{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Action\": \"sts:AssumeRole\",\n \"Principal\": {\n \"Service\": \"ec2.amazonaws.com\"\n },\n \"Effect\": \"Allow\",\n \"Sid\": \"\"\n }\n ]\n}\n", + "name": "machine-${var.VALIDATOR_NAME}" + }, + "vmimport": { + "assume_role_policy": " {\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Principal\": { \"Service\": \"vmie.amazonaws.com\" },\n \"Action\": \"sts:AssumeRole\",\n \"Condition\": {\n \"StringEquals\":{\n \"sts:Externalid\": \"vmimport\"\n }\n }\n }\n ]\n}\n", + "name": "vmimport-${var.VALIDATOR_NAME}" + } + }, + "aws_iam_role_policy": { + "machine": { + "name": "${var.VALIDATOR_NAME}", + "policy": "${data.aws_iam_policy_document.machine.json}", + "role": "${aws_iam_role.machine.name}" + } + }, + "aws_instance": { + "node-a": { + "ami": "ami-05173ee0952a97126", + "associate_public_ip_address": true, + "instance_type": "t2.medium", + "key_name": "${aws_key_pair.machine.key_name}", + "provisioner": { + "file": [ + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "ed25519.json", + "source": "${path.module}/../../.secret/node-a.ed25519.json" + }, + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "sr25519.json", + "source": "${path.module}/../../.secret/node-a.sr25519.json" + } + ] + }, + "root_block_device": { + "volume_size": 84 + }, + "security_groups": [ + "${aws_security_group.machine.name}" + ], + "tags": { + "tool": "terranix" + } + }, + "node-b": { + "ami": "ami-05173ee0952a97126", + "associate_public_ip_address": true, + "instance_type": "t2.medium", + "key_name": "${aws_key_pair.machine.key_name}", + "provisioner": { + "file": [ + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "ed25519.json", + "source": "${path.module}/../../.secret/node-b.ed25519.json" + }, + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "sr25519.json", + "source": "${path.module}/../../.secret/node-b.sr25519.json" + } + ] + }, + "root_block_device": { + "volume_size": 84 + }, + "security_groups": [ + "${aws_security_group.machine.name}" + ], + "tags": { + "tool": "terranix" + } + }, + "node-c": { + "ami": "ami-05173ee0952a97126", + "associate_public_ip_address": true, + "instance_type": "t2.medium", + "key_name": "${aws_key_pair.machine.key_name}", + "provisioner": { + "file": [ + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "ed25519.json", + "source": "${path.module}/../../.secret/node-c.ed25519.json" + }, + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "sr25519.json", + "source": "${path.module}/../../.secret/node-c.sr25519.json" + } + ] + }, + "root_block_device": { + "volume_size": 84 + }, + "security_groups": [ + "${aws_security_group.machine.name}" + ], + "tags": { + "tool": "terranix" + } + }, + "node-d": { + "ami": "ami-05173ee0952a97126", + "associate_public_ip_address": true, + "instance_type": "t2.medium", + "key_name": "${aws_key_pair.machine.key_name}", + "provisioner": { + "file": [ + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "ed25519.json", + "source": "${path.module}/../../.secret/node-d.ed25519.json" + }, + { + "connection": { + "host": "${self.public_ip}", + "private_key": "${local_sensitive_file.machine_ssh_key.content}", + "type": "ssh", + "user": "root" + }, + "destination": "sr25519.json", + "source": "${path.module}/../../.secret/node-d.sr25519.json" + } + ] + }, + "root_block_device": { + "volume_size": 84 + }, + "security_groups": [ + "${aws_security_group.machine.name}" + ], + "tags": { + "tool": "terranix" + } + } + }, + "aws_key_pair": { + "machine": { + "key_name": "centralization-risk-${var.VALIDATOR_NAME}", + "public_key": "${tls_private_key.machine.public_key_openssh}" + } + }, + "aws_route53_health_check": { + "node-a": { + "failure_threshold": "5", + "fqdn": "${aws_route53_record.node-a.name}", + "port": 443, + "request_interval": "30", + "resource_path": "/", + "tags": { + "tool": "terranix" + }, + "type": "HTTPS" + }, + "node-b": { + "failure_threshold": "5", + "fqdn": "${aws_route53_record.node-b.name}", + "port": 443, + "request_interval": "30", + "resource_path": "/", + "tags": { + "tool": "terranix" + }, + "type": "HTTPS" + }, + "node-c": { + "failure_threshold": "5", + "fqdn": "${aws_route53_record.node-c.name}", + "port": 443, + "request_interval": "30", + "resource_path": "/", + "tags": { + "tool": "terranix" + }, + "type": "HTTPS" + }, + "node-d": { + "failure_threshold": "5", + "fqdn": "${aws_route53_record.node-d.name}", + "port": 443, + "request_interval": "30", + "resource_path": "/", + "tags": { + "tool": "terranix" + }, + "type": "HTTPS" + } + }, + "aws_route53_record": { + "node-a": { + "name": "node-a.${var.DOMAIN_NAME}", + "records": [ + "${aws_instance.node-a.public_ip}" + ], + "ttl": 300, + "type": "A", + "zone_id": "${aws_route53_zone.primary.zone_id}" + }, + "node-b": { + "name": "node-b.${var.DOMAIN_NAME}", + "records": [ + "${aws_instance.node-b.public_ip}" + ], + "ttl": 300, + "type": "A", + "zone_id": "${aws_route53_zone.primary.zone_id}" + }, + "node-c": { + "name": "node-c.${var.DOMAIN_NAME}", + "records": [ + "${aws_instance.node-c.public_ip}" + ], + "ttl": 300, + "type": "A", + "zone_id": "${aws_route53_zone.primary.zone_id}" + }, + "node-d": { + "name": "node-d.${var.DOMAIN_NAME}", + "records": [ + "${aws_instance.node-d.public_ip}" + ], + "ttl": 300, + "type": "A", + "zone_id": "${aws_route53_zone.primary.zone_id}" + } + }, + "aws_route53_zone": { + "primary": { + "name": "${var.DOMAIN_NAME}" + } + }, + "aws_route53domains_registered_domain": { + "nodes": { + "admin_privacy": false, + "domain_name": "${var.DOMAIN_NAME}", + "name_server": [ + { + "name": "${aws_route53_zone.primary.name_servers[0]}" + }, + { + "name": "${aws_route53_zone.primary.name_servers[1]}" + }, + { + "name": "${aws_route53_zone.primary.name_servers[2]}" + }, + { + "name": "${aws_route53_zone.primary.name_servers[3]}" + } + ], + "registrant_privacy": false, + "tags": { + "tool": "terranix" + }, + "tech_privacy": false + } + }, + "aws_security_group": { + "machine": { + "name": "${var.VALIDATOR_NAME}" + } + }, + "aws_security_group_rule": { + "machine_egress_all": { + "cidr_blocks": [ + "0.0.0.0/0" + ], + "description": "Allow to connect to the whole Internet", + "from_port": 0, + "protocol": "-1", + "security_group_id": "${aws_security_group.machine.id}", + "to_port": 0, + "type": "egress" + }, + "machine_ingress_ssh": { + "cidr_blocks": [ + "0.0.0.0/0" + ], + "description": "non secure access via all ports", + "from_port": 0, + "protocol": "all", + "security_group_id": "${aws_security_group.machine.id}", + "to_port": 65535, + "type": "ingress" + } + }, + "local_sensitive_file": { + "machine_ssh_key": { + "content": "${tls_private_key.machine.private_key_pem}", + "file_permission": "0600", + "filename": "id_rsa.pem" + } + }, + "tls_private_key": { + "machine": { + "algorithm": "RSA" + } + }, + "uptime_check_http": { + "node-a": { + "address": "node-a.${var.DOMAIN_NAME}", + "contact_groups": [ + "Default" + ], + "interval": 1, + "locations": [ + "US East", + "United Kingdom" + ], + "name": "Node" + }, + "node-b": { + "address": "node-b.${var.DOMAIN_NAME}", + "contact_groups": [ + "Default" + ], + "interval": 1, + "locations": [ + "US East", + "United Kingdom" + ], + "name": "Node" + }, + "node-c": { + "address": "node-c.${var.DOMAIN_NAME}", + "contact_groups": [ + "Default" + ], + "interval": 1, + "locations": [ + "US East", + "United Kingdom" + ], + "name": "Node" + }, + "node-d": { + "address": "node-d.${var.DOMAIN_NAME}", + "contact_groups": [ + "Default" + ], + "interval": 1, + "locations": [ + "US East", + "United Kingdom" + ], + "name": "Node" + } + } + }, + "terraform": { + "backend": { + "local": { + "path": "terraform-testnet.tfstate" + } + }, + "required_providers": { + "acme": { + "source": "vancluever/acme", + "version": "2.13.1" + }, + "uptime": { + "source": "onesdata/uptime", + "version": "1.0.1" + } + } + }, + "variable": { + "AWS_REGION": { + "type": "string" + }, + "DOMAIN_NAME": { + "type": "string" + }, + "VALIDATOR_NAME": { + "description": "should be more than 3 but less then 12 symbols, only lower case letters", + "type": "string" + } + } +} diff --git a/terraform/testnet/terraform-testnet.tfstate.backup.sops b/terraform/testnet/terraform-testnet.tfstate.backup.sops new file mode 100644 index 00000000..7c5a3f2d --- /dev/null +++ b/terraform/testnet/terraform-testnet.tfstate.backup.sops @@ -0,0 +1,20 @@ +{ + "data": "ENC[AES256_GCM,data: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,iv:+J383ctX/GZHWoe0R/N3KYEohqjNOpYZmXyHUJUc39A=,tag:EfPrNOAe29JUFalPG2dLBQ==,type:str]", + "sops": { + "kms": null, + "gcp_kms": null, + "azure_kv": null, + "hc_vault": null, + "age": [ + { + "recipient": "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5", + "enc": "-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSArcHdBQy84aStDdzhPSUpw\nSTc0K3hsdEoxZGl1TCt3SVpSZUd0Uzl0WmlFCmhncUpZY2F1OUxWMTFmb08zajcr\nNzdUbm8vTzgzZVdFbHZHYVNxZ0RlUDQKLS0tIFdGbytJSmJOcG1jbEk0NzR4QTNp\nR2RST2pORzRJMGtGTm0yREFWaGVMMzAKlFuoovx34md9GTuXtKJeSpBQhBQD08mV\negdDSUpCNV8w+wdIxqpMEuavjEzLgAmqw868G6esgiqqhug7xQEgGw==\n-----END AGE ENCRYPTED FILE-----\n" + } + ], + "lastmodified": "2023-04-03T13:39:03Z", + "mac": "ENC[AES256_GCM,data:KfEcybY9uFALu9HLqSd+Had4vM2CoOsUhtLhC95TBs0ynb57S9tViu8DUHU8EHujJVwluMMRMO3TGNns5mVIDx4UMZ8IHM7ckCkbhl7ZXEtAzGF1WRHE0dqHjO8WKfPcjdK8fARDOGy09R259LpD6zS2Ysbiv+0bp7PbUmN44eM=,iv:hw13n+Wot/JmtD0HqBeaBvulXvFQAKZJ2NneczIm5hE=,tag:zrHsIjju7KKC3NPSmKbQkA==,type:str]", + "pgp": null, + "unencrypted_suffix": "_unencrypted", + "version": "3.7.3" + } +} \ No newline at end of file diff --git a/terraform/testnet/terraform-testnet.tfstate.sops b/terraform/testnet/terraform-testnet.tfstate.sops new file mode 100644 index 00000000..223e0abf --- /dev/null +++ b/terraform/testnet/terraform-testnet.tfstate.sops @@ -0,0 +1,20 @@ +{ + "data": "ENC[AES256_GCM,data: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,iv:WJkYvkDhF/52YYCqw40uv8MIOj4Kermrj+b+FpF/0OQ=,tag:vQPggFk2bA7pGyt9QrxETA==,type:str]", + "sops": { + "kms": null, + "gcp_kms": null, + "azure_kv": null, + "hc_vault": null, + "age": [ + { + "recipient": "age1a8k02z579lr0qr79pjhlneffjw3dvy3a8j5r4fw3zlphd6cyaf5qukkat5", + "enc": "-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBCNXMxL0hlWWdWYm9qU2FD\nZmRoeldqY01xazRXckJQMk4rTUJ1WkJxOW5rCjAwTzB5N0JHQjhNanJTQWVzbWlj\nT0pjS0NBUUpKMktPVDhCU0E5dmRSZDQKLS0tIHU2cERzRjhGZEUxRVBTYjBJcjFl\nSHZFMTR5UDRjeHZjYldEaWFvNW0xLzgK8JEh7AmjH42S/bJdBStpr7bGVIvDqfKz\nb8Ahp6qXBGg4ewcBcmzp4OjX9U9OoSbh3maroMgiXDqbWp78oxaACQ==\n-----END AGE ENCRYPTED FILE-----\n" + } + ], + "lastmodified": "2023-04-03T13:39:03Z", + "mac": "ENC[AES256_GCM,data:ztK3mnRvdFOB6UMVZAkrqIHfeSD5D4H1SQMt9yQg4RBSG79b038yDM/VtrOhwFSIdSnNDoqTRcnnRp6pnmn8VQCpEc/fFtQLAxTNCmqivbwkpO3YBKVjTLvt+xAob7Q7jkem/O8+xES4/vkuhaa796n+Nh7ksAgHuvciRGymNIM=,iv:xML2R2LqzeG0QtI+hAB8Ih0BkvQ7RiWmGlqSYw+LUrM=,tag:y9LtSUIEuiYhXXy/ldgi7A==,type:str]", + "pgp": null, + "unencrypted_suffix": "_unencrypted", + "version": "3.7.3" + } +} \ No newline at end of file