MongoDB

Store documents off chain in MongoDB and write their hashes to peaq storage. Compare document hashes with on-chain values to verify data integrity.

MongoDB is an open-source NoSQL database that stores JSON-like BSON documents. It suits large or loosely structured payloads that do not belong on chain.

peaq storage holds a 64-byte key and a 256-byte value, so anything larger lives in your own storage. For how the two layers divide the work, see On-chain vs Off-chain.

Prerequisites

• Node.js and npm installed.
• TypeScript and Node.js type declarations installed in your project:

npm install --save-dev typescript @types/node

• Atlas CLI for the Atlas setup in step 4. With Homebrew on macOS or Linux:

brew install mongodb-atlas-cli

For other operating systems, follow the Atlas CLI installation instructions.

Integration tutorial

Store the document in MongoDB and write its hash to peaq storage, keyed by the MongoDB document ID. Later you fetch the document from MongoDB, hash it again, and compare against the on-chain value to prove it was not altered.

1. Install the required packages

npm install mongodb @polkadot/api

2. Create a tsconfig.json file in your project directory

{
  "compilerOptions": {
    "target": "es2018",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "types": ["node"]
  }
}

3. Create a file named app.ts

import { MongoClient, Db, Collection, ObjectId } from 'mongodb';

class MongoDBStorage {
  private client: MongoClient;
  private db!: Db;
  private collection!: Collection;
  private collectionName: string;
  private dbName: string;

  constructor() {
    const connectionString = 'mongodb://localhost:27017';
    this.client = new MongoClient(connectionString);
    this.dbName = 'yourDataBaseName';
    this.collectionName = 'yourCollectionName';
  }

  async connect() {
    try {
      await this.client.connect();
      console.log('Connected successfully to MongoDB server');
      this.db = this.client.db(this.dbName);
      this.collection = this.db.collection(this.collectionName);
    } catch (error) {
      console.error('Error connecting to MongoDB:', error);
      throw error;
    }
  }

  async disconnect() {
    try {
      await this.client.close();
      console.log('Disconnected successfully from MongoDB server');
    } catch (error) {
      console.error('Error disconnecting from MongoDB:', error);
      throw error;
    }
  }

  async insertDocument(document: any) {
    try {
      const result = await this.collection.insertOne(document);
      console.log('Document inserted:', result);
      return result;
    } catch (error) {
      console.error('Error inserting document:', error);
      throw error;
    }
  }

  async findDocumentById(id: string) {
    const result = await this.collection.findOne({ _id: new ObjectId(id) });
    console.log('Found document by ID:', result);
    return result;
  }

  async updateDocument(id: string, update: any) {
    const result = await this.collection.updateOne({ _id: new ObjectId(id) }, { $set: update });
    console.log('Updated document:', result.modifiedCount);
    return result.modifiedCount > 0;
  }

  async deleteDocument(id: string) {
    const result = await this.collection.deleteOne({ _id: new ObjectId(id) });
    console.log('Deleted document:', result.deletedCount);
    return result.deletedCount > 0;
  }

}

export {MongoDBStorage}

4. Set up MongoDB

You can run MongoDB locally, in the cloud with Atlas, or serverless.

• Download MongoDB.
• Run atlas setup to create and configure an Atlas account. It prints your cluster name, cloud provider location, and admin username and password.
• For Atlas, replace mongodb://localhost:27017 in the step 3 code with your cluster’s mongodb+srv://<username>:<password>@<cluster-host>/ connection string (atlas setup prints the credentials; the Atlas UI shows the host). For a local MongoDB, keep mongodb://localhost:27017. The MongoDB documentation covers the format.
• Run npx tsc to compile the TypeScript, then rename the generated app.js to app.cjs. The next step imports the class from that file.

5. Connect to peaq

• Create a file named peaq.js in the same directory.
• Add "type": "module" to package.json.
• Paste the code below to open the peaq connection.

import { ApiPromise, WsProvider } from '@polkadot/api';
import { MongoDBStorage } from './app.cjs';
import { u8aToHex, u8aToU8a, u8aConcat } from "@polkadot/util";
import Keyring from "@polkadot/keyring";
import { decodeAddress, blake2AsHex } from '@polkadot/util-crypto';

// agung testnet. Swap in a peaq mainnet endpoint when you go live.
const WSS_URL = 'wss://wss-async-agung.peaq.xyz';
const OWNER_SEED = 'your funded account mnemonic';

const provider = new WsProvider(WSS_URL);
const api = await ApiPromise.create({ provider });

// creates a storage key to read data from chain
function createStorageKey(address, itemType) {
    const storageKeyByteArray = [];
    const decodedAddress = decodeAddress(address, false, 42);
    storageKeyByteArray.push(decodedAddress);

    const hashItemType = u8aToU8a(itemType);
    storageKeyByteArray.push(hashItemType);

    const key = u8aConcat(...storageKeyByteArray);

    const storageKey = blake2AsHex(key, 256);
    return storageKey
  }

// Store Big data in MongoDB, hash data on peaq Network, read to confirm data is the same
const main = async () => {
    // Data to store in MongoDB
    const data = "Hello World";

    // Store data in MongoDB
    const mongoDBStorage = new MongoDBStorage();
    await mongoDBStorage.connect();
    const insertedDocument = await mongoDBStorage.insertDocument({text: data});
    await mongoDBStorage.disconnect();

    // Hash data to store on chain
    const mongoID = insertedDocument.insertedId.toString();
    const storeHashData = blake2AsHex(data, 256);

    // Create wallet from seed of a user funded wallet
    const keyring = new Keyring({ type: 'sr25519' });
    const owner = keyring.addFromUri(OWNER_SEED);

    // Add to MongoDB id and hashed data to peaq storage
    await api.tx.peaqStorage.addItem(mongoID, storeHashData).signAndSend(owner);

    await sleep(30000); // Pause before reading; this delay does not guarantee inclusion.

    // Retrieve data from off-chain storage based on the id
    await mongoDBStorage.connect();
    const foundDocument = await mongoDBStorage.findDocumentById(mongoID);
    await mongoDBStorage.disconnect();

    const readId = foundDocument._id.toString();

    // Create a storage key and read hashed on-chain data storage
    const storageKey = createStorageKey(owner.address, readId);
    var onChainHashData = await api.query.peaqStorage.itemStore(storageKey);

    // Confirm the on-chain hash matches a fresh hash of the MongoDB document
    onChainHashData = onChainHashData.toHex();
    const hashData = blake2AsHex(foundDocument.text, 256);
    console.log(onChainHashData == hashData);

    await api.disconnect();
  }

  function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

main();

signAndSend without a status callback returns a transaction hash before inclusion. The fixed delay above is only a pause before reading. To wait for inclusion, use a signAndSend status callback, check dispatchError, and wait for status.isInBlock (or status.isFinalized for finality) before reading on-chain storage.

The script uses the MongoDBStorage class from step 3. The document goes into MongoDB, and its hash goes into peaq storage as the pair MongoDB_Id: Hashed_Data. Reading the document back and re-hashing it shows whether it still matches the on-chain record.