IPFS

Add data to IPFS using Helia, store its content identifier in peaq storage, and retrieve it by CID. Covers node setup and JavaScript examples.

IPFS is a peer-to-peer protocol for storing and sharing files by content address. Every file gets a content identifier (CID) derived from its bytes, and anyone holding that CID can fetch the file from any node that has it.

Store IPFS data on peaq

This guide adds data to IPFS, writes the returned CID to peaq storage, and reads the data back through that CID.

Connect to IPFS

This guide uses Helia, an IPFS implementation that runs without a full IPFS daemon and works in the browser as well as in Node.

Install the two packages Helia needs:

• npm install helia - creates a Helia node.
• npm install @helia/unixfs - adds the unixfs filesystem on top of that node.

Import both packages, start a node, and create a filesystem for it:

import { createHelia } from 'helia';
import { unixfs } from '@helia/unixfs';

// create node
const helia = await createHelia();

// create filesystem
const fs = unixfs(helia);

Add data to the node:

// convert string to Uint8Array
const encoder = new TextEncoder();

const bytes = encoder.encode('Hello peaq data');

// adds bytes to node and receives a CID back (content identifier)
const cid = await fs.addBytes(bytes);

console.log('CID of the data added:', cid.toString());

The snippet encodes the string into bytes and adds it to the filesystem created above. Keep the returned CID: you need it to read the data back.

Retrieve data from the node

Read the data back with that CID:

// decoder converts Uint8Array to strings
const decoder = new TextDecoder()
let stored_data = ''

for await (const data of fs.cat(cid)) {
    stored_data += decoder.decode(data, {
    stream: true
  })
}

console.log('Read file contents from data store:', stored_data);

helia.stop();

Connect to peaq

Install the two packages the chain connection needs:

• npm install @polkadot/api - websocket provider, API client, and the keyring used to sign the storage transaction.
• npm install @peaq-network/types - peaq’s type definitions.

This example connects to the agung testnet:

import { ApiPromise, WsProvider, Keyring } from '@polkadot/api';
import { defaultOptions } from '@peaq-network/types';

const WSS_URL = 'wss://wss-async-agung.peaq.xyz';

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

Add the CID to peaq storage

Store the CID under an item type name:

const item_type = "user-data";
const keyring = new Keyring({ type: 'sr25519' });

// Add Alice to our keyring with a hard-derivation path.
// Can add agung funded wallet here with your substrate wallet's mnemonic phrase (recommended).
const UserPair = keyring.addFromUri('//Alice');

await api.tx.peaqStorage.addItem(item_type, cid).signAndSend(UserPair);

Build the storage key and retrieve the data

Install the two packages used to build the storage key:

• npm install @polkadot/util-crypto - decodeAddress and blake2AsHex.
• npm install @polkadot/util - byte and hex conversions.

The storage key is the blake2 hash of your decoded address concatenated with the item type. Read the CID back with that key, then fetch the data from IPFS:

import { decodeAddress, blake2AsHex } from '@polkadot/util-crypto';
import { u8aToU8a, u8aToHex, u8aConcat, hexToString } from "@polkadot/util";

// generate storage key
const storageKeyByteArray = [];
const decodedAddress = decodeAddress(UserPair.address, false, 42);
storageKeyByteArray.push(decodedAddress);

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

const key = u8aConcat(...storageKeyByteArray);

const storageKey = blake2AsHex(key, 256);

const val = await api.query.peaqStorage.itemStore(storageKey);

// convert u8a to hex to obtain data from peaq storage
var retrieved_cid = hexToString(val.toHex());

const decoder = new TextDecoder()
let stored_data = ''

for await (const data of fs.cat(retrieved_cid)) {
    stored_data += decoder.decode(data, {
    stream: true
    })
}

console.log('Read file contents from data store:', stored_data);

Putting it all together

The full script:

import { createHelia } from 'helia';
import { unixfs } from '@helia/unixfs';
import { ApiPromise, WsProvider, Keyring } from '@polkadot/api';
import { defaultOptions } from '@peaq-network/types';
import { decodeAddress, blake2AsHex } from '@polkadot/util-crypto';
import { u8aToU8a, u8aToHex, u8aConcat, hexToString} from "@polkadot/util";

const WSS_URL = 'wss://wss-async-agung.peaq.xyz';

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

// create node
const helia = await createHelia();

// create filesystem
const fs = unixfs(helia);

async function createAddHelia() {
    // convert string to Uint8Array
    const encoder = new TextEncoder();

    const bytes = encoder.encode('Hello peaq data');

    // adds bytes to node and receives a CID back (content identifier)
    const cid = await fs.addBytes(bytes);

    console.log('CID of the data added:', cid.toString());

    return cid;
}

async function peaqStorageAdd(item_type, cid){
    const keyring = new Keyring({ type: 'sr25519' });

    // Add Alice to our keyring with a hard-derivation path.
    // Can add agung funded wallet here with your substrate wallet's mnemonic phrase (recommended).
    const UserPair = keyring.addFromUri('//Alice');

    await api.tx.peaqStorage.addItem(item_type, cid).signAndSend(UserPair);

    return UserPair;
}

async function peaqStorageRetrieve(UserPair, item_type){
    // generate storage key
    const storageKeyByteArray = [];
    const decodedAddress = decodeAddress(UserPair.address, false, 42);
    storageKeyByteArray.push(decodedAddress);

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

    const key = u8aConcat(...storageKeyByteArray);

    const storageKey = blake2AsHex(key, 256);

    const val = await api.query.peaqStorage.itemStore(storageKey);

    // convert u8a to hex to obtain data from peaq storage
    var retrieved_cid = hexToString(val.toHex());

    return retrieved_cid
}

async function readHelia(returned_cid){
    // decoder converts Uint8Array to strings
    const decoder = new TextDecoder()
    let stored_data = ''

    for await (const data of fs.cat(returned_cid)) {
        stored_data += decoder.decode(data, {
        stream: true
        })
    }

    console.log('Read file contents from data IPFS store:\n', stored_data);
}

async function main() {
    const cid = await createAddHelia();
    const item_type = 'user-data-1';
    const UserPair = await peaqStorageAdd(item_type, cid);

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

    const returned_cid = await peaqStorageRetrieve(UserPair, item_type);
    await readHelia(returned_cid);

    // disconnect to terminate the process
    await helia.stop();
    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.

For more Helia usage, see the Helia examples.