Medusa Core (OSS)
Blocks, hashes, events, verify, basic API, Docker, SDK, docs.
Open Source · Apache-2.0
Medusa Ledger — Open Source Trust Ledger for Business
Append-only SHA-256 ledger so anyone can prove business events — without replacing your ERP.
SHA-256 · append-only
Single ledger per instance
npm · Spring · Docker · .NET
Core vs Cloud
Open the engine. Keep multi-tenant business features commercial.
Medusa Cloud
Multi-tenant / white-label, payment anchors, analytics hubs, SLA, ERP connectors.
How an event becomes proof
You define the event. Medusa makes it verifiable.
1
YOUR APP
2
EVENT + payload
3
SHA-256
4
BLOCK
5
VERIFY
Storage SPEC
Operational DB is state. Medusa is evidence. The chain lives next to the app — not in the other service’s Mongo.
Embedded
npm install · FileStore · ./ledger/blocks/*.json
Sidecar
Docker / K8s volume · HTTP append + verify from any language
Cloud
Managed ledger per business unit · backups, anchors, multi-tenant
Install SPEC
Same protocol. Pick the stack already in the project. Node is the hash reference in v0.1; Spring and .NET talk HTTP to the sidecar.
Embedded Core in Node
In-process FileStore. No extra container required.
npm install @medusa-ledger/core
const { MedusaChain, FileStore } = require("@medusa-ledger/core");
const chain = new MedusaChain(new FileStore("./ledger"), { autoSeal: true });
await chain.appendEvent({
eventId: "order-001",
eventType: "ORDER_CREATED",
payload: { amount: 50000, currency: "COP" }
});
console.log(await chain.verifyChain());
Spring Boot HTTP client
v0.1 starter calls the Docker sidecar. Native Java hash is v1.1.
<dependency> <groupId>com.medusa</groupId> <artifactId>medusa-ledger-client</artifactId> <version>0.1.0</version> </dependency>
implementation 'com.medusa:medusa-ledger-client:0.1.0'
var body = """
{"eventId":"order-001","eventType":"ORDER_CREATED",
"payload":{"amount":50000,"currency":"COP"}}
""";
var req = HttpRequest.newBuilder()
.uri(URI.create("http://localhost:8080/api/events"))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(body))
.build();
var res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
Docker white-label sidecar
Any language posts HTTP. Chain lives on the container volume.
git clone https://github.com/wbsckt3/medusa-ledger.git cd medusa-ledger docker compose up --build
curl -X POST http://localhost:8080/api/events \
-H "Content-Type: application/json" \
-d '{"eventId":"order-001","eventType":"ORDER_CREATED","payload":{"amount":50000}}'
curl http://localhost:8080/api/verify
.NET stub (roadmap)
HTTP client against the sidecar in v0.1. Native NuGet hashes in v1.2. Do not fork SHA-256 until SPEC is frozen.
dotnet add package Medusa.Ledger
var client = new MedusaLedgerClient("http://localhost:8080");
await client.AppendAsync("ORDER_CREATED", "order-001",
new { amount = 50000, currency = "COP" });
var verify = await client.VerifyAsync();
Console.WriteLine(verify.Valid);
Quick start
Append ORDER_CREATED, then PAYMENT_RECEIVED, then verify. Same two events on every stack.
Install the Core
npm install @medusa-ledger/core
Append two events
const { MedusaChain, FileStore } = require("@medusa-ledger/core");
const chain = new MedusaChain(new FileStore("./ledger"), { autoSeal: true });
await chain.appendEvent({ eventId: "order-001", eventType: "ORDER_CREATED",
payload: { customerId: "customer-42", amount: 50000, currency: "COP" } });
await chain.appendEvent({ eventId: "payment-001", eventType: "PAYMENT_RECEIVED",
payload: { orderId: "order-001", amount: 50000, currency: "COP" } });
Verify the chain
console.log(await chain.verifyChain());
// { valid: true, message: "Ledger integrity verified" }
Sidecar up, then Maven or Gradle
docker compose up --build # pom.xml → com.medusa:medusa-ledger-client:0.1.0
POST events, GET verify
HttpClient.newHttpClient().send(
HttpRequest.newBuilder()
.uri(URI.create("http://localhost:8080/api/events"))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(
"{\"eventId\":\"order-001\",\"eventType\":\"ORDER_CREATED\",\"payload\":{\"amount\":50000}}"))
.build(),
HttpResponse.BodyHandlers.ofString());
HttpClient.newHttpClient().send(
HttpRequest.newBuilder().uri(URI.create("http://localhost:8080/api/verify")).GET().build(),
HttpResponse.BodyHandlers.ofString());
Clone the repository
git clone https://github.com/wbsckt3/medusa-ledger.git cd medusa-ledger
Start the stack
docker compose up --build
Append an event
curl -X POST http://localhost:8080/api/events \
-H "Content-Type: application/json" \
-d '{
"eventId": "order-001",
"eventType": "ORDER_CREATED",
"payload": { "customerId": "customer-42", "amount": 50000, "currency": "COP" }
}'
Verify integrity
curl http://localhost:8080/api/verify curl http://localhost:8080/api/ledger/show
Sidecar + stub package
docker compose up --build dotnet add package Medusa.Ledger
Append and verify
var client = new MedusaLedgerClient("http://localhost:8080");
await client.AppendAsync("ORDER_CREATED", "order-001",
new { amount = 50000, currency = "COP" });
await client.AppendAsync("PAYMENT_RECEIVED", "payment-001",
new { orderId = "order-001", amount = 50000 });
Console.WriteLine((await client.VerifyAsync()).Valid);
Core v0.1 lives on main. Node hashes are canonical; Spring and .NET use the Docker sidecar until native SPEC hashes ship.
GitHub Sponsors
Core is open; Cloud is managed. Sponsors fund discovery and roadmap — not a back door into multi-tenant, payment hubs, or SLA.
Community · $0
Medusa Core: blocks, hashes, events, verify, Docker, NPM, docs. Run the ledger on your disk.
Cloud / Business / Enterprise
Hosted ledgers per unit, white-label, payment anchors, analytics, ERP connectors, SLA.
Need hosted multi-tenant?
Medusa Cloud runs isolated ledgers per business unit with analytics and payment anchors.