OriginTrail
  • Get started with OriginTrail
  • OriginTrail Ecosystem — Call for Papers (Coming Soon)
  • Key Concepts
    • Decentralized Knowledge Graph (DKG)
    • DKG key concepts
  • Build with DKG
    • Quickstart (test drive the DKG in 5 mins)
      • Quickstart with Node.js
      • Quickstart with Python
    • ChatDKG builder toolkit
      • DKG SDK
        • Development environment setup
        • DKG Javascript SDK (dkg.js)
          • Interact with DKG paranets
          • Knowledge submission & curation
          • Paranet's incentives pool implementation
        • DKG Python SDK (dkg.py)
      • DKG paranets
        • Deploying a DKG paranet
        • Building with DKG paranets
        • Syncing a DKG Paranet
        • Initial Paranet Offerings (IPOs)
          • IPO specification
          • Launching your IPO
          • Paranet's incentives pool
          • IPO voting
      • AI agents
        • ElizaOS DKG agent
        • Custom DKG Python agent
        • Custom DKG JavaScript agent
    • DKG Edge Node
      • DKG Edge Node architecture
      • Get started with the Edge Node boilerplate
        • Automated setup with the installer
        • Manual setup
        • Usage example
      • Customize & build with the Edge Node
      • Knowledge Mining and dRAG examples
      • Deploy your Edge Node based project
        • Automated deployment with installer
      • DKG Edge Node inception program
      • DKG Edge Node API documentation
    • DKG Core Node
      • Run a V8 Core Node on testnet
        • Preparation for V8 DKG Core Node deployment
        • V8 DKG Core Node installation
      • Run a V8 Core Node on mainnet
        • Preparation for V8 DKG Core Node deployment
        • V8 DKG Core Node installation
  • Delegated staking
    • Delegated staking—Introduction
      • Step-by-step staking
      • Redelegating stake
  • Integrated Blockchains
    • Base blockchain
      • Connect to Base
    • Gnosis chain
      • Connect to Gnosis
    • NeuroWeb
    • Teleport instructions - NeuroWeb
    • Bridging to Moonbeam
    • Deployed smart contracts
  • Bounties & rewards
    • General bug bounty
    • Code contributions & V8 bug bounty
  • Whitepapers & RFCs
    • OriginTrail whitepaper
    • OriginTrail RFCs
  • Useful Resources
    • What's new with OriginTrail V8
    • DKG V8 guidebook
      • Protocol updates
      • Feature roadmap
      • How to upgrade to V8?
    • Public nodes
    • Tutorials
    • Test token faucet
    • Development principles
    • Community created resources
    • Linked data & knowledge graphs
    • Available networks, network details and RPCs
    • OT Node Engine implementation details
      • Modules
      • Command Executor
    • Contribution guidelines
      • Guidelines for automated test contributions
    • Explore the OriginTrail ecosystem
Powered by GitBook
On this page
  • Adding a curator
  • Staging — Submitting KC to a paranet
  • Reviewing and approving KC
  • Conclusion

Was this helpful?

Edit on GitHub
  1. Build with DKG
  2. ChatDKG builder toolkit
  3. DKG SDK
  4. DKG Javascript SDK (dkg.js)

Knowledge submission & curation

PreviousInteract with DKG paranetsNextParanet's incentives pool implementation

Last updated 1 month ago

Was this helpful?

Staging Paranet is the process of submitting a Knowledge Collection (KC) for approval before it becomes part of the paranet. Curators review and either approve or reject the KC to ensure data accuracy and quality before it's added to the network.

Knowledge collection(KC) is a collection of knowledge assets. It refers to structured data that can be stored, shared, and validated within a distributed network.

In order to maintain data integrity and prevent malicious or irrelevant information from being added, the paranet system includes permission controls that regulate who can submit and approve new data entries.

Here's the demo code for a .

Why is KC management important?

