@typeberry/jam 0.2.0-661fe38 → 0.2.0-663eeb1

package/index.js

@@ -25334,12 +25334,13 @@ class bytes_BytesBlob {
     }
     /** Display a hex-encoded version of this byte blob, but truncated if it's large. */
     toStringTruncated() {
+        const bytes = `${this.raw.length} ${this.raw.length === 1 ? "byte" : "bytes"}`;
         if (this.raw.length > 32) {
             const start = bytesToHexString(this.raw.subarray(0, 16));
             const end = bytesToHexString(this.raw.subarray(this.raw.length - 16));
-            return `${start}...${end.substring(2)} (${this.raw.length} bytes)`;
+            return `${start}...${end.substring(2)} (${bytes})`;
         }
-        return this.toString();
+        return `${this.toString()} (${bytes})`;
     }
     toJSON() {
         return this.toString();
@@ -44454,10 +44455,10 @@ class Info {
         const chunk = encodedInfo.raw.subarray(Number(offset), Number(offset + length));
         const writeResult = memory.storeFrom(outputStart, chunk);
         if (writeResult.isError) {
-            logger_logger.trace `INFO(${serviceId}) <- PANIC`;
+            logger_logger.trace `INFO(${serviceId}, off: ${offset}, len: ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
-        logger_logger.trace `INFO(${serviceId}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
+        logger_logger.trace `INFO(${serviceId}, off: ${offset}, len: ${length}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
         if (accountInfo === null) {
             regs.set(IN_OUT_REG, HostCallResult.NONE);
             return;
@@ -46015,7 +46016,7 @@ class Bless {
             decoder.resetTo(0);
             const memoryReadResult = memory.loadInto(result, memIndex);
             if (memoryReadResult.isError) {
-                logger_logger.trace `BLESS(${manager}, ${delegator}, ${registrar}) <- PANIC`;
+                logger_logger.trace `BLESS(m: ${manager}, v: ${delegator}, r: ${registrar}) <- PANIC`;
                 return PvmExecution.Panic;
             }
             const { serviceId, gas } = decoder.object(serviceIdAndGasCodec);
@@ -46028,26 +46029,26 @@ class Bless {
         const authorizersDecoder = decoder_Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
-            logger_logger.trace `BLESS(${manager}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- PANIC`;
+            logger_logger.trace `BLESS(m: ${manager}, v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // `a`
         const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(descriptors_codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate);
         if (updateResult.isOk) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
+            logger_logger.trace `BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
             regs.set(bless_IN_OUT_REG, HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         // NOTE: `UpdatePrivilegesError.UnprivilegedService` won't happen in 0.7.1+
         if (e === UpdatePrivilegesError.UnprivilegedService) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- HUH`;
+            logger_logger.trace `BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- HUH`;
             regs.set(bless_IN_OUT_REG, HostCallResult.HUH);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${lazyInspect(autoAccumulate)}) <- WHO`;
+            logger_logger.trace `BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- WHO`;
             regs.set(bless_IN_OUT_REG, HostCallResult.WHO);
             return;
         }
@@ -46425,9 +46426,11 @@ const IN_OUT_REG_1 = 7;
 const IN_OUT_REG_2 = 8;
 const UPPER_BITS_SHIFT = 32n;
 /**
- * Query the state of the accumulator.
+ * Query the state of the preimage.
+ *
+ * Get time slots for current preimage availability status.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/373002373002?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/37cb0237cb02?v=0.7.2
  */
 class Query {
     currentServiceId;
@@ -46452,27 +46455,31 @@ class Query {
             return PvmExecution.Panic;
         }
         const result = this.partialState.checkPreimageStatus(hash.asOpaque(), length);
-        logger_logger.trace `QUERY(${hash}, ${length}) <- ${result}`;
         const zero = numbers_tryAsU64(0n);
         if (result === null) {
+            logger_logger.trace `QUERY(${hash}, ${length}) <- NONE`;
             regs.set(IN_OUT_REG_1, HostCallResult.NONE);
             regs.set(IN_OUT_REG_2, zero);
             return;
         }
         switch (result.status) {
             case PreimageStatusKind.Requested:
+                logger_logger.trace `QUERY(${hash}, ${length}) <- REQUESTED`;
                 regs.set(IN_OUT_REG_1, zero);
                 regs.set(IN_OUT_REG_2, zero);
                 return;
             case PreimageStatusKind.Available:
+                logger_logger.trace `QUERY(${hash}, ${length}) <- AVAILABLE [${result.data}]`;
                 regs.set(IN_OUT_REG_1, numbers_tryAsU64((BigInt(result.data[0]) << UPPER_BITS_SHIFT) + 1n));
                 regs.set(IN_OUT_REG_2, zero);
                 return;
             case PreimageStatusKind.Unavailable:
+                logger_logger.trace `QUERY(${hash}, ${length}) <- UNAVAILABLE [${result.data.join(", ")}]`;
                 regs.set(IN_OUT_REG_1, numbers_tryAsU64((BigInt(result.data[0]) << UPPER_BITS_SHIFT) + 2n));
                 regs.set(IN_OUT_REG_2, numbers_tryAsU64(result.data[1]));
                 return;
             case PreimageStatusKind.Reavailable:
+                logger_logger.trace `QUERY(${hash}, ${length}) <- REAVAILABLE [${result.data.join(", ")}]`;
                 regs.set(IN_OUT_REG_1, numbers_tryAsU64((BigInt(result.data[0]) << UPPER_BITS_SHIFT) + 3n));
                 regs.set(IN_OUT_REG_2, numbers_tryAsU64((BigInt(result.data[2]) << UPPER_BITS_SHIFT) + BigInt(result.data[1])));
                 return;
@@ -46866,6 +46873,15 @@ var FetchKind;
 
 
 const decoder = new TextDecoder("utf8");
+var Levels;
+(function (Levels) {
+    Levels[Levels["ERROR"] = 0] = "ERROR";
+    Levels[Levels["WARNING"] = 1] = "WARNING";
+    Levels[Levels["INFO"] = 2] = "INFO";
+    Levels[Levels["DEBUG"] = 3] = "DEBUG";
+    Levels[Levels["NIT"] = 4] = "NIT";
+    Levels[Levels["UNKNOWN"] = 5] = "UNKNOWN";
+})(Levels || (Levels = {}));
 /**
  * Log message to the console
  *
@@ -46892,7 +46908,8 @@ class LogHostCall {
             memory.loadInto(target, targetStart);
         }
         memory.loadInto(message, msgStart);
-        logger_logger.trace `SERVICE [${this.currentServiceId}] [${lvl}] ${decoder.decode(target)} ${decoder.decode(message)}`;
+        const level = clampU64ToU32(lvl);
+        logger_logger.trace `LOG(${this.currentServiceId}, ${level < Levels.UNKNOWN ? Levels[level] : Levels[Levels.UNKNOWN]}(${lvl}), ${decoder.decode(target)}, ${decoder.decode(message)})`;
         return Promise.resolve(undefined);
     }
 }
@@ -47043,7 +47060,13 @@ class Read {
             regs.set(read_IN_OUT_REG, HostCallResult.NONE);
             return;
         }
-        logger_logger.trace `READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
+        if (chunk.length > 0) {
+            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
+        }
+        else {
+            // just a query for length of stored data
+            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- (${valueLength} ${valueLength === 1n ? "byte" : "bytes"})`;
+        }
         regs.set(read_IN_OUT_REG, valueLength);
     }
 }
@@ -47103,7 +47126,7 @@ class Write {
         const maybeValue = valueLength === 0n ? null : bytes_BytesBlob.blobFrom(value);
         // a
         const result = this.account.write(storageKey, maybeValue);
-        logger_logger.trace `WRITE(${storageKey}, ${maybeValue?.toStringTruncated()}) <- ${result_resultToString(result)}`;
+        logger_logger.trace `WRITE(${storageKey}, ${maybeValue?.toStringTruncated() ?? "remove"}) <- ${result_resultToString(result)}`;
         if (result.isError) {
             regs.set(write_IN_OUT_REG, HostCallResult.FULL);
             return;