mrkeyoor.comAsk

zeemscript/TrustMinttested 13 Nov 2026commit 70081d1

TrustMint review

Our TrustMint Compose deployment completed in 46 seconds, then failed its health check after 600 seconds, so budget for integration work before evaluating an asset workflow.

  • Deploy 46 s
  • Healthy failed
40 sto install
  • 324 packages
Dev Toolsevaluationupdated 13 Nov 2026
+0stars / 7d

TrustMint is zeemscript's collection of Stellar Soroban building blocks for tokenized invoices, property shares and carbon credits. It connects asset examples with holder-approval and transfer-policy examples, plus a dashboard and TypeScript SDK. The README explicitly says it does not verify identities or provide legal compliance.

Verdict

Our TrustMint Compose deployment completed in 46 seconds, then failed its health check after 600 seconds, so budget for integration work before evaluating an asset workflow. Use it to study and adapt Stellar asset and policy examples if you can own the signing path and contract assurance. Pass if you need a complete identity service or a deployment ready for real assets.

TrustMint infographic: study and adapt Stellar asset and policy examples, plus our test result and who it suits
Tested 13 November 2026: the deployment was running after 46 s. Before that: source install 40 s.

We ran it

Lab card: what happened when we ran TrustMint
Lab card from our sandbox run
Screenshot of TrustMint (github.com/zeemscript/TrustMint)
github.com/zeemscript/TrustMint
Install✓ · 40s324 packages · 186 MB
Buildn/ano build script
Testsn/ano test script
Known vulns210 critical · 11 high · 10 moderate · 0 low (npm audit)
Repo113 files~13,787 lines of source · 1.3 MB · 2 CI workflows · tests dir

Answers from our run

Does TrustMint build from source?

Dependencies installed in 40 seconds (324 packages), and the project has no separate build step. We cloned commit 70081d1 into a clean Debian container with 3 CPUs and no project-specific setup.

Does TrustMint have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does TrustMint have known vulnerabilities in its dependencies?

npm audit flagged 21 known advisories in the dependency tree at the time of our run.

Who should not use TrustMint?

Teams seeking a complete identity-verification or legal-compliance service: the README excludes both.

What are the alternatives to TrustMint?

OpenZeppelin Stellar Contracts, Stellar JS SDK. Our TrustMint Compose deployment completed in 46 seconds, then failed its health check after 600 seconds, so budget for integration work before evaluating an asset workflow.

Setup2/5In our 2026-11-13 run it deployed in 46 s but never became healthy (“stellar-1 | stellar-core(node): Synced!”), though our source checkout installed in 40 s.Editor’s note: npm installation completed, but Compose readiness failed and the supplied tail gives no cause. An end-to-end supported setup was not assessed.
Docs4/5The README has an install section (“Explore the building blocks”) and a usage section (“Developer commands”); we did not run its quickstart ourselves.Editor’s note (scored 3/5): On the visible documentation rubric, concrete Cargo, SDK and frontend commands support 3/5. Issue #32 identifies an open end-to-end wallet-signing guide gap.
Community3/5Last push on 2026-11-06, 131 stars and maintainers answered or closed 4 of the 10 most-discussed issues we sampled.Editor’s note: The supplied issues show requested work and contributor interest, without enough evidence to rate support responsiveness or adoption.
Maturity1/5No tagged GitHub release and repository created 2026-10-04.Editor’s note: A completed asset lifecycle, mainnet reliability and independent security assurance were outside the measured run, so no numerical maturity judgment is supported.

How we score

Who it’s for

Stellar developers exploring asset prototypes who can inspect Rust contracts and adapt TypeScript clients.
Contributors interested in the specific lifecycle, arithmetic and SDK-interface checks requested in the issue tracker.
Teams that already own the off-chain identity process and want examples of recording approvals on-chain.

Who it’s NOT for

Teams seeking a complete identity-verification or legal-compliance service: the README excludes both.
Developers expecting SDK builders to return a signed transaction: issue #32 says they return operation XDR and requests the remaining workflow.
Operators requiring a demonstrated ready-to-use deployment: our Compose health check failed after 600 seconds.
Teams expecting the deployment helper to include the separate RWA reference token: the README says it is excluded.

Setup reality

Our November 13, 2026 sandbox run at 70081d1 installed npm dependencies in 40 seconds, recording 324 dependencies and 186 MB on disk. Build and tests were skipped because the harness detected no matching script or target. npm audit reported 21 known vulnerabilities: 11 high and 10 moderate, with none critical or low. Separately, our Compose deployment completed in 46 seconds, but its health check failed after 600 seconds.

The README requires Rust, the WASM target, Stellar CLI and Node.js 20 or newer, plus Docker for local integration work. Network-backed dashboard workflows need contract IDs. The testnet helper excludes the separate RWA reference token and uses placeholder asset metadata that needs replacing.

The npm sandbox configuration was 3 CPUs, 8 GB RAM and image label lab-node:22; raw logs are needed for actual runtime versions. The Compose log tail showed stellar-core Synced! and checkpoint resolve-snapshot messages, without identifying why readiness failed. A successful dependency install is only one checkpoint in this multi-toolchain setup.

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.

Alternatives

ProjectWhat it isPick it when
OpenZeppelin Stellar ContractsSeparate Stellar contract crates for access controls, tokens and supporting utilities.Choose it when you want contract components for an application you design yourself; its README labels the software experimental.
Stellar JS SDKJavaScript facilities for Stellar networking and building, signing and submitting transactions.Choose it when you already have contracts and need the network and transaction layer rather than asset examples.

Sources

  1. TrustMint README
  2. TrustMint integration lifecycle request
  3. TrustMint wallet signing request
  4. OpenZeppelin Stellar Contracts README
  5. Stellar JS SDK README

More dev tools reviews