GemTrackr

@OpenLedger #OpenLedger $OPEN
The thing that keeps bothering me on OpenLedger is the warning flag after the bad upload.
Not the bad upload itself.
That part is boring.
Duplicate row. Fake label. Old scrape wearing fresh metadata. Low-effort upload dressed up as community participation because apparently metadata makes garbage feel employed.
Fine.
Reject it.
The warning flag is worse.
Because it stays there after the row is gone.
That is where OpenLedger gets uncomfortable in a useful way.
The clean version is easy. Datanets need quality. Contributors need incentives. Proof of Attribution should not pay garbage. OPEN rewards should not leak to spam. Fine. Nobody is defending the upload farm. Congratulations, society found the obvious villain.
Punish bad data.
Now decide how long the punishment remembers.
That is the part people skip because it is not fun to put in the deck.
I keep picturing a contributor sending a bad batch into a DeFi risk Datanet on OpenLedger. Maybe it is not even evil at first. Just sloppy. A few exploit labels copied from old summaries. Some liquidation examples without market context. One oracle failure note that gets the timeline wrong. Metadata clean enough to look respectable. Cute little disaster.
The validation layer catches part of it.
Contributor reputation takes a hit.
Maybe the source gets discounted. Maybe future rewards get reduced. Maybe the next submission gets slower review.
Good.
The system worked.
That is exactly why it gets worse.
Because now OpenLedger has memory.
The contributor comes back later with something better. A real source this time. Maybe an ugly but valuable trading-risk note. Maybe a rare incident pattern that OpenLedger's OctoClaw could use while building a risk view before a trading agent touches a route. Maybe something ModelFactory builders would want in a fine-tune. Maybe the kind of Datanet entry that later helps an OpenLoRA adapter stop a model from saying some confident nonsense about protocol safety.
But the wallet has a scar now.
Penalty note. Lower trust. Longer review. Worse retrieval odds. Not dramatic. Just enough friction to miss the next inference window.
This is the part I keep seeing in my head. Not the rejection. The next submission. Same wallet. Better data. Old warning still sitting beside it like a bored security guard.
Nice.
The bad data failed yesterday, and today the good data is still paying rent to the failure.
This is the penalty problem inside OpenLedger’s data economy. Not whether bad data should have consequences. It should. Obviously. If Datanets are supposed to feed specialized AI models, then malicious or low-quality data cannot just pass through like “community participation.” That is how you get model behavior trained on trash and then everyone acts surprised when the answer smells.
But penalties are not just filters.
They become memory.
And once memory touches rewards, it becomes economic.
That is the ugly handoff.
A validation system says this contributor sent bad data. Proof of Attribution later asks which contributions mattered. Reward logic asks who deserves OPEN from usage. ModelFactory builders want trusted datasets. OpenLoRA serving paths depend on whatever got trained cleanly. Agents need sources that do not poison the route. Every layer has a good reason to care about past behavior.
Every layer is also another place where one bad submission can keep echoing.
I keep coming back to this because it is not a dramatic failure.
No hack.
No exploit.
No villain cackling into a CSV.
Just a contributor who sent something bad once, or twice, and now the system has to decide whether that history is a warning, a sentence, or a permanent stain.
That difference matters.
A malicious uploader should get hammered. Sure. Slash the influence, reduce future rewards, bury the account, whatever the Datanet governance decides. If someone is trying to feed poisoned examples into a healthcare model or a trading-risk Datanet, be boring and harsh. Society can survive one fewer spammer, somehow.
But uneven contributors are harder.
A researcher sends messy data because the source itself is messy. A new domain expert formats badly. A small team misses metadata because they are not native to the upload culture yet. Someone submits an outdated source, gets penalized, then later submits a fresh correction.
Does the system treat the second entry as new signal.
Or as another thing from the person who already dented the record.
That is where “quality control” starts looking like character judgment.
Not intentionally.
Worse.
Mechanically.
The OpenLedger's Datanet intake sees the history. The validator sees the flags. The system weights trust. The source waits longer. Meanwhile a cleaner contributor gets through. The model trains. The agent retrieves. The inference happens. The reward split gets built around what was already inside the path.
By the time the late good source clears, the answer already happened.
The bad data did not just fail.
It changed timing.
And timing is value on OpenLedger.
That is the part that feels very OpenLedger-native to me. Data does not earn because it exists. It earns if it becomes useful inside training, retrieval, inference, agent output, adapter behavior, some actual model path that Proof of Attribution can trace. So any penalty that slows a contributor can also keep them away from the moment where usefulness becomes payable.
Not blocked.
Just late.
Very elegant little punishment. No blood on the floor. Just no seat at the inference table.
I hate how realistic that is.
I can already see the ugly version. OctoClaw pulls a risk brief. A trading agent is waiting on a route. RAG hits the DeFi Datanet. Inference receipt on one side, Datanet review queue on the other. The answer leans on clean, trusted sources. The agent avoids one route or limits exposure. Good. That is what the stack should do.
Then someone checks later and finds a lower-reputation contributor had submitted a warning about the same protocol earlier. Messier. Rougher. Flagged because their last batch was bad. Delayed in validation. Not in the retrieved set when the agent asked.
The model did not ignore them.
The system never really let them arrive in time.
Not ignored. Not rejected. Just late enough to become irrelevant. Very neat. Very stupid.
Different failure.
More annoying.
Because every individual decision looks defensible. The previous penalty was reasonable. The slower review was reasonable. The trusted source was reasonable. The agent needed an answer. The inference was paid. Proof of Attribution traced what was actually used. OPEN rewarded the visible contribution trail.
Everything verifies.
Still, the useful warning missed the moment.
And now the contributor’s old failure is sitting inside the new outcome, not as data, but as delay.
That is the wound.
OpenLedger needs this memory. Without it, Datanets become a playground for adversarial uploads. Bad contributors would keep resetting themselves like nothing happened. Proof of Attribution would reward whatever got through. Agents would trust sources with no behavioral context. ModelFactory builders would pick datasets that looked clean only because the system refused to remember who kept dirtying them.
So yes.
Remember bad behavior.
But remembering is never neutral once money is attached.
The bad upload becomes a penalty score. The penalty score becomes slower review. Slower review becomes reduced retrieval chance. Reduced retrieval chance becomes less inference influence. Less influence becomes thinner reward history. Thinner reward history makes the contributor look less useful later.
Look at that.
A whole little poverty machine for data credibility.
Maybe deserved.
Maybe not.
That word again.
Maybe is where systems hide the bodies.
And on OpenLedger, this is the uncomfortable part. Bad data does not just test the validation layer. It tests how much failure-memory the AI economy can carry without turning correction into exile. Datanets need penalties. Contributor reputation needs teeth. Proof of Attribution needs clean influence trails. OPEN rewards need protection from spam. But if one ugly contribution keeps lowering the odds that later good data reaches ModelFactory, OpenLoRA, RAG retrieval, or agent execution, then the penalty is no longer only about yesterday’s data. It is shaping tomorrow’s model inputs.
That is not a small design question.
That is the future answer being edited by an old mistake.
I keep thinking about the dashboard version because it is always the dashboard version. Contributor page. A warning flag. A reduced score. Past rejected batch. Current submission pending. No drama. Just the quiet administrative look of a system making a person less believable.
The contributor probably sees “under review.”
The model sees nothing.
The agent retrieves from somewhere else.
The reward goes to whoever made it into the path.
Clean.
Terrible word, clean.
No bug. No failed proof. No broken attribution. Just a penalty layer doing its job so well that the later signal never gets close enough to be remembered.
Because the system can be cleaner and less forgiving at the same time.
Maybe that is necessary. Probably is. AI data markets cannot be soft about adversarial data. A single malicious pattern inside a specialized dataset can become expensive later. Especially when trading agents, DeFi risk models, or other OpenLedger-powered workflows start acting on those outputs. Bad data is not just a bad row. It can become bad behavior.
So the penalty layer has to exist.
Fine.
But then the human question stays there, irritating and small.
How long does bad data remain attached to the contributor?
One upload?
One Datanet?
One category?
One model path?
Does the scar decay after better submissions? Does strong later data repair it? Does a contributor get a route back into trust, or do they keep submitting from the edge of the system, visible enough to be counted as present, not trusted enough to matter?
That is not abstract fairness.
That is whether OpenLedger can punish the bad row without making the next good row drag the same shadow behind it.
Bad data should follow people.
Sure.
But if it follows too closely, the system stops only remembering risk.
It starts predicting it.
And once the AI economy starts predicting which contributors are risky, the next useful submission may never get close enough to prove otherwise.
Bad row.
Penalty.
Delayed source.
Missed inference.
No reward.
Then the dashboard says the system worked.
Maybe it did.
Old garbage gone. New signal late. Clean system.
$EDEN $BSB

