orama setup

orama setup [ip ...] [flags]

Turn fresh VPSes into nodes of an Orama network, in one command.

For each machine setup gives your RootWallet an SSH key (and pins the machine's host key),
checks the hardware against what the machine will run, installs the signed release of the
network's channel (verified against the release root the network pins), installs the cluster
node and, beside it, the global layer: the chain (it joins by state sync from two seeds that
must agree), public storage and its provider, and a Tor relay (the network pins the Tor network file its
relays join; --tor-network gives another, --no-relay leaves the relay out). Then it registers your operator, each node, its bonds and its storage capacity on the
chain and creates your validator, signing every transaction with your RootWallet. Nodes are
restarted one at a time, each waiting until it carries its share of the cluster again.

Each machine downloads the release from the release repository itself, up to eight at a time, and checks the
file against the length and SHA-256 of the release metadata that setup verified here; the archive does not pass
through this computer. A machine that cannot reach the repository fails the run; --upload-release downloads the
archive here and uploads it to each machine over SSH, one after the other, for such machines.

The first machine creates the cluster; the others join it. Running setup again with more
addresses adds nodes to the same cluster, and a machine that already has a step does not get
it again, so a run that stopped can be run again as it was.

With no addresses and no --yes, on a terminal, setup asks for everything. With --yes it asks
nothing: give the addresses, --name, and a --host-key for each machine (the fingerprint your
provider's console shows; setup never trusts a host key it was not given).

The operator account needs ORAMA for the bonds and for the validator's 1,000 ORAMA self-bond.
On a network with a faucet and a node of it in your CLI configuration it is requested; otherwise
setup stops, says how much to send and to which address, and resumes when you run it again.

--create-network <name> makes a new network instead of joining one. Every machine is a bootstrap
validator of it: setup installs the cluster and the global layer on all of them, makes each
machine's chain keys, builds the genesis on the first machine from all the keys, gives it to
the others, starts the chains one after the other, waits for blocks, and then registers your
operator and the nodes as it does for a join. It writes networks/<name>/ (manifest, genesis,
release root) to --publish-dir and prints what to do to publish it. --chain-id is the chain's
id: a test network's carries -stagenet-, -devnet- or -localnet-; any other is a production id, which
setup refuses: it creates test networks only, because it keeps each seat's key in an unencrypted test keyring
(a production network needs seat accounts held by the RootWallet, which is not built). --release-root is the release-root.json the network's
releases are verified against. A network that was announced in the registry before it was created (orama maint network announce)
supplies its chain id, release repository, channel, minimum version, seeds, faucet and release root, so those flags can be left out;
a flag overrides the announcement, and the genesis built here is published over it. Joining a network that is only announced is refused. Running it again with the same machines resumes: a machine that
has its keys keeps them, and a genesis the machines carry is kept (--force-new-genesis builds a
new one, and only while no chain has run).

A creation also makes the network its own Tor network, unless --tor-authorities 0: the first N machines
(default 3, when there are at least 3 machines and neither --tor-network nor --no-relay is given; fewer
than 3 is refused) each run a directory authority, whose keys are made on that machine and never leave it,
and the others run relays (exits with --exit). After the chains run and the nodes are registered, setup
installs and starts the authorities within minutes of each other, waits until the machines' own tor holds a
consensus signed by a majority of the authorities that lists them (an authority casts no Running vote for
30 minutes after it starts, so that takes about an hour), then leaves the bootstrap mode: the authorities
are restarted one at a time, each only when its own machine allows it (30 minutes after the previous one
started), then the relays. The step takes two hours or more; a run that stops resumes where it stopped.
networks/<name>/ gets the tor-network.json the manifest pins, which every machine that joins installs.

--cluster-only installs the cluster node alone (2 vCPU, 2 GiB, 10 GiB free). The full profile
needs 4 vCPU, 8 GiB and 80 GiB free plus the storage you offer. Nothing is installed on any
machine until every machine passes.