TrustMint's local stack deployed in our lab, then failed its health check. That makes this a project for developers prepared to inspect Stellar contracts and finish an integration, rather than a ready-made way to issue real assets. The useful part is the collection of asset and policy examples. The decision turns on how much assurance and transaction plumbing you can supply yourself.
What people use TrustMint for
The project's CI suite deploys TrustMint WASM contracts to local Stellar Quickstart and checks KYC, compliance, RWA and invoice reads, according to issue #27.
- Who used it: the project's own CI suite. Task: deploy the contracts and exercise those read workflows. Outcome: deployment and basic reads are covered in the issue's account; the same issue #27 requests a complete state-changing lifecycle. It is open in the supplied record.
That use case is useful to a contributor changing a contract interface or learning how the registry and policy engine connect. It puts related pieces in one repository, with a dashboard and SDK alongside them. A team exploring tokenized invoices can follow an asset example through its supporting policy components instead of assembling an example from unrelated repositories.
The README describes invoice issuance, transfers, settlement and redemption, fractional property shares with dividend accounting, and carbon-credit issuance and retirement. These are upstream descriptions of the building blocks. Their appeal is specific: asset operations sit beside eligibility and transfer rules, so a prototype can explore restrictions as well as token balances.
What happened when we ran it
Our Compose deployment completed in 46 seconds, but the health-check step failed after 600 seconds. The deployment record and failed health check describe different outcomes, and both matter to someone trying to reproduce the setup.
The run record dates this to November 13, 2026, at commit 70081d18bb5f. It used the project's own Docker Compose configuration on our lab server, with every port bound to 127.0.0.1. That binding describes our deployment precautions, rather than a claim about the repository's public-facing defaults.
| Recorded Compose step | Outcome | What it tells you |
|---|---|---|
| Deploy | OK in 46 seconds | Compose deployment completed |
| Ollama connection | OK | The harness marked this auxiliary connection successful |
| Model pull | Manifest and SHA256 messages, including 4.7 GB/4.7 GB | Download output appeared in the harness |
| Healthy | FAILED in 600 seconds | The stack failed the recorded readiness step |
| Teardown | OK | Cleanup completed |
The revealing moment came after deployment. The health-check output repeatedly said stellar-core(node): Synced!, yet the harness still ended with FAILED in 600 s. Its tail also contained checkpoint-publishing messages and resolve-snapshot. A reassuring service log line was therefore insufficient for this readiness check. The extract gives us that sequence, without identifying the failed probe or proving why it failed.
The harness also recorded an Ollama connection and model-pull output. Those entries supply no evidence of a TrustMint AI feature or a completed asset operation. The pull extract repeats digest and manifest messages, so its 0s text is unsuitable as a download benchmark.
Our separate npm sandbox run installed dependencies successfully in 40 seconds and recorded 324 dependencies occupying 186 MB. It used commit 70081d1 on November 13, with 3 CPUs, 8 GB RAM and the configured image label lab-node:22.
| Sandbox check | Recorded result |
|---|---|
| npm installation | Succeeded in 40 seconds |
| Dependencies | 324 recorded, 186 MB on disk |
| Build | Skipped: no build script or target detected |
| Tests | Skipped: no tests script or target detected |
| npm audit | 21 known vulnerabilities: 11 high, 10 moderate, 0 critical, 0 low |
The scan found 113 files, roughly 13,787 source lines and a 1.3 MB checkout. It recorded npm workspaces, two CI workflow files, a tests directory, a Compose file and no Dockerfile. The skipped steps describe the npm harness's detected targets. The current README separately documents Cargo commands, an SDK command and frontend commands, so “skipped” must not become “the repository has no tests.”
Where people get stuck: the SDK stops before signing
TrustMint SDK builders return operation XDR rather than a signed transaction, according to issue #32. For an application developer, that is the most consequential interface detail in the research: receiving the builder's output is only part of getting an asset action onto Stellar.
Issue #32 requests an example that covers simulation, assembly, wallet signing, submission and confirmation with an injected signer. The supplied record is open and contains a contributor's offer to work on it. An offer is not a merged example. Treat the issue as a precise description of the documentation work an integrator may still need to do.
A wallet application needs to carry the operation through that sequence and handle its outcomes. The issue's requested injected signer also gives a sensible boundary for the example: wallet signing belongs in an explicit integration step. Copying operation XDR into an application does not answer how the user authorizes it or how the application learns that the action completed.
| Friction | Requested improvement | Status in the supplied record |
|---|---|---|
| Operation XDR needs a transaction workflow | Issue #32: simulation through confirmation with an injected signer | Open |
| CI failure location is hard to identify | Issue #6: crate, target, command and integration-stage summaries | Open |
| Repeated Cargo work across jobs | Issue #7: lockfile-, target- and toolchain-aware cache keys | Open |
| Formatting and lint feedback arrives after pushing | Issue #2: optional local hooks with installation and removal instructions | Open |
The failure-summary request in issue #6 is particularly relevant after our health-check result. It asks for the failed integration stage and original error output to survive in job summaries, without exposing credentials. That is a requested diagnostic improvement, rather than a documented fix for our particular run.
Issue #7 asks for cache review while preserving identical results on a clean cache miss. Issue #2 asks for optional local checks. Both remain open in the records. These are useful contributor tasks, but neither supplies a shorter measured setup time.
Deployment helpers cover a specific asset suite
The README says the testnet helper deploys the registry, compliance engine, invoice, property and carbon-credit contracts, while excluding the separate RWA reference token. That distinction prevents a frustrating mismatch between the repository's feature table and the contract IDs an application expects after running the helper.
The documented prerequisites span Rust, the WASM target, Stellar CLI and Node.js 20 or newer, with Docker for local integration work. A developer only installing npm dependencies has completed one portion of this setup. The dashboard can load without contract IDs, but network-backed workflows require the relevant VITE_*_ID values. A page appearing in the browser is therefore a different checkpoint from a connected asset workflow.
The deployment script's asset metadata is placeholder data, according to the README. Replace it before deployment, including testnet. For a first evaluation, choose one asset contract and write down the expected accounts, approvals, transfer rule and resulting state. That creates a concrete acceptance task and avoids mistaking a dashboard tour for an exercised transaction path.
Contract assurance requests concern state after an operation
Issues #26, #28 and #29 ask for stronger evidence about balances, arithmetic and SDK compatibility. They describe requested checks, not demonstrated exploits. A developer deciding whether to adapt these contracts should read the requested acceptance conditions as carefully as the feature list.
Issue #26 requests multi-holder lifecycle sequences for invoice, property, carbon and RWA contracts, including supply invariants and unchanged state after failed operations. The important question is what happens to every affected holder and total supply across the sequence. A successful individual call cannot answer that whole question.
Issue #28 requests deterministic checks around zero, maximum and overflow-adjacent amounts, along with timestamps, fees and counters. Its explicit goal includes proving that overflow cannot mutate state. The record reports no overflow exploit. For a team evaluating asset code, this is an assurance task with clear inputs and expected outcomes, rather than evidence that an attacker has already broken the arithmetic.
Issue #29 requests comparison of public contract specifications against SDK methods and arguments. Its proposed failure condition is useful: stale SDK mappings should fail CI and interface changes should produce a reviewable diff. That work addresses a different risk from contract arithmetic, because a correct contract can still be awkward to call through an outdated client. All three requests are open in the supplied records.
Security depends on the verifier and the browser configuration
TrustMint does not verify identities or provide legal compliance, the README says. An authorized verifier records an approval decision on-chain, while the identity documents and the process behind that decision stay off-chain under the deploying project's control. This is a firm product boundary, and a reason to pass if you need a complete identity service.
A registry can store an approval without settling whether the person making that approval used an adequate process. Teams adapting the examples need to decide who can approve holders, who administers policy and how those responsibilities fit their operation. The contract examples are useful precisely when the team wants to inspect those connections and own those decisions.
The README also warns that Vite variables are bundled into the browser application. Never put private keys, secrets or identity documents in them. Contract IDs belong in frontend configuration; a convenient environment-variable name does not make its value confidential. This warning is more actionable than describing the project with a general security adjective.
Issue #9 requests tighter workflow permissions and review of external action references, especially for untrusted pull requests. It remains open in the supplied record. The npm audit finding belongs to the JavaScript dependency environment, while that issue concerns CI permissions. Neither should be presented as a completed Soroban contract audit.
TrustMint vs OpenZeppelin Stellar Contracts and Stellar JS SDK
OpenZeppelin Stellar Contracts supplies contract components, while Stellar JS SDK supplies network and transaction facilities. These are alternatives for particular parts of a developer's job, rather than interchangeable asset platforms. The research synthesis contains no direct competitor comparison, so this table uses their own documentation to explain which starting point to consider.
| Starting point | Documented role | Choose it when |
|---|---|---|
| TrustMint | Asset examples with registry, policy, dashboard and SDK pieces | You want to inspect how those pieces connect in an asset prototype |
| OpenZeppelin Stellar Contracts | Separate crates for access, accounts, tokens and contract utilities | You want to choose contract components and design your own application |
| Stellar JS SDK | Horizon and RPC networking, transaction construction, signing and submission | You already have contracts and need the client and transaction layer |
OpenZeppelin's README lists separate access-control and token crates. It also explicitly labels the software experimental. It recommends version pinning because rapid iterations are expected. Its name alone is no reason to skip a review of the specific components you intend to use.
Stellar JS SDK's README documents transaction building, signing and submission facilities. Those capabilities make it a relevant starting point for someone whose primary problem is moving a contract call through a transaction workflow. Choosing that lower-level route means owning the asset application design yourself. TrustMint's appeal is the supplied asset examples and their connections, rather than an escape from transaction integration.
What the other reviews get wrong
The supplied search results mix zeemscript/TrustMint with unrelated products that share its name. There is no basis here to call those products inaccurate reviews of the repository. The correction is to the identity match: their claims belong to their own services.
TrustMint.co describes Google review management for local businesses. TryTrustMint.com describes review automation for home-service businesses. Neither page supplies evidence about this Stellar codebase. A developer searching the short name should keep the repository owner attached to the query and check that any technical advice names Stellar or Soroban.
The Reddit scam question asks about trustmint.win. It cannot support a safety verdict about zeemscript/TrustMint. Likewise, the supplied X search record names a TrustMint hackathon entry by team macBlockers without connecting it to this repository. Counting that announcement as adoption would attach someone else's activity to the software under review.
Questions people ask
Issue #32 requests a complete signing workflow, while issues #6 and #2 address CI diagnostics and local checks.
How do I simulate, sign, submit, and confirm a transaction built with the TrustMint SDK?
Issue #32 requests that exact workflow because builders return operation XDR. The requested sequence is simulation, assembly, injected-wallet signing, submission and confirmation. Use the issue as a checklist for the integration you need to finish, rather than as a working code example. The record supplies no completed signing recipe to reproduce here.
Do TrustMint's integration tests verify completed asset operations and policy-denied operations?
Issue #27 requests a completed permitted operation, a subsequent state read and a policy-denied operation that preserves asset state. It describes existing deployment and basic-read coverage separately. The supplied issue therefore supports calling the complete lifecycle an open coverage request, rather than claiming it already passes or that it exposes a defect.
How can contributors identify and reproduce a failing TrustMint CI job?
Issue #6 asks job summaries to name the crate or integration stage, target, failed command and relevant log. Until that request is resolved, preserve those details from the failing job itself when reporting a problem. Include the original error output and exclude credentials. The request is open in the supplied record.
Can contributors run formatting and lint checks locally before committing?
Yes: the README documents cargo fmt --all -- --check and cargo clippy --all --all-targets -- -D warnings. Issue #2 requests optional hooks to run fast checks automatically, with documented installation, removal and bypass behavior. Manual commands are documented today; the supplied issue describes the hook setup as requested work.
What we have not tested yet
Our npm run measured dependency installation and audit output, while the Compose run reached a failed readiness step. We have not tested a completed wallet-signed asset lifecycle, policy-denial state preservation, property dividends, invoice redemption or carbon retirement end to end. The records contain no known-answer task results, application memory measurements or screenshots. There is no transaction throughput, latency-at-volume or operating-cost benchmark to compare against another project.
The health-check extract does not establish which probe failed or whether the cause was configuration, packaging, the lab environment or application behavior. The auxiliary Ollama and model-pull entries do not explain their purpose in a Stellar deployment. Exact runtime and operating-system versions require the raw toolchain logs; the configured image label alone cannot confirm them. Our current README reading also is not a commit-pinned reproduction of every documented command.
We did not reproduce the Rust contract checks, inspect every dependency advisory for reachability, or conduct a security audit. The open issues are requests for additional assurance, not proof of arithmetic or authorization exploits. Production adoption, support response times, legal suitability and mainnet reliability remain unassessed. That is why setup, community and maturity have no numeric score here. Documentation receives 3/5 under a narrow rubric: 1 means no usable setup guidance, 3 means concrete commands with a consequential integration gap, and 5 would require an exercised end-to-end guide. The README supplies commands; issue #32 identifies the gap.
For a developer evaluation, the next useful result is one permitted operation through confirmation, followed by a state read, then one denied operation with unchanged state. Record that sequence against the exact contracts and SDK revision you intend to adapt before putting real assets behind the interface.