In decentralized networks, anyone can technically contribute data, but not all data should be trusted. Without a system for validation, there is a risk of:

  • Spam or false data being introduced into the network.

  • Duplicate or low-quality data reducing the efficiency and reliability of the system.

  • Unauthorized modifications that could disrupt the credibility of shared knowledge.

To prevent these issues, paranet uses a curator-based system, where only authorized users (curators) can decide which knowledge assets get added to the network.

How does KC submission work?

  1. A miner creates a collection of knowledge assets(KC) — This is structured data (e.g., city information, scientific research, metadata, etc.) that is prepared for submission.

  2. The KC is staged to the paranet — This means it is submitted for approval but is not yet officially part of the paranet.

  3. A curator reviews the submission — The curator has the authority to either accept or reject the KC.

  4. If approved, the KC is officially submitted and becomes part of the paranet network. If rejected, the KC does not get added, and the user must make changes or submit a different KC.

This structured approach ensures that only reliable and relevant data is added to the network while maintaining a decentralized governance model.

When creating a paranet, we can define permissions for:

Adding a curator

A curator is a user who decides which collection of knowledge assets (KC) are accepted or rejected. Curators are added using their address, and they control the approval of new data within the Paranet.

Add a curator:

DkgClient.paranet.addCurator(paranetUAL, PUBLIC_KEY);

Remove a curator:

DkgClient.paranet.removeCurator(paranetUAL, PUBLIC_KEY);

Check if a user is a curator:

isCurator = await DkgClient.paranet.isCurator(paranetUAL, PUBLIC_KEY);
console.log('Is user a curator?', isCurator);

Staging — Submitting KC to a paranet

When a knowledge collection (KC) is staged, it must go through the staging process before being officially added to the paranet. This means the KC is submitted for review, and the curator decides whether to accept or reject it.

Create a new knowledge collection(collection of knowledge assets):

jsCopyEditconst content = {
    public: {
        '@context': 'https://www.schema.org',
        '@id': 'urn:us-cities:info:dallas',
        '@type': 'City',
        name: 'Dallas',
        state: 'Texas',
        population: '1,343,573',
        area: '386.5 sq mi',
    }
};

const createKcResult = await DkgClient.asset.create(content, { epochsNum: 2 });
console.log('Knowledge Collection Created:', createKcResult);

Stage KC to the paranet (submit for approval):

stageToParanetResult = await DkgClient.paranet.stageKnowledgeCollection(
    createKcResult.UAL,
    paranetUAL,
);
console.log('Knowledge Collection Staged to Paranet:', stageToParanetResult);

Check if KC is staged for approval:

isStaged = await DkgClient.paranet.isKnowledgeCollectionStaged(createKcResult.UAL, paranetUAL);
console.log('Is KC staged to Paranet?', isStaged);

Reviewing and approving KC

A curator can accept or reject a knowledge collection:

Reject a KC:

DkgClient.paranet.reviewKnowledgeCollection(createKcResult.UAL, paranetUAL, false);
console.log('Knowledge Collection Rejected');

Accept a KC:

DkgClient.paranet.reviewKnowledgeCollection(createKcResult.UAL, paranetUAL, true);
console.log('Knowledge Collection Approved');

Check approval status:

approvalStatus = await DkgClient.paranet.getKnowledgeCollectionApprovalStatus(createKcResult.UAL, paranetUAL);
console.log('KC Approval Status:', approvalStatus);

Check if KC is registered:

isRegistered = await DkgClient.paranet.isKnowledgeCollectionRegistered(createKcResult.UAL, paranetUAL);
console.log('Is KC registered to Paranet?', isRegistered);

Conclusion

  • Curators manage which KC entries get accepted to a paranet. Users who wish to submit data to a paranet must go through the staging process.

The curator doesn't have to be human, it can also be an AI agent.

  • KC must first be submitted for approval, and then the curator can accept or reject it.

  • All operations are tied to the user's public key, enabling secure and decentralized data management. 🚀

staging paranet