Jędrzej Stuczyński
151 lines
6.4 KiB
Markdown
151 lines
6.4 KiB
Markdown
# Testnet manager
|
|
|
|
This is extremely experimental tool. Only to be used internally. Expect a lot of breaking changes.
|
|
|
|
Currently (as of 11.07.24), it exposes the following commands:
|
|
|
|
## `build-info`
|
|
|
|
Show build information of this binary. Does it need any more than that?
|
|
|
|
## `initialise-new-network`
|
|
|
|
pre-requisites:
|
|
|
|
1. you must have built all nym-contracts and put them in the same directory (just run `make contracts` from the root
|
|
directory)
|
|
|
|
Initialises new testnet network:
|
|
|
|
1. attempts to retrieve paths to all .wasm files of the nym-contracts based on provided arguments
|
|
2. uploads all the contracts to the specified nyxd
|
|
3. creates mnemonics for all contract admins
|
|
4. transfers some tokens to each created account
|
|
5. instantiates all the contracts
|
|
6. performs post-instantiation migration (like sets vesting contract address inside the mixnet contract)
|
|
7. queries each contract and retrieves its build information to display any warnings if they were built using some
|
|
ancient commits
|
|
8. persists all the network info (addresses, mnemonics, etc.) in the database for future use
|
|
|
|
**note: if you intend to `bond-local-mixnet` afterward, you want to set `--custom-epoch-duration-secs` to a rather low
|
|
value (like 60s)**
|
|
|
|
## `load-network-details`
|
|
|
|
Attempt to load testnet network details using either the provided name, or if nothing was specified, the latest one
|
|
created.
|
|
|
|
It outputs contents of an `.env` file you'd use with that network.
|
|
|
|
## `bypass-dkg`
|
|
|
|
pre-requisites:
|
|
|
|
1. you must have built the `dkg-bypass contract` (just run `make build-bypass-contract` from **this** directory)
|
|
|
|
Attempts to bypass the DKG by overwriting the contract state with pre-generated keys:
|
|
|
|
1. generates data for each specified ecash signer:
|
|
- ecash keys via a ttp
|
|
- ed25519 identity keys
|
|
- cosmos mnemonic
|
|
2. validates the existing DKG contract to make sure the DKG hasn't actually already been run and checks the group
|
|
contract to make sure its empty
|
|
3. persists the signer data generated at the beginning
|
|
4. uploads the bypass contract
|
|
5. overwrites the contract state (endpoints, keys, etc.) using the uploaded contract
|
|
6. restores the original DKG contract code
|
|
7. adds the ecash signers to the CW4 group
|
|
8. transfers some tokens to each ecash signer so they could actually execute txs
|
|
|
|
## `initialise-post-dkg-network`
|
|
|
|
pre-requisites:
|
|
|
|
1. you must have built all nym-contracts and put them in the same directory (just run `make contracts` from the root
|
|
directory)
|
|
2. you must have built the `dkg-bypass contract` (just run `make build-bypass-contract` from **this** directory)
|
|
|
|
Initialises new network and bypasses the DKG. It's just the equivalent of running `initialise-new-network`
|
|
and `bypass-dkg` separately:
|
|
|
|
1. runs equivalent of `initialise-new-network`
|
|
2. runs equivalent of `bypass-dkg`
|
|
|
|
## `create-local-ecash-apis`
|
|
|
|
pre-requisites:
|
|
|
|
1. you must have built all nym-contracts and put them in the same directory (just run `make contracts` from the root
|
|
directory)
|
|
2. you must have built the `dkg-bypass contract` (just run `make build-bypass-contract` from **this** directory)
|
|
3. you must have built `nym-api` binary
|
|
|
|
Attempt to create brand new network, in post DKG-state, using locally running nym-apis.
|
|
|
|
1. runs equivalent of `initialise-post-dkg-network`, with one difference: rather than requiring you to provide api
|
|
endpoints to all signers, it defaults to `http:://127.0.0.1:X`, where `X = 10000 + i`, based on the number of apis
|
|
specified in the args
|
|
2. runs `nym-api init` for all required api
|
|
3. copies over keys generated during `bypass-dkg` into the correct path for each API,
|
|
4. generates an `.env` file to use in all subsequent `run` commands
|
|
5. generates and outputs (either as raw string or `json` if used with `--output=json`) run commands for each nym-api
|
|
using full canonical and absolute paths (so you could paste them regardless of local directory)
|
|
|
|
## `bond-local-mixnet`
|
|
|
|
pre-requisites:
|
|
|
|
1. you must have a running network **including nym-api** (just run `create-local-ecash-apis` and start the binaries)
|
|
2. the mixnet epoch must be waiting for transition (thus `--custom-epoch-duration-secs` recommendation)
|
|
3. you must have built `nym-node` binary
|
|
|
|
Attempt to bond minimal local mixnet (3 mixnodes + 1 gateways) and output the run commands.
|
|
|
|
1. runs `nym-node init` 4 times, including once in `mode==entry` (with credentials)
|
|
2. generates mnemonics for each node
|
|
3. generates bonding signatures for each node
|
|
4. transfers some tokens to each bond owner
|
|
5. performs bonding of mixnode/gateway
|
|
6. assigns all nodes to the active set by:
|
|
- starting epoch transition
|
|
- reconciling epoch events
|
|
- advancing current epoch and assigning the nodes to the set
|
|
7. generates and outputs (either as raw string or `json` if used with `--output=json`) run commands for each nym-node
|
|
using full canonical and absolute paths (so you could paste them regardless of local directory)
|
|
|
|
## `create-local-client`
|
|
|
|
pre-requisites:
|
|
|
|
1. you must have a running MIXNET **including nym-api AND nym-nodes** (just run `create-local-ecash-apis` followed
|
|
by `bond-local-mixnet` and start the binaries)
|
|
2. you must have built `nym-client` binary
|
|
|
|
Initialise a locally run nym-client, adjust its config and output the run command:
|
|
|
|
1. runs `nym-client init` in credentials mode
|
|
2. updates its config to add `minimum_mixnode_performance = 0` and `minimum_gateway_performance = 0` thus ignoring the
|
|
lack of a network monitor
|
|
3. generates and outputs run command for the client using full canonical and absolute paths (so you could paste it
|
|
regardless of local directory)
|
|
|
|
### Extra
|
|
|
|
For reference, my workflow was as follows:
|
|
|
|
note: for the very first run you'll have to explicitly provide mnemonics and nyxd
|
|
|
|
1. rebuild whichever binary/contract was needed
|
|
2. `cargo run -- create-local-ecash-apis --bypass-dkg-contract ../../../target/wasm32-unknown-unknown/release/dkg_bypass_contract.wasm --number-of-apis=2 --nym-api-bin ../../../target/release/nym-api --built-contracts ../../../contracts/target/wasm32-unknown-unknown/release --custom-epoch-duration-secs=60`
|
|
3. run the apis in separate terminal window
|
|
4. `cargo run -- bond-local-mixnet --nym-node-bin ../../../target/release/nym-node`
|
|
5. start all the nym-nodes
|
|
6. `cargo run -- create-local-client --nym-client-bin ../../../target/debug/nym-client`
|
|
7. usually at this point I was using `nym-cli` to get some ticketbooks into my client before running it with the command
|
|
that was output in the previous step
|
|
|
|
|
|
|
|
|