@OpenLedger #OpenLedger $OPEN
What keeps pulling me back on OpenLedger is not the model.
Not this time.
It is the thing that shows up for one answer and then disappears like it did not just change the whole output.
Yeah...
The adapter.
One line in the run log. Loaded, used, gone. Like that was supposed to be the end of it.
Tiny little problem.
Naturally.
OpenLedger's OpenLoRA sounds clean until I picture the actual run. Base model sitting there. Request comes in. Adapter loads. The answer gets sharper. Adapter unloads. Everyone wants to act like the temporary part stayed temporary. A model does not need to carry every specialization forever. Fine. Efficient. No need to drag every narrow capability around like luggage nobody packed properly.
Useful.
But the moment the adapter touches the answer, OpenLedger has a memory problem.
Not technical memory only.
Economic memory.
That is the part I keep staring at.
A user asks a specific question. Maybe DeFi risk again, because apparently I enjoy staring at systems where capital and bad assumptions become friends. The base model can answer something broad. Too broad. Useless in that familiar “technically fluent, practically dangerous” way. So the OpenLoRA path loads a fine-tuned adapter trained around protocol incidents, liquidation behavior, oracle failure cases, exploit patterns, maybe some ugly governance history sitting inside a Datanet. What about a trading agent?...
The answer improves.
Maybe it catches that the oracle issue was not just a price-feed glitch but a liquidation-timing problem. Good. Useful. Also now the adapter has fingerprints on the answer.
Now the adapter can unload.
Great.
Except what exactly just happened.
The user sees one answer. The system knows a base model was involved. OpenLedger can point toward Datanets, contribution records, Proof of Attribution, model usage, maybe the adapter path, maybe the inference record, maybe the OPEN fee that moved because somebody paid for output instead of vibes.
And now the annoying question appears.
Which part earned?
The base model. adapter creator. The Datanet contributors. OpenLedger's ModelFactory workflow that produced the fine-tune?. compute path?... The retrieval source if one was pulled in. Some combination. Obviously. Always “some combination.” Very helpful. Put it on a slide and pretend the slide solved arithmetic.
This is where temporary intelligence stops feeling temporary.
Because OpenLoRA can make specialization feel light. That is the point. You do not need a whole model sitting there forever for every narrow domain. You can serve different adapter paths, switch context, answer specific requests, then release that specialization. Efficient. Clean. Almost elegant, which is usually when I start checking where the uglier part got moved.
Cheap serving removes one cost and creates another: explanation debt.
And on OpenLedger, the uglier part moves into attribution.
If an adapter shaped the answer for three seconds, OpenLedger Proof of Attribution still has to remember it longer than three seconds. The reward logic cannot shrug because the adapter is gone from active memory. The Datanet contributors whose data trained that adapter cannot become invisible just because inference was efficient. OPEN settlement cannot treat the answer like it came from one smooth model blob because the whole point is that OpenLedger is trying not to lie about where AI value came from.
That is the split.
The model can be temporary.
The trail cannot.
Three seconds is enough to change the output. Apparently it is also enough to create a creditor. Lovely.
I keep picturing the run log after a specialized answer. Not the user screen. The uglier one. Base model ID. Adapter loaded. Adapter merged or routed. Datanet source behind the adapter. ModelFactory training record. Inference event. OPEN fee. Proof of Attribution waiting to turn a three-second adapter path into a payout claim.
Good.
The answer is done.
...accounting is not.
That is the part that keeps making me rub my eyes. The system finished the response and somehow opened a ledger dispute.
That feels like the real OpenLoRA pressure. Not "can it serve adapters efficiently." Fine, maybe it can. The better question is what happens when efficient serving creates more short-lived influence events than the reward layer can comfortably explain to humans later.
Because humans do this wonderful thing where they accept complexity until they see their payout.
Then suddenly everyone becomes a forensic accountant.
A model builder says the adapter did the real work. A Datanet contributor says the adapter only mattered because their ugly niche data taught it something useful. A compute operator says the inference still needed serving. A user says they paid for an answer, not a seminar on model lineage. And OpenLedger, poor machine, has to make the trail legible enough that "payable AI" does not turn into “trust us, the split was probably fine.”
Great.
We invented transparency and immediately found new paperwork inside it.
The hard part is that adapter influence is not always obvious. Some requests on OpenLedger may barely touch the adapter. Some depend on it heavily. Some use the adapter to steer language but rely on Datanet retrieval for substance. Some look specialized because the adapter nudged the model away from generic nonsense. How much is that worth. No, really. How much.
That question is not decorative.
It decides rewards.
If the output fee moves through OPEN, if the adapter path gets credited, if Proof of Attribution assigns influence, then this little inference-time specialization becomes an economic event. Not after the fact. During the answer. While the user is just trying to get a response and the system is quietly building a receipt behind the curtain.
That receipt better be good.
Because later someone will not ask politely. They will open the inference record and ask why this adapter got credit, why that Datanet showed up, why one contributor was in the trail and another vanished. Very calm meeting, I’m sure.
Because the adapter is easy to underestimate. It is not the whole model. It is not the whole dataset. It is not even always visible to the user. It is the narrow layer that made the answer less stupid at the exact moment stupidity would have been expensive.
I have seen this kind of thing in systems before. The temporary layer gets treated as convenience until someone realizes the temporary layer made the final decision usable. Then everyone goes back and asks why the logs did not treat it like a first-class actor.
Same mood here.
If OpenLedger's OpenLoRA lets a model become specific on demand, then OpenLedger has to make that specificity accountable on demand too.
Otherwise the clean output starts hiding the adapter debt.
And that is not a small problem.
A Datanet can contain the domain knowledge. ModelFactory can help produce the fine-tuned adapter. OpenLoRA can serve it efficiently. Proof of Attribution can try to trace who influenced the output. OPEN can settle usage and rewards. Each layer solves something real.
Then together they create the worse question.
When intelligence is assembled only for the moment, what does ownership even attach to?
The adapter file. The training run. The Datanet. The contributor record. The inference event. The output. The user payment. Pick one. Wrong already.
That is why this does not feel like a normal deployment feature to me. It feels like OpenLedger is turning every specialized answer into a small custody problem over influence.
The answer used this adapter.
The adapter came from this training path.
The training path touched this Datanet. Alright alright...
The Datanet came from these contributors.
The user paid for the result. Fine.
OpenLedger system now has to remember the sequence without pretending the sequence was simpler than it was.
Cute.
Very scalable until someone asks why their contribution earned less than the adapter that compressed it into behavior.
And maybe the system has a good answer. Maybe Proof of Attribution can weight it cleanly. Maybe usage history makes the split defensible. Maybe contributor reputation and Datanet lineage on OpenLedger make the training record strong enough. Maybe the adapter creator really did create the important transformation.
Maybe.
That word again.
Always standing near the expensive part.
The sharper tradeoff is that OpenLoRA makes specialized inference cheaper and more flexible, but it also multiplies the number of moments that need attribution. A full model sitting there has one kind of ownership story. A base model plus constantly loaded adapters has another. More dynamic. More efficient. Also more annoying.
Because every temporary specialization leaves a question behind.
Who made that answer better.
Not broadly.
Specifically.
And on OpenLedger, this is where OpenLoRA stops being just deployment tech. The adapter path touches Datanets, ModelFactory training records, Proof of Attribution, inference receipts, and OPEN rewards flow. So the temporary specialization does not stay temporary in the economy. It becomes something the system may have to remember, price, defend, and pay. Cute little adapter. Very persistent paperwork.
Still.
Once OpenLoRA makes intelligence modular, the reward trail has to become modular too.
That sounds neat until the output is already served, the adapter has unloaded, the user is gone, and the system still has to keep a clean enough memory of who shaped that moment.
Base model there.
Adapter there.
Datanet behind it.
Contributor trail behind that.
OPEN moving because the answer was useful enough to pay for.
Fine.
Now make that readable six weeks later when someone asks why this adapter earned, why that Datanet mattered, why one contributor showed up in the trail and another did not.
That is the part that keeps bothering me.
Not the adapter loading.
The forgetting after it.
OpenLoRA can make intelligence feel temporary. OpenLedger cannot afford to let the evidence feel temporary too.
Because the adapter may leave the inference path.
But the claim it created is still sitting there.
Small. Paid. Traceable.
And waiting for someone to ask why that answer owed money to the thing that was only loaded for a moment.
Unload the adapter. Keep the argument.
$PROMPT $PLAY

