adding missing authorizeStorage in common.js

Author: rosarp

examples/common.js

@@ -13,6 +13,7 @@ import { cidFromBytes, buildUnixFSDagPB } from "./cid_dag_metadata.js";
 export const WS_ENDPOINT = 'ws://127.0.0.1:10000'; // Bulletin node
 export const IPFS_API = 'http://127.0.0.1:5001';   // Local IPFS daemon
 export const HTTP_IPFS_API = 'http://127.0.0.1:8080';   // Local IPFS HTTP gateway
+export const CHUNK_SIZE = 1 * 1024 * 1024; // 1 MB
 // -----------------
 
 function to_hex(input) {
@@ -51,7 +52,7 @@ export async function storeChunkedFile(api, pair, filePath, nonceMgr) {
       const tx = api.tx.transactionStorage.store(bytes);
       const result = await tx.signAndSend(pair, { nonce: nonceMgr.getAndIncrement() });
       console.log(`✅ Stored chunk #${i + 1}, result:`, result.toHuman?.());
-    } catch(err) {
+    } catch (err) {
       if (err.stack.includes("Immediately Dropped: The transaction couldn't enter the pool because of the limit")) {
         await waitForNewBlock();
         --i;
@@ -147,11 +148,11 @@ export async function storeMetadata(api, pair, chunks, nonceMgr) {
  * @returns {Promise<{ rootCid: CID, dagBytes: Uint8Array }>}
  */
 export async function buildUnixFSDag(metadataJson, mhCode = 0x12) {
-    // Extract chunk info
-    const chunks = metadataJson.chunks || []
-    if (!chunks.length) throw new Error('❌ metadataJson.chunks is empty')
+  // Extract chunk info
+  const chunks = metadataJson.chunks || []
+  if (!chunks.length) throw new Error('❌ metadataJson.chunks is empty')
 
-    return await buildUnixFSDagPB(chunks, mhCode);
+  return await buildUnixFSDagPB(chunks, mhCode);
 }
 
 /**
@@ -202,6 +203,30 @@ export async function storeProof(api, sudoPair, pair, rootCID, dagFileBytes, non
   return { rawDagCid }
 }
 
+export async function authorizeStorage(api, sudoPair, pair, nonceMgr) {
+  // Ensure enough quota.
+  const auth = await api.query.transactionStorage.authorizations({ "Account": pair.address });
+  console.log('Authorization info:', auth.toHuman());
+
+  if (!auth.isSome) {
+    console.log('ℹ️ No existing authorization found — requesting new one...');
+  } else {
+    const authValue = auth.unwrap().extent;
+    const transactions = authValue.transactions.toNumber();
+    const bytes = authValue.bytes.toNumber();
+
+    if (transactions > 10 && bytes > 24 * CHUNK_SIZE) {
+      console.log('✅ Account authorization is sufficient.');
+      return;
+    }
+  }
+
+  const transactions = 128;
+  const bytes = 64 * 1024 * 1024; // 64 MB
+  await authorizeAccount(api, sudoPair, pair.address, transactions, bytes, nonceMgr);
+  await waitForNewBlock();
+}
+
 export async function waitForNewBlock() {
   // TODO: wait for a new block.
   console.log('🛰 Waiting for new block...')
@@ -212,86 +237,86 @@ export async function waitForNewBlock() {
  * Creates a PAPI-compatible signer from a Keyring account
  */
 export function createSigner(account) {
-    return getPolkadotSigner(
-        account.publicKey,
-        'Sr25519',
-        (input) => account.sign(input)
-    );
+  return getPolkadotSigner(
+    account.publicKey,
+    'Sr25519',
+    (input) => account.sign(input)
+  );
 }
 
 export function setupKeyringAndSigners(sudoSeed, accountSeed) {
-    const keyring = new Keyring({ type: 'sr25519' });
-    const sudoAccount = keyring.addFromUri(sudoSeed);
-    const whoAccount = keyring.addFromUri(accountSeed);
-    
-    const sudoSigner = createSigner(sudoAccount);
-    const whoSigner = createSigner(whoAccount);
-    
-    return {
-        sudoSigner,
-        whoSigner,
-        whoAddress: whoAccount.address
-    };
+  const keyring = new Keyring({ type: 'sr25519' });
+  const sudoAccount = keyring.addFromUri(sudoSeed);
+  const whoAccount = keyring.addFromUri(accountSeed);
+
+  const sudoSigner = createSigner(sudoAccount);
+  const whoSigner = createSigner(whoAccount);
+
+  return {
+    sudoSigner,
+    whoSigner,
+    whoAddress: whoAccount.address
+  };
 }
 
 /**
  * Generates (dynamic) images based on the input text.
  */
 export function generateTextImage(file, text, width = 800, height = 600) {
-    const canvas = createCanvas(width, height);
-    const ctx = canvas.getContext("2d");
+  const canvas = createCanvas(width, height);
+  const ctx = canvas.getContext("2d");
 
-    // 🎨 Background
+  // 🎨 Background
+  ctx.fillStyle = randomColor();
+  ctx.fillRect(0, 0, width, height);
+
+  // 🟠 Random shapes
+  for (let i = 0; i < 15; i++) {
+    ctx.beginPath();
     ctx.fillStyle = randomColor();
-    ctx.fillRect(0, 0, width, height);
-
-    // 🟠 Random shapes
-    for (let i = 0; i < 15; i++) {
-        ctx.beginPath();
-        ctx.fillStyle = randomColor();
-        ctx.arc(
-            Math.random() * width,
-            Math.random() * height,
-            Math.random() * 120,
-            0,
-            Math.PI * 2
-        );
-        ctx.fill();
-    }
+    ctx.arc(
+      Math.random() * width,
+      Math.random() * height,
+      Math.random() * 120,
+      0,
+      Math.PI * 2
+    );
+    ctx.fill();
+  }
 
-    // ✍️ Draw your text
-    ctx.font = "bold 40px Sans";
-    ctx.fillStyle = "white";
-    ctx.textAlign = "center";
-    ctx.textBaseline = "middle";
+  // ✍️ Draw your text
+  ctx.font = "bold 40px Sans";
+  ctx.fillStyle = "white";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
 
-    // Add text with shadow for readability
-    ctx.shadowColor = "black";
-    ctx.shadowBlur = 8;
+  // Add text with shadow for readability
+  ctx.shadowColor = "black";
+  ctx.shadowBlur = 8;
 
-    ctx.fillText(text, width / 2, height / 2);
+  ctx.fillText(text, width / 2, height / 2);
 
-    let jpegBytes = canvas.toBuffer("image/jpeg");
-    fs.writeFileSync(file, jpegBytes);
-    console.log("Saved to file:", file);
+  let jpegBytes = canvas.toBuffer("image/jpeg");
+  fs.writeFileSync(file, jpegBytes);
+  console.log("Saved to file:", file);
 }
 
 function randomColor() {
-    return `rgb(${rand255()}, ${rand255()}, ${rand255()})`;
+  return `rgb(${rand255()}, ${rand255()}, ${rand255()})`;
 }
 
 function rand255() {
-    return Math.floor(Math.random() * 256);
+  return Math.floor(Math.random() * 256);
 }
 
 export function filesAreEqual(path1, path2) {
-    const data1 = fs.readFileSync(path1);
-    const data2 = fs.readFileSync(path2);
-    assert.deepStrictEqual(data1.length, data2.length)
+  const data1 = fs.readFileSync(path1);
+  const data2 = fs.readFileSync(path2);
+  assert.deepStrictEqual(data1.length, data2.length)
 
-    for (let i = 0; i < data1.length; i++) {
-        assert.deepStrictEqual(data1[i], data2[i])
-    }
+  for (let i = 0; i < data1.length; i++) {
+    assert.deepStrictEqual(data1[i], data2[i])
+  }
 }
 
 export async function fileToDisk(outputPath, fullBuffer) {