mrkeyoor.com_
Tue 01 Sept 17:39 UTC
Self-Hostedevaluationupdated 25 Aug 2026

node review

Amadeus Node is the validator and RPC software for the AMA blockchain, which supports WASM contracts and a matrix-multiplication proof-of-work system. The repository combines an Elixir/Erlang node with Rust native code, local testnet tooling, contract samples, and operator instructions for joining its networks.

+125stars / 7d
Verdict

Our Rust contract-sample build installed 4 packages, then failed in 34 seconds with 20 type errors, so the repository does not currently offer a dependable Rust contract starting point at commit 01e66db. The Elixir node may still interest researchers committed to AMA, but our lab did not build it and the operator instructions make invasive host changes. Do not deploy it on a shared server until the license, Rust SDK, test coverage, host tuning, and update policy have been reviewed independently.

We ran it

Lab card: what happened when we ran nodeScreenshot of node (github.com/amadeusprotocol/node)
Install✓ · 34s4 packages
Build✗ · 34s
Tests✗ · 32sran, no count parsed
Repo172 files~18,075 lines of source · 1.3 MB · 0 CI workflows

Answers from our run

Does node build from source?

Dependencies installed in 34 seconds (4 packages), and the build failed. We cloned commit 01e66db into a clean Debian container with 3 CPUs and no project-specific setup.

Do node's tests pass?

The test command failed in our container, and its output did not report a pass or fail count.

Who should not use node?

Contract developers who need a working Rust sample today: our build of contract_samples/rust/ failed with 20 compiler errors.

What are the alternatives to node?

Polkadot SDK, Cosmos SDK, nearcore. Our Rust contract-sample build installed 4 packages, then failed in 34 seconds with 20 type errors, so the repository does not currently offer a dependable Rust contract starting point at commit 01e66db.

Setup1/5Rust contract sample fails and node setup changes the host deeply
Docs2/5Useful pointers, but sparse steps and source is declared more current
Community2/5Recent pushes and releases, with weak issue and review hygiene
Maturity2/5Live network claims, but experimental status and missing CI remain

Who it’s for

Blockchain engineers specifically evaluating the AMA protocol and willing to read consensus source code.
Operators prepared to run an experimental Linux node, tune host networking, and monitor a system service.
Contract developers who can work with WASM, AssemblyScript or Rust, and a project-specific CLI.
Researchers who need the implementation of AMA's BLS signatures, Merkle structures, RPC endpoints, and useful proof-of-work design.

Who it’s NOT for

Contract developers who need a working Rust sample today: our build of contract_samples/rust/ failed with 20 compiler errors.
Teams requiring clear redistribution rights: GitHub reports no detected license, and the repository root contains no license file.
Operators unwilling to make host-wide kernel and resource-limit changes: the README proposes large UDP buffers, unlimited process and memory-lock limits, and a root-run systemd service.
Security-conscious teams seeking a safe local web test flow: the README tells users to launch Chrome with certificate checking and web security disabled.
Developers who need finished remote testnet instructions: the contract guide explicitly says that section will be finished later.
Projects that depend on stable, complete documentation: the getting-started guide says linked source files are more current than the docs.
Teams expecting established CI evidence: our snapshot found 0 CI workflow files, no root Dockerfile, and no top-level tests directory.

Setup reality

Our harness entered ./contract_samples/rust/, not the Elixir node. It installed 4 Rust packages in 34 seconds, then the build failed after 34 seconds with 20 type errors, including an abort macro returning () where u128 was required. Tests failed after 32 seconds with the same type errors plus a no-std panic-unwinding error.

The node itself uses a Docker or Podman builder under ex/, then build.sh; a local developer path needs the Elixir/Erlang and Rust toolchains described by that image. A testnet also needs local host mapping, ports 80 and 443, and node-specific environment variables.

Production notes change global sysctl and security limits, create a systemd service, optionally enable auto-updates, and default to root. The repository calls the project experimental. No license is declared in GitHub or at the repository root.

The repository is a blockchain node, not a normal Rust crate

The main implementation lives under ex/ and mixes Elixir with a native Rust component. Its directories cover peer networking, consensus coordination, transaction pools, RPC APIs, chain storage, snapshots, rate limiting, validator work, and built-in contracts. The project describes AMA as a privacy-focused layer 1 with 500 ms blocks, BLS12-381 signatures, WASM contracts, sorted Merkle proofs, and matrix multiplication as useful proof of work.

Contract samples sit beside the node in AssemblyScript and Rust. Examples cover a counter, deposits, a token, and an NFT. The local testnet exposes Elixir helpers for deployment and calls, while a separate amadeus-cli path creates keys, transfers test tokens, deploys WASM, and queries RPC endpoints. This is protocol-specific infrastructure, so its value depends entirely on choosing the AMA network.

What happened when we ran it

Our sandbox cloned commit 01e66db into a fresh, unprivileged Debian container with 3 CPUs, 12 GB of RAM, and no secrets. The whole checkout occupied 1.3 MB, contained 172 files, and held about 18,075 lines of source. The harness detected the runnable Rust project under contract_samples/rust/, rather than the Elixir node under ex/.