I keep getting stuck on the upload part with @OpenLedger
Not because uploading data into a Datanet sounds hard.
It sounds too easy.
That is the annoying part.
Upload complete. Metadata clean. Datanet record sitting there like the job is done. Alright... Thats the lie I keep staring at.
A contributor finds a niche dataset, cleans it, formats it, attaches whatever metadata the workflow asks for, pushes it into a OpenLedger Datanet, and now everyone wants to act like the value has arrived. Data contributed. Record created. Nice little on-chain moment. Very civilized. Put it in the dashboard and let the human feel useful for six seconds.
But OpenLedger does not really make that simple.
It can't.
Because a Datanet is not supposed to be a museum shelf for uploaded files. It is supposed to become a usable data supply for AI models, fine-tuning flows, retrieval paths, and later inference. That means the upload is only the first claim. Not the proof. Not the payoff. Not even the interesting part, honestly.
The interesting part starts later, when the model actually needs something.
That is where the clean contribution story starts getting rough.
I keep picturing some contributor joining a finance-focused Datanet. Maybe they upload transaction labels, protocol risk notes, cleaned market structure data, liquidation examples, whatever the Datanet is built to collect. Looks useful. Probably is useful. The contribution lands. Metadata looks fine. Maybe reputation improves a little. The interface says the data is there.
Maybe the Datanet history even looks clean. Upload hash, category, contributor ID, timestamp. All the little boxes humans love because boxes make uncertainty look employed.
Good.
Now what.
Because on OpenLedger, the real question is not only “who uploaded data.” The real question is whether that data later shaped a model, helped a response, improved retrieval, influenced fine-tuning, or became part of a payable AI output. OpenLedger's Proof of Attribution makes that distinction harder to ignore. It does not let contribution stay as a soft emotional claim. It asks whether the data actually mattered when the system produced value.
And that is a very different kind of pressure.
That is where I stop trusting the easy version.
Most AI platforms blur this completely. They swallow data, train something somewhere, produce answers, and nobody can tell which original inputs carried weight. Everyone donated to the machine. The machine got rich. Cute arrangement. Very Web2. Very polite theft with nicer infrastructure.
Fine. Great even...
OpenLedger is trying to make the trail visible. Datanets hold the data layer. Proof of Attribution tracks the influence. ModelFactory can pull approved datasets into fine-tuning. Then retrieval paths, inference events, and reward logic start touching the same record. Not in a pretty diagram way. In a who actually earned here way, OPEN sits under that as gas, inference payment, settlement, contributor reward flow.
That sounds clean when listed.
It gets less clean when you put a person inside it.
Because the contributor does not experience “attribution-native AI economy.” Nobody normal wakes up and says that unless they are trapped in a pitch deck. The contributor experiences waiting. They uploaded something. Maybe it was accepted. Maybe the Datanet needed it. Maybe a model builder picked that Datanet later. Maybe the model used that data enough to matter. Maybe an inference event touched the influence trail. Maybe the reward arrived.
Maybe.
That word does a lot of damage.
This is where OpenLedger gets interesting to me. Not at “data ownership,” because that phrase has been beaten to death and then used in three more decks. The real thing is delayed proof of usefulness. Data does not earn just because it exists on-chain. It earns when the system can connect it to actual model value.
Which means the Datanet contributor is not just uploading.
They are waiting for the data to survive contact with the model.
That sounds small. It is not.
If a Datanet is full of domain-specific data, not every contribution will carry the same value. Some data will be redundant. Some will be too stale. Some will look clean but fail once it enters a training path. Some will help in one narrow retrieval context and do nothing elsewhere. Some might become very useful later because a model starts needing exactly that edge case. Great. Now the value of the contribution is not fully known at upload time.
So the upload becomes a kind of unpaid claim against future usefulness.
Lovely.
That is where Proof of Attribution starts looking less like a reward feature and more like a delayed judgment system.
A contributor can say, “I provided data.” OpenLedger has to ask, “Did the model use it.” Then maybe, “How much did it influence the output.” Then maybe, “Was that influence useful or noisy.” Then maybe, “Should this contributor earn from the inference fee, the model usage, the Datanet reward path, or basically nothing because the data only looked useful before the model touched it.”
That is a lot of machinery hiding behind the friendly word contribution.
And yes, that is probably the point.
The AI data economy does not need another place where everyone dumps files and calls it decentralization. We already have enough digital landfills with governance tokens standing nearby looking important. OpenLedger’s harder claim is uglier: data should not get paid just because it showed up. It has to matter inside the AI workflow.
Datanets make the contribution visible.
Proof of Attribution makes the influence harder to dodge.
Okay..... OpenLedger's ModelFactory makes the data usable by builders instead of leaving it as dead inventory.
Then inference makes the whole thing expensive enough for everyone to start caring.
That chain matters.
But it also makes the contributor’s position stranger.
Because now they are not only competing to upload. They are competing to be useful later, inside a model behavior they do not fully control. A builder might select one Datanet over another. A fine-tuning workflow might use a subset. A retrieval system might pull from certain entries more often. A model might lean on one contributor’s data heavily for a while, then less after updates, new Datanet entries, or better sources arrive.
The contributor’s value can decay quietly.
That one bothers me more than the upload delay.
Not because they did anything wrong.
Because usefulness moved.
That is the part people skip when they talk about monetizing data like it is passive income with cleaner branding. OpenLedger can make attribution more transparent, but it also makes the distance between “I uploaded” and “I earned” much harder to pretend away.
I keep coming back to the dashboard moment.
Some contributor checks their Datanet history. Contribution accepted. Metadata there. Maybe the record is clean. Maybe reputation is not bad. But the reward line is thin because the data has not influenced much yet. Or worse, it influenced once, then stopped. Another contributor’s data became more useful. Another Datanet gained better coverage. A model builder changed the training set. The inference path stopped touching that source.
Nothing broke.
That is the ugly part.
The OpenLedger system can be working exactly as designed and still make the contributor feel like the contribution is stuck in some waiting room between ownership and value.
That waiting room is OpenLedger-native.
It exists because the project is not just recording uploads. It is trying to price influence. And influence is a nastier object than data. Data can sit in a Datanet. Influence has to show up later, through training, retrieval, inference, output quality, reward logic, and whatever model path actually used the thing.
So the Datanet becomes more than a data pool.
It becomes a pressure surface.
A place where contributors learn that ownership is not enough. Clean formatting is not enough. Being early is not enough. Even being accepted is not enough.
The model has to need you.
And when it does, Proof of Attribution on OpenLedger has to catch that need cleanly enough to turn it into payment.
That is where $OPEN becomes more than a campaign tag. In the useful version of this system, OPEN is moving through the parts where AI usage becomes settlement: inference fees, Datanet usage, contributor rewards, model access, network gas. Not as decoration. As the accounting language under the AI contribution economy.
Still.
That does not make the human side neat.
A contributor can be right about their data and still early. Useful and still underused. Accepted and still unpaid. Valuable in one model path and invisible in another. The contribution can exist before the value event arrives, and that gap is where the whole thing starts feeling less like upload-and-earn and more like waiting for a model to admit it needed you.
That is probably the more honest version of OpenLedger.
Not “your data gets paid.”
Too clean.
More like: your data gets a chance to become payable if the system can prove it mattered after the model actually used it.
That is harsher.
Also better.
Because AI has been pretending inputs do not matter for too long. OpenLedger pushes against that by making Datanets, attribution trails, and contributor rewards part of the AI workflow instead of pretending the answer appeared from nowhere like a magic trick with cloud invoices.
But once you make contribution traceable, you also make disappointment traceable.
The contributor can see the upload. The Datanet can hold the record. The model can produce the answer. Proof of Attribution can follow the influence trail. The reward logic can split whatever value showed up.
And then someone still has to stare at the thin reward line and realize their data existed cleanly, behaved properly, passed through the system, and still did not become important enough to pay.
Not useless.
Not rejected.
Just not needed yet.
Which is somehow worse, because the record is clean on OpenLedger, the Datanet accepted it, Proof of Attribution is waiting for usage, and the contributor is still staring at a contribution that has not become important enough to owe them anything.
Yet.
$RONIN $PLAY
#OpenLedger #openledger