Add percenteage, refactor sync conditions

src/components/CoreSyncStatus.tsx

@@ -25,9 +25,7 @@ export const CoreSyncStatus = () => {
   useEffect(() => {
     const getNodeInfos = async () => {
       try {
-        setIsUsingGateway(
+        setIsUsingGateway(getBaseApiReact()?.includes('ext-node.qortal.link'));
-          !!getBaseApiReact()?.includes('ext-node.qortal.link')
-        );
         const url = `${getBaseApiReact()}/admin/status`;
         const response = await fetch(url, {
           method: 'GET',
@@ -82,27 +80,27 @@ export const CoreSyncStatus = () => {
       : '';
 
     let imagePath = syncingImg;
-    let message = t('core:minting.status.synchronizing', {
+    let message: string = '';
-      postProcess: 'capitalizeFirstChar',
-    });
 
-    if (isMintingPossible && !isUsingGateway) {
+    if (isUsingGateway) {
-      imagePath = syncedMintingImg;
-      message = `${t(`core:minting.status.${isSynchronizing ? 'synchronizing' : 'synchronized'}`, { postProcess: 'capitalizeFirstChar' })} ${t('core:minting.status.minting')}`;
-    } else if (isSynchronizing === true && syncPercent === 99) {
       imagePath = syncingImg;
-    } else if (isSynchronizing && !isMintingPossible && syncPercent === 100) {
+      message = `${t('core:minting.status.no_status')}`;
-      imagePath = syncingImg;
+    } else if (isMintingPossible) {
-      message = `${t('core:minting.status.synchronizing', { postProcess: 'capitalizeFirstChar' })} ${!isUsingGateway ? t('core:minting.status.not_minting') : ''}`;
+      if (isSynchronizing) {
-    } else if (!isSynchronizing && !isMintingPossible && syncPercent === 100) {
+        imagePath = syncingImg;
-      imagePath = syncedImg;
+        message = `${t(`core:minting.status.synchronizing`, { percent: syncPercent, postProcess: 'capitalizeFirstChar' })} ${t('core:minting.status.minting')}`;
-      message = `${t('core:minting.status.synchronized', { postProcess: 'capitalizeFirstChar' })} ${!isUsingGateway ? t('core:minting.status.not_minting') : ''}`;
+      } else {
-    } else if (isSynchronizing && isMintingPossible && syncPercent === 100) {
+        imagePath = syncedMintingImg;
-      imagePath = syncingImg;
+        message = `${t(`core:minting.status.synchronized`, { percent: syncPercent, postProcess: 'capitalizeFirstChar' })} ${t('core:minting.status.minting')}`;
-      message = `${t('core:minting.status.synchronizing', { postProcess: 'capitalizeFirstChar' })} ${!isUsingGateway ? t('core:minting.status.minting') : ''}`;
+      }
-    } else if (!isSynchronizing && isMintingPossible && syncPercent === 100) {
+    } else if (!isMintingPossible) {
-      imagePath = syncedMintingImg;
+      if (syncPercent == 100) {
-      message = `${t('core:minting.status.synchronized', { postProcess: 'capitalizeFirstChar' })} ${!isUsingGateway ? t('core:minting.status.minting') : ''}`;
+        imagePath = syncedImg;
+        message = `${t(`core:minting.status.synchronized`, { percent: syncPercent, postProcess: 'capitalizeFirstChar' })} ${t('core:minting.status.not_minting')}`;
+      } else {
+        imagePath = syncingImg;
+        message = `${t(`core:minting.status.synchronizing`, { percent: syncPercent, postProcess: 'capitalizeFirstChar' })} ${t('core:minting.status.not_minting')}`;
+      }
     }
 
     return (

src/components/Group/Forum/ReadOnlySlate.tsx

@@ -96,6 +96,7 @@ interface ReadOnlySlateProps {
   content: any;
   mode?: string;
 }
+
 const ReadOnlySlate: FC<ReadOnlySlateProps> = ({ content, mode }) => {
   const [load, setLoad] = useState(false);
   const editor = useMemo(() => withReact(createEditor()), []);
@@ -103,11 +104,15 @@ const ReadOnlySlate: FC<ReadOnlySlateProps> = ({ content, mode }) => {
 
   const performUpdate = useCallback(async () => {
     setLoad(true);
-    await new Promise<void>((res) => {
+    try {
-      setTimeout(() => {
+      await new Promise<void>((res) => {
-        res();
+        setTimeout(() => {
-      }, 250);
+          res();
-    });
+        }, 250);
+      });
+    } catch (error) {
+      console.log(error);
+    }
     setLoad(false);
   }, []);
   useEffect(() => {

src/components/Minting/Minting.tsx

@@ -698,10 +698,14 @@ export const Minting = ({ setIsOpenMinting, myAddress, show }) => {
                       label={t('core:minting.average_blocktime', {
                         postProcess: 'capitalizeEachFirstChar',
                       })}
-                      value={averageBlockTime(
+                      value={t('core:time.second', {
-                        adminInfo,
+                        count: parseFloat(
-                        nodeHeightBlock
+                          averageBlockTime(adminInfo, nodeHeightBlock).toFixed(
-                      ).toFixed(2)}
+                            2
+                          )
+                        ),
+                        postProcess: 'capitalizeEachFirstChar',
+                      })}
                     />
 
                     <StatCard

src/components/Minting/MintingStats.tsx

@@ -299,7 +299,7 @@ export const countRewardDay = (
       );
       return countRewardDay34;
     } else if (level === 5 || level === 6) {
-      if (this.tier4Online < 30) {
+      if (tier4Online < 30) {
         const countRewardDay56 = parseFloat(
           (
             (((blockReward(nodeStatus) / 100) *
@@ -324,7 +324,7 @@ export const countRewardDay = (
         return countRewardDay56;
       }
     } else if (level === 7 || level === 8) {
-      if (this.tier4Online < 30) {
+      if (tier4Online < 30) {
         const countRewardDay78 = parseFloat(
           (
             (((blockReward(nodeStatus) / 100) *
@@ -368,7 +368,6 @@ export const mintingStatus = (nodeStatus): string => {
     nodeStatus.isMintingPossible === true &&
     nodeStatus.isSynchronizing === true
   ) {
-    // this.cssMinting = 'blue';
     return i18n.t('core:minting.status.minting', {
       postProcess: 'capitalizeFirstChar',
     });
@@ -376,7 +375,6 @@ export const mintingStatus = (nodeStatus): string => {
     nodeStatus.isMintingPossible === true &&
     nodeStatus.isSynchronizing === false
   ) {
-    // this.cssMinting = 'blue';
     return i18n.t('core:minting.status.minting', {
       postProcess: 'capitalizeFirstChar',
     });
@@ -384,7 +382,6 @@ export const mintingStatus = (nodeStatus): string => {
     nodeStatus.isMintingPossible === false &&
     nodeStatus.isSynchronizing === true
   ) {
-    // this.cssMinting = 'red';
     return i18n.t('core:minting.status.synchronizing', {
       postProcess: 'capitalizeFirstChar',
     }) +
@@ -396,7 +393,6 @@ export const mintingStatus = (nodeStatus): string => {
     nodeStatus.isMintingPossible === false &&
     nodeStatus.isSynchronizing === false
   ) {
-    // this.cssMinting = 'red';
     return i18n.t('core:minting.status.not_minting', {
       postProcess: 'capitalizeFirstChar',
     });

src/encryption/kdf.ts

@@ -1,100 +1,110 @@
 // @ts-nocheck
 
-import {bytes_to_base64 as bytesToBase64, Sha512} from 'asmcrypto.js'
+import { bytes_to_base64 as bytesToBase64, Sha512 } from 'asmcrypto.js';
-import utils from '../utils/utils'
+import utils from '../utils/utils';
-import { crypto as crypto2 } from '../constants/decryptWallet'
+import { crypto as crypto2 } from '../constants/decryptWallet';
 import BcryptWorker from './bcryptworker.worker.js?worker';
 
-const stringtoUTF8Array = (message)=> {
+const stringtoUTF8Array = (message) => {
-    if (typeof message === 'string') {
+  if (typeof message === 'string') {
-        var s = unescape(encodeURIComponent(message)) // UTF-8
+    var s = unescape(encodeURIComponent(message)); // UTF-8
-        message = new Uint8Array(s.length)
+    message = new Uint8Array(s.length);
-        for (var i = 0; i < s.length; i++) {
+    for (var i = 0; i < s.length; i++) {
-            message[i] = s.charCodeAt(i) & 0xff
+      message[i] = s.charCodeAt(i) & 0xff;
-        }
     }
-    return message
+  }
-}
+  return message;
-
+};
-
 
 const bcryptInWorker = (hashBase64, salt) => {
   return new Promise((resolve, reject) => {
-      const worker = new BcryptWorker()
+    const worker = new BcryptWorker();
-      worker.onmessage = (e) => {
+    worker.onmessage = (e) => {
-          const { result, error } = e.data;
+      const { result, error } = e.data;
-          if (error) {
+      if (error) {
-              reject(error);
+        reject(error);
-          } else {
+      } else {
-              resolve(result);
+        resolve(result);
-          }
+      }
-          worker.terminate();
+      worker.terminate();
-      };
+    };
-      worker.onerror = (err) => {
+    worker.onerror = (err) => {
-          reject(err.message);
+      reject(err.message);
-          worker.terminate();
+      worker.terminate();
-      };
+    };
-      worker.postMessage({ hashBase64, salt });
+    worker.postMessage({ hashBase64, salt });
   });
 };
 
+const stringToUTF8Array = (message) => {
+  if (typeof message !== 'string') return message; // Assuming you still want to pass through non-string inputs unchanged
+  const encoder = new TextEncoder(); // TextEncoder defaults to UTF-8
+  return encoder.encode(message);
+};
 
-const stringToUTF8Array=(message)=> {
+const computekdf = async (req) => {
-    if (typeof message !== 'string') return message; // Assuming you still want to pass through non-string inputs unchanged
+  const { salt, key, nonce, staticSalt, staticBcryptSalt } = req;
-    const encoder = new TextEncoder(); // TextEncoder defaults to UTF-8
+  const combinedBytes = utils.appendBuffer(
-    return encoder.encode(message);
+    new Uint8Array([]),
-}
+    stringToUTF8Array(`${staticSalt}${key}${nonce}`)
-const computekdf = async (req)=> {
+  );
-    const { salt, key, nonce, staticSalt, staticBcryptSalt } = req
-    const combinedBytes = utils.appendBuffer(new Uint8Array([]), stringToUTF8Array(`${staticSalt}${key}${nonce}`))
 
-    const sha512Hash = new Sha512().process(combinedBytes).finish().result
+  const sha512Hash = new Sha512().process(combinedBytes).finish().result;
-    const sha512HashBase64 = bytesToBase64(sha512Hash)
+  const sha512HashBase64 = bytesToBase64(sha512Hash);
 
-    const result = await bcryptInWorker(sha512HashBase64.substring(0, 72), staticBcryptSalt);
+  const result = await bcryptInWorker(
-    return { key, nonce, result }
+    sha512HashBase64.substring(0, 72),
-}
+    staticBcryptSalt
+  );
+  return { key, nonce, result };
+};
 
 export const doInitWorkers = (numberOfWorkers) => {
-    const workers = []
+  const workers = [];
 
-        try {
+  try {
-            for (let i = 0; i < numberOfWorkers; i++) {
+    for (let i = 0; i < numberOfWorkers; i++) {
-                workers.push({})
+      workers.push({});
-            }
+    }
+  } catch (e) {}
 
-        } catch (e) {
+  return workers;
-        }
+};
-  
-    return workers
-}
 
 export const kdf = async (seed, salt, threads) => {
-	const workers = threads
+  const workers = threads;
-    const salt2 = 	new Uint8Array(salt)
+  const salt2 = new Uint8Array(salt);
 
-	salt = new Uint8Array(salt)
+  salt = new Uint8Array(salt);
-	const seedParts = await Promise.all(workers.map((worker, index) => {
+  const seedParts = await Promise.all(
-		const nonce = index
+    workers.map((worker, index) => {
-		return computekdf({
+      const nonce = index;
-			key: seed,
+      return computekdf({
-			salt,
+        key: seed,
-			nonce,
+        salt,
-			staticSalt: crypto2.staticSalt,
+        nonce,
-			staticBcryptSalt: crypto2.staticBcryptSalt
+        staticSalt: crypto2.staticSalt,
-		}).then(data => {
+        staticBcryptSalt: crypto2.staticBcryptSalt,
-			let jsonData
+      }).then((data) => {
-			try {
+        let jsonData;
-				jsonData = JSON.parse(data)
+        try {
-				data = jsonData
+          jsonData = JSON.parse(data);
-			} catch (e) {
+          data = jsonData;
-				// ...
+        } catch (e) {
-			}
+          // ...
-			// if (seed !== data.key) throw new Error(kst3 + seed + ' !== ' + data.key)
+        }
-			// if (nonce !== data.nonce) throw new Error(kst4)
+        // if (seed !== data.key) throw new Error(kst3 + seed + ' !== ' + data.key)
-			return data.result
+        // if (nonce !== data.nonce) throw new Error(kst4)
-		})
+        return data.result;
-	}))
+      });
-	const result = new Sha512().process(stringtoUTF8Array(crypto2.staticSalt + seedParts.reduce((a, c) => a + c))).finish().result
+    })
-	return result
+  );
-}
+
+  const result = new Sha512()
+    .process(
+      stringtoUTF8Array(crypto2.staticSalt + seedParts.reduce((a, c) => a + c))
+    )
+    .finish().result;
+
+  return result;
+};

src/i18n/locales/de/core.json

@@ -334,8 +334,8 @@
       "minting": "(Prägung)",
       "not_minting": "(nicht punktieren)",
       "no_status": "kein Status",
-      "synchronized": "synchronisiert",
+      "synchronized": "synchronisiert ({{ percent }}%)",
-      "synchronizing": "Synchronisierung..."
+      "synchronizing": "Synchronisierung ({{ percent }}%)..."
     },
     "status_title": "Münzstatus",
     "tier_share_per_block": "Stufenanteil pro Block",

src/i18n/locales/en/core.json

@@ -336,8 +336,8 @@
       "minting": "(minting)",
       "not_minting": "(not minting)",
       "no_status": "no status",
-      "synchronized": "synchronized",
+      "synchronized": "synchronized ({{ percent }}%)",
-      "synchronizing": "synchronizing..."
+      "synchronizing": "synchronizing ({{ percent }}%)..."
     },
     "status_title": "minting status",
     "tier_share_per_block": "tier share per block",
@@ -399,6 +399,8 @@
     "hour_other": "{{count}} hours",
     "minute_one": "{{count}} minute",
     "minute_other": "{{count}} minutes",
+    "second_one": "{{count}} second",
+    "second_other": "{{count}} seconds",
     "time": "time"
   },
   "title": "title",

src/i18n/locales/es/core.json

@@ -335,8 +335,8 @@
       "minting": "(acuñado)",
       "not_minting": "(no acuñar)",
       "no_status": "sin estado",
-      "synchronized": "sincronizado",
+      "synchronized": "sincronizado ({{ percent }}%)",
-      "synchronizing": "sincronización..."
+      "synchronizing": "sincronización ({{ percent }}%)..."
     },
     "status_title": "estado de acuñación",
     "tier_share_per_block": "porción del nivel por bloque",

src/i18n/locales/fr/core.json

@@ -335,8 +335,8 @@
       "minting": "(Frappe)",
       "not_minting": "(pas de la frappe)",
       "no_status": "pas de statut",
-      "synchronized": "synchronisé",
+      "synchronized": "synchronisé ({{ percent }}%)",
-      "synchronizing": "synchronisation..."
+      "synchronizing": "synchronisation ({{ percent }}%)..."
     },
     "status_title": "statut de frappe",
     "tier_share_per_block": "part du niveau par bloc",

src/i18n/locales/it/core.json

@@ -334,8 +334,8 @@
       "minting": "(minting)",
       "not_minting": "(non minting)",
       "no_status": "nessun stato",
-      "synchronized": "sincronizzato",
+      "synchronized": "sincronizzato ({{ percent }}%)",
-      "synchronizing": "sincronizzazione..."
+      "synchronizing": "sincronizzazione ({{ percent }}%)..."
     },
     "status_title": "stato minting",
     "tier_share_per_block": "quota della fascia per blocco",

src/i18n/locales/ja/core.json

@@ -335,8 +335,8 @@
       "minting": "（鋳造）",
       "not_minting": "（造りではありません）",
       "no_status": "ステータスなし",
-      "synchronized": "同期",
+      "synchronized": "同期 ({{ percent }}%)",
-      "synchronizing": "同期..."
+      "synchronizing": "同期 ({{ percent }}%)..."
     },
     "status_title": "ミントステータス",
     "tier_share_per_block": "ブロックごとのティアシェア",

src/i18n/locales/ru/core.json

@@ -335,8 +335,8 @@
       "minting": "(добыча)",
       "not_minting": "(не шахта)",
       "no_status": "нет статуса",
-      "synchronized": "синхронизированный",
+      "synchronized": "синхронизированный ({{ percent }}%)",
-      "synchronizing": "синхронизация..."
+      "synchronizing": "синхронизация ({{ percent }}%)..."
     },
     "status_title": "Статус майтинга",
     "tier_share_per_block": "доля уровня за блок",

src/i18n/locales/zh/core.json

@@ -335,8 +335,8 @@
       "minting": "（铸造）",
       "not_minting": "（不是铸造）",
       "no_status": "没有状态",
-      "synchronized": "同步",
+      "synchronized": "同步 ({{ percent }}%)",
-      "synchronizing": "同步..."
+      "synchronizing": "同步 ({{ percent }}%)..."
     },
     "status_title": "铸造状态",
     "tier_share_per_block": "每个区块的等级份额",

src/qdn/publish/publish.ts

@@ -71,7 +71,7 @@ async function uploadChunkWithRetry(endpoint, formData, index, maxRetries = 3) {
       if (attempt >= maxRetries) {
         throw new Error(`Chunk ${index} failed after ${maxRetries} attempts`);
       }
-      // Wait 10 seconds before next retry
+      // Wait 25 seconds before next retry
       await new Promise((res) => setTimeout(res, 25_000));
     }
   }