Inside that Rust sample, installation succeeded in 34 seconds and installed 4 packages. The build failed after 34 seconds with exit code 101. Cargo reported 20 errors in amadeus-sdk; the visible example showed a macro path expected to return u128 but receiving () from the abort path.

The test command failed after 32 seconds with exit code 101. Its log again reported 20 errors for the library test and 21 for the library build, plus a warning. It also said unwinding panics are unsupported without the standard library and suggested a nightly build-std panic-abort route. Those lines describe compilation failure, so no tests actually ran.

This result is limited to the Rust smart-contract SDK sample. It does not establish whether ex/build.sh can produce the node binary. The supplied measurement block identifies the Rust subdirectory as the project the harness found, and the repository has no root manifest that would redirect a generic Rust run into the Elixir build. The node remains unverified by our sandbox.

Building the node requires a dedicated Linux environment

The README says its tested environment is Ubuntu 24.04 with Linux kernel 6.8. The preferred build creates an Erlang builder image from ex/build.Dockerfile and then runs ex/build.sh. The local route tells contributors to follow that Dockerfile as root, then run mix deps.get and mix compile for language-server support. This is a specialized toolchain rather than a release binary quick start.

Running a local testnet adds host and browser changes. The README maps nodes.amadeus.bot to localhost, permits unprivileged binding on ports 80 and 443, and launches Chrome with certificate verification plus web security disabled. That browser command should only be used in an isolated testing profile. It weakens protections that normal browsing depends on.

The contract getting-started guide is candid about documentation. It points readers directly to consensus, WASM import, RPC, and proof-generation source files because those are more current than any prose documentation. Its remote testnet section says it will be finished later and recommends local deployment for now. Engineers should expect source archaeology, not a stable application developer guide.

The operator recipe changes the whole host

The systemd section writes global network buffer values and raises file, process, task, and memory-lock limits. Several limits become unlimited, while the file-descriptor target is 1,048,576. The sample service runs as root from /root, starts the node inside GNU Screen, restarts after 3 seconds, and can enable automatic updates through an environment variable. A brief note shows how to change the user.

These settings may be intentional for a high-throughput validator, but copying them onto a shared server is poor operational hygiene. Create a dedicated host, justify each sysctl and limit, use a non-root service account, pin the binary, and understand how AUTOUPDATE=true obtains and verifies a release. Release v1.5.8 says signed updates fail closed and reject rollback, but operators should verify that path before enabling it.

Contract and RPC edges are still under repair

The Rust SDK failure blocks the most approachable contract language in this repository. AssemblyScript may still work, but that is a separate path with its own compiler and samples. The Rust guide also depends on amadeus-cli, a testnet faucet, external RPC endpoints, and generated signing keys. Until the SDK compiles at the reviewed commit, new Rust contract work starts with repairing the toolchain.

Open pull request 24 covers invalid limit and offset query parameters that could trigger a bad argument exception and return 502, while negative values reached the database or native layer. The proposed fix validates integers and returns 400, but its test-plan boxes were still unchecked. Open issue 8 asks for backoff because traffic to unconfirmed peers could make data centers flag nodes as scanners.

Current releases do not replace missing project hygiene

GitHub recorded a push on August 25, 2026, and listed 10 open issues and pull requests together. Release v1.6.0 arrived August 10 with a one-line note about PRIME points at mainnet epoch 792. Earlier releases contain much deeper consensus, validator, proof, snapshot, and security notes, showing that substantial implementation work exists behind the sparse top-level README.

Repository hygiene is much weaker than that release history. The measured snapshot had 0 CI workflows, no root Dockerfile, and no top-level tests directory. Several open issues have one-word titles without actionable detail. GitHub detects no license, and the root listing has no license file. An experimental disclaimer is not permission to use, modify, or redistribute code. AMA specialists may still learn from the implementation, but general users have safer, better documented options.

Alternatives

ProjectWhat it isPick it when
Polkadot SDK gh↗A modular Rust framework for building and operating custom blockchains and WASM runtimes.pick this instead when you need a mature toolkit for designing a chain rather than joining the AMA network.
Cosmos SDKA Go framework for application-specific blockchains with a large validator and module ecosystem.pick this instead when established tooling, governance modules, and interoperable chain construction matter more than AMA's design.
nearcoreThe Rust node implementation for NEAR, including its runtime, networking, and validator software.pick this instead when you want WASM contracts on a more established network with broader documentation and tooling.

What people are saying

  1. [github-trending] nodejs/node
  2. [github-trending] amadeusprotocol/node

Sources

  1. Amadeus Node README
  2. AMA protocol documentation index
  3. Contract getting started guide
  4. Rust contract SDK guide
  5. Amadeus v1.6.0 release
  6. RPC parameter validation pull request 24
  7. Unresponsive peer issue 8
  8. Measured Amadeus commit

More self-hosted reviews

v2 · OpenShell · wigolo · Mindwtr · club-3090 · reclip · the whole board →