Store and Retrieve Data on the Bulletin Chain¶

1. Navigate to the Bulletin Chain Console and click Connect to connect your wallet.

   

2. Go to the Faucet page and select the Storage Faucet tab.

3. Under Authorize Account, enter the desired number of Transactions and Bytes for your storage needs, then click Authorize Account.

   

4. Approve the transaction in your wallet extension. You should see a success confirmation.

   

5. To verify your authorization, switch to the Accounts tab to view your remaining transactions, bytes, and expiration block.

   

1. Navigate to the Upload page in the Bulletin Chain Console. You can see your account's storage usage and authorization quota on the right side panel.

   

2. Select the File tab, then drag and drop your image or click to browse. The UI shows the file name and size.

   

3. Leave the CID Configuration at the defaults (Blake2b-256 hash, Raw codec) unless you have specific requirements.

4. Click Upload to Bulletin Chain and approve the transaction in your wallet extension.

5. On success, the UI displays your CID, Block Number, and Transaction Index.

   

Use the Polkadot API (PAPI) to store an image programmatically — ideal for integrating into build scripts, CI pipelines, or dApp backends.

Environment Setup

1. Create and initialize a new project:

   mkdir bulletin-store-example && cd bulletin-store-example && \
   npm init -y && npm pkg set type=module
   

2. Install the required dependencies:

   npm install polkadot-api@2.0.1 @polkadot-labs/hdkd@0.0.28 @polkadot-labs/hdkd-helpers@0.0.29 multiformats
   

3. Fetch the Bulletin Chain metadata and generate typed descriptors:

   npx papi add bulletin -w wss://paseo-bulletin-rpc.polkadot.io
   

   This command connects to the Bulletin Chain RPC endpoint, downloads the chain metadata, and generates typed descriptors that provide full type safety for all pallet interactions.

Store an Image

Create a file named store-data.ts with the following content:

import { createClient } from 'polkadot-api';
import { getWsProvider } from 'polkadot-api/ws';
import { bulletin } from '@polkadot-api/descriptors';
import { sr25519CreateDerive } from '@polkadot-labs/hdkd';
import {
  DEV_PHRASE,
  entropyToMiniSecret,
  mnemonicToEntropy,
} from '@polkadot-labs/hdkd-helpers';
import { getPolkadotSigner } from 'polkadot-api/signer';
import { CID } from 'multiformats/cid';
import { readFile } from 'fs/promises';

// Bulletin Chain Polkadot TestNet RPC endpoint
const BULLETIN_RPC = 'wss://paseo-bulletin-rpc.polkadot.io';

// Path to the image you want to store
const FILE_PATH = 'INSERT_IMAGE_PATH';

async function main() {
  // Create the client connection
  const client = createClient(getWsProvider(BULLETIN_RPC));

  // Get the typed API for the Bulletin Chain
  const api = client.getTypedApi(bulletin);

  console.log('Connected to Bulletin Chain (Polkadot TestNet)');

  // Derive a signer from a mnemonic
  const miniSecret = entropyToMiniSecret(mnemonicToEntropy(DEV_PHRASE));
  const derive = sr25519CreateDerive(miniSecret);
  const hdkdKeyPair = derive('//Alice');
  const signer = getPolkadotSigner(
    hdkdKeyPair.publicKey,
    'Sr25519',
    hdkdKeyPair.sign
  );

  // Read the image to store
  const fileData = await readFile(FILE_PATH);
  console.log(`Read file: ${FILE_PATH} (${fileData.length} bytes)`);

  // Submit the store transaction
  // Note: the signing account must have an active authorization (see Get Authorization section)
  console.log('Submitting store transaction...');
  const result = await api.tx.TransactionStorage.store({
    data: new Uint8Array(fileData),
  }).signAndSubmit(signer);

  console.log(`Transaction included in block: ${result.block.hash}`);
  console.log(`Transaction index: ${result.block.index}`);

  // Check events for the Stored event containing the CID
  for (const event of result.events) {
    if (event.type === 'TransactionStorage' && event.value.type === 'Stored') {
      // Decode the raw CID bytes into a standard IPFS CID string
      const cid = CID.decode(event.value.value.cid);

      console.log('\nImage stored successfully!');
      console.log(`Index: ${event.value.value.index}`);
      console.log(`CID: ${cid.toString()}`);
      console.log(`\nRetrieve via IPFS gateway:`);
      console.log(`https://paseo-ipfs.polkadot.io/ipfs/${cid.toString()}`);
    }
  }

  // Disconnect the client
  client.destroy();
}

main().catch(console.error);

Run the script:

npx tsx store-data.ts

You should see output similar to:

1. Navigate to the Download page in the Bulletin Chain Console.

2. Choose a retrieval method:

   • P2P Connection: Connects directly to Bulletin Chain collator nodes (decentralized, recommended).
   • IPFS Gateway: Uses the Bulletin Chain's IPFS gateway at https://paseo-ipfs.polkadot.io.

3. Enter your CID in the "Fetch by CID" field — you can use either the bafk2bzace... format or the hex-encoded 0x0155a0e4... format.

4. Click Fetch Data to retrieve your content. The UI also generates a direct Gateway Link you can open in your browser.

   

https://paseo-ipfs.polkadot.io/ipfs/<CID>

You can retrieve data programmatically using the Bulletin Chain's IPFS gateway:

const cid = 'INSERT_CID';
const response = await fetch(`https://paseo-ipfs.polkadot.io/ipfs/${cid}`);
const data = await response.arrayBuffer();
console.log(`Retrieved ${data.byteLength} bytes`);

For production applications, the recommended decentralized approach is to connect directly to Bulletin Chain collator nodes using Helia (a lean IPFS implementation) and retrieve data via the CID over libp2p.

This method requires knowing the public multiaddresses of Bulletin Chain collator nodes. See the Bulletin Chain repository for Helia configuration examples and available collator endpoints.

1. Navigate to the Renew page in the Bulletin Chain Console.

2. Select your stored transaction from the Load from History dropdown, or manually enter the Block Number and Transaction Index.

   

3. Click Lookup Transaction to view the transaction details, including the content hash, size, and expiration status.

   

4. Click Renew Storage and approve the transaction in your wallet extension.

console.log('Renewing stored data...');
const result = await api.tx.TransactionStorage.renew({
  block: INSERT_BLOCK_NUMBER,
  index: INSERT_INDEX,
}).signAndSubmit(signer);
console.log(`Renewal included in block: ${result.block.hash}`);

You should see output similar to: