@typeberry/lib 0.4.1-bb6dbac → 0.4.1-d3b18b3

package/index.cjs

@@ -101,6 +101,15 @@ class Compatibility {
 function isBrowser() {
     return typeof process === "undefined" || typeof process.abort === "undefined";
 }
+/**
+ * Get current time in milliseconds (works in both Node and browser).
+ *
+ * Node.js implementation converts hrtime bigint nanoseconds to milliseconds.
+ * This is safe because dividing nanoseconds by 1_000_000 yields milliseconds,
+ * which remain well below Number.MAX_SAFE_INTEGER for practical runtimes
+ * (would take ~285 years to overflow).
+ */
+const now = isBrowser() ? () => performance.now() : () => Number(process.hrtime.bigint() / 1000000n);
 /**
  * A function to perform runtime assertions.
  *
@@ -189,19 +198,10 @@ function inspect(val) {
     return v;
 }
 /** Utility function to measure time taken for some operation [ms]. */
-const measure = isBrowser()
-    ? (id) => {
-        const start = performance.now();
-        return () => `${id} took ${performance.now() - start}ms`;
-    }
-    : (id) => {
-        const start = process.hrtime.bigint();
-        return () => {
-            const tookNano = process.hrtime.bigint() - start;
-            const tookMilli = Number(tookNano / 1000000n).toFixed(2);
-            return `${id} took ${tookMilli}ms`;
-        };
-    };
+function measure(id) {
+    const start = now();
+    return () => `${id} took ${(now() - start).toFixed(2)}ms`;
+}
 /** A class that adds `toString` method that prints all properties of an object. */
 class WithDebug {
     toString() {
@@ -606,10 +606,12 @@ var index$y = /*#__PURE__*/Object.freeze({
   assertNever: assertNever,
   check: check,
   deepEqual: deepEqual,
+  env: env,
   inspect: inspect,
   isBrowser: isBrowser,
   lazyInspect: lazyInspect,
   measure: measure,
+  now: now,
   resultToString: resultToString,
   safeAllocUint8Array: safeAllocUint8Array,
   seeThrough: seeThrough,
@@ -3848,7 +3850,7 @@ class Mutex {
 }
 
 var _a;
-function getGlobal() {
+function getGlobal$1() {
     if (typeof globalThis !== "undefined")
         return globalThis;
     if (typeof self !== "undefined")
@@ -3857,7 +3859,7 @@ function getGlobal() {
         return window;
     return global;
 }
-const globalObject = getGlobal();
+const globalObject = getGlobal$1();
 const nodeBuffer = (_a = globalObject.Buffer) !== null && _a !== void 0 ? _a : null;
 const textEncoder = globalObject.TextEncoder
     ? new globalObject.TextEncoder()
@@ -7794,7 +7796,7 @@ class JipChainSpec extends WithDebug {
 }
 
 var $schema$1 = "https://fluffylabs.dev/typeberry/schemas/config-v1.schema.json";
-var version$1 = 1;
+var version$2 = 1;
 var flavor$1 = "tiny";
 var authorship$1 = {
 	omit_seal_verification: false
@@ -7833,7 +7835,7 @@ var chain_spec$1 = {
 var database_base_path$1 = "./database";
 var defaultConfig = {
 	$schema: $schema$1,
-	version: version$1,
+	version: version$2,
 	flavor: flavor$1,
 	authorship: authorship$1,
 	chain_spec: chain_spec$1,
@@ -7841,7 +7843,7 @@ var defaultConfig = {
 };
 
 var $schema = "https://fluffylabs.dev/typeberry/schemas/config-v1.schema.json";
-var version = 1;
+var version$1 = 1;
 var flavor = "tiny";
 var authorship = {
 	omit_seal_verification: true
@@ -7879,7 +7881,7 @@ var chain_spec = {
 var database_base_path = "./database";
 var devConfig = {
 	$schema: $schema,
-	version: version,
+	version: version$1,
 	flavor: flavor,
 	authorship: authorship,
 	chain_spec: chain_spec,
@@ -18117,7 +18119,7 @@ function emptyRegistersBuffer() {
     return safeAllocUint8Array(NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE);
 }
 
-const IN_OUT_REG$f = 7;
+const IN_OUT_REG$g = 7;
 const OFFSET_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9 : 11;
 const LEN_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 10 : 12;
 /**
@@ -18143,14 +18145,14 @@ class Info {
     account;
     index = tryAsHostCallIndex(5);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$f, 8, OFFSET_REG, LEN_REG);
+    tracedRegisters = traceRegisters(IN_OUT_REG$g, 8, OFFSET_REG, LEN_REG);
     constructor(currentServiceId, account) {
         this.currentServiceId = currentServiceId;
         this.account = account;
     }
     async execute(_gas, regs, memory) {
         // t
-        const serviceId = getServiceIdOrCurrent(IN_OUT_REG$f, regs, this.currentServiceId);
+        const serviceId = getServiceIdOrCurrent(IN_OUT_REG$g, regs, this.currentServiceId);
         // o
         const outputStart = regs.get(8);
         // v
@@ -18176,10 +18178,10 @@ class Info {
         }
         logger$7.trace `[${this.currentServiceId}] INFO(${serviceId}, off: ${offset}, len: ${length}) <- ${BytesBlob.blobFrom(chunk)}`;
         if (accountInfo === null) {
-            regs.set(IN_OUT_REG$f, HostCallResult.NONE);
+            regs.set(IN_OUT_REG$g, HostCallResult.NONE);
             return;
         }
-        regs.set(IN_OUT_REG$f, valueLength);
+        regs.set(IN_OUT_REG$g, valueLength);
     }
 }
 /**
@@ -19723,7 +19725,7 @@ function finalize(mergeContext) {
     };
 }
 
-const IN_OUT_REG$e = 7;
+const IN_OUT_REG$f = 7;
 /**
  * Assign new fixed-length authorization queue to some core and authorize a service for this core.
  *
@@ -19735,7 +19737,7 @@ class Assign {
     chainSpec;
     index = tryAsHostCallIndex(15);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$e, 8);
+    tracedRegisters = traceRegisters(IN_OUT_REG$f, 8);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
@@ -19743,7 +19745,7 @@ class Assign {
     }
     async execute(_gas, regs, memory) {
         // c
-        const maybeCoreIndex = regs.get(IN_OUT_REG$e);
+        const maybeCoreIndex = regs.get(IN_OUT_REG$f);
         // o
         const authorizationQueueStart = regs.get(8);
         // a
@@ -19756,7 +19758,7 @@ class Assign {
             return PvmExecution.Panic;
         }
         if (maybeCoreIndex >= this.chainSpec.coresCount) {
-            regs.set(IN_OUT_REG$e, HostCallResult.CORE);
+            regs.set(IN_OUT_REG$f, HostCallResult.CORE);
             return;
         }
         // NOTE: Here we know the core index is valid
@@ -19766,18 +19768,18 @@ class Assign {
         const fixedSizeAuthQueue = FixedSizeArray.new(authQueue, AUTHORIZATION_QUEUE_SIZE);
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
-            regs.set(IN_OUT_REG$e, HostCallResult.OK);
+            regs.set(IN_OUT_REG$f, HostCallResult.OK);
             logger$7.trace `[${this.currentServiceId}] ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`;
             return;
         }
         const e = result.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
-            regs.set(IN_OUT_REG$e, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$f, HostCallResult.HUH);
             logger$7.trace `[${this.currentServiceId}] ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
-            regs.set(IN_OUT_REG$e, HostCallResult.WHO);
+            regs.set(IN_OUT_REG$f, HostCallResult.WHO);
             logger$7.trace `[${this.currentServiceId}] ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
             return;
         }
@@ -19785,7 +19787,7 @@ class Assign {
     }
 }
 
-const IN_OUT_REG$d = 7;
+const IN_OUT_REG$e = 7;
 const serviceIdAndGasCodec = object({
     serviceId: u32.convert((i) => i, (o) => asOpaqueType(o)),
     gas: u64.convert((i) => tryAsU64(i), (o) => tryAsServiceGas(o)),
@@ -19802,8 +19804,8 @@ class Bless {
     index = tryAsHostCallIndex(14);
     basicGasCost = tryAsSmallGas(10);
     tracedRegisters = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-        ? traceRegisters(IN_OUT_REG$d, 8, 9, 10, 11, 12)
-        : traceRegisters(IN_OUT_REG$d, 8, 9, 10, 11);
+        ? traceRegisters(IN_OUT_REG$e, 8, 9, 10, 11, 12)
+        : traceRegisters(IN_OUT_REG$e, 8, 9, 10, 11);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
@@ -19811,7 +19813,7 @@ class Bless {
     }
     async execute(_gas, regs, memory) {
         // `m`: manager service (can change privileged services)
-        const manager = getServiceId(regs.get(IN_OUT_REG$d));
+        const manager = getServiceId(regs.get(IN_OUT_REG$e));
         // `a`: manages authorization queue
         const authorization = regs.get(8);
         // `v`: manages validator keys
@@ -19858,19 +19860,19 @@ class Bless {
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate);
         if (updateResult.isOk) {
             logger$7.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
-            regs.set(IN_OUT_REG$d, HostCallResult.OK);
+            regs.set(IN_OUT_REG$e, HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         // NOTE: `UpdatePrivilegesError.UnprivilegedService` won't happen in 0.7.1+
         if (e === UpdatePrivilegesError.UnprivilegedService) {
             logger$7.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- HUH`;
-            regs.set(IN_OUT_REG$d, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$e, HostCallResult.HUH);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
             logger$7.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- WHO`;
-            regs.set(IN_OUT_REG$d, HostCallResult.WHO);
+            regs.set(IN_OUT_REG$e, HostCallResult.WHO);
             return;
         }
         assertNever(e);
@@ -19926,7 +19928,7 @@ class Checkpoint {
     }
 }
 
-const IN_OUT_REG$c = 7;
+const IN_OUT_REG$d = 7;
 const VALIDATOR_DATA_BYTES = tryAsExactBytes(ValidatorData.Codec.sizeHint);
 /**
  * Designate a new set of validator keys.
@@ -19939,7 +19941,7 @@ class Designate {
     chainSpec;
     index = tryAsHostCallIndex(16);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$c);
+    tracedRegisters = traceRegisters(IN_OUT_REG$d);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
@@ -19947,7 +19949,7 @@ class Designate {
     }
     async execute(_gas, regs, memory) {
         // `o`
-        const validatorsStart = regs.get(IN_OUT_REG$c);
+        const validatorsStart = regs.get(IN_OUT_REG$d);
         const res = safeAllocUint8Array(VALIDATOR_DATA_BYTES * this.chainSpec.validatorsCount);
         const memoryReadResult = memory.loadInto(res, validatorsStart);
         // error while reading the memory.
@@ -19960,16 +19962,16 @@ class Designate {
         const result = this.partialState.updateValidatorsData(tryAsPerValidator(validatorsData, this.chainSpec));
         if (result.isError) {
             logger$7.trace `[${this.currentServiceId}] DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`;
-            regs.set(IN_OUT_REG$c, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$d, HostCallResult.HUH);
         }
         else {
             logger$7.trace `[${this.currentServiceId}] DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`;
-            regs.set(IN_OUT_REG$c, HostCallResult.OK);
+            regs.set(IN_OUT_REG$d, HostCallResult.OK);
         }
     }
 }
 
-const IN_OUT_REG$b = 7;
+const IN_OUT_REG$c = 7;
 /**
  * Remove the provided service account and transfer the remaining balance to current service account.
  *
@@ -19980,14 +19982,14 @@ class Eject {
     partialState;
     index = tryAsHostCallIndex(21);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$b, 8);
+    tracedRegisters = traceRegisters(IN_OUT_REG$c, 8);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `d`: account to eject from (source)
-        const serviceId = getServiceId(regs.get(IN_OUT_REG$b));
+        const serviceId = getServiceId(regs.get(IN_OUT_REG$c));
         // `o`: preimage hash start memory index
         const preimageHashStart = regs.get(8);
         // `h`: hash
@@ -19999,7 +20001,7 @@ class Eject {
         }
         // cannot eject self
         if (serviceId === this.currentServiceId) {
-            regs.set(IN_OUT_REG$b, HostCallResult.WHO);
+            regs.set(IN_OUT_REG$c, HostCallResult.WHO);
             logger$7.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- WHO`;
             return;
         }
@@ -20007,17 +20009,17 @@ class Eject {
         // All good!
         if (result.isOk) {
             logger$7.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- OK`;
-            regs.set(IN_OUT_REG$b, HostCallResult.OK);
+            regs.set(IN_OUT_REG$c, HostCallResult.OK);
             return;
         }
         const e = result.error;
         if (e === EjectError.InvalidService) {
             logger$7.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- WHO ${resultToString(result)}`;
-            regs.set(IN_OUT_REG$b, HostCallResult.WHO);
+            regs.set(IN_OUT_REG$c, HostCallResult.WHO);
         }
         else if (e === EjectError.InvalidPreimage) {
             logger$7.trace `[${this.currentServiceId}] EJECT(${serviceId}, ${previousCodeHash}) <- HUH ${resultToString(result)}`;
-            regs.set(IN_OUT_REG$b, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$c, HostCallResult.HUH);
         }
         else {
             assertNever(e);
@@ -20025,7 +20027,7 @@ class Eject {
     }
 }
 
-const IN_OUT_REG$a = 7;
+const IN_OUT_REG$b = 7;
 /**
  * Delete preimage hash or mark as unavailable if it was available.
  *
@@ -20036,14 +20038,14 @@ class Forget {
     partialState;
     index = tryAsHostCallIndex(24);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$a, 8);
+    tracedRegisters = traceRegisters(IN_OUT_REG$b, 8);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `o`
-        const hashStart = regs.get(IN_OUT_REG$a);
+        const hashStart = regs.get(IN_OUT_REG$b);
         // `z`
         const length = regs.get(8);
         const hash = Bytes.zero(HASH_SIZE);
@@ -20056,15 +20058,15 @@ class Forget {
         const result = this.partialState.forgetPreimage(hash.asOpaque(), length);
         logger$7.trace `[${this.currentServiceId}] FORGET(${hash}, ${length}) <- ${resultToString(result)}`;
         if (result.isOk) {
-            regs.set(IN_OUT_REG$a, HostCallResult.OK);
+            regs.set(IN_OUT_REG$b, HostCallResult.OK);
         }
         else {
-            regs.set(IN_OUT_REG$a, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$b, HostCallResult.HUH);
         }
     }
 }
 
-const IN_OUT_REG$9 = 7;
+const IN_OUT_REG$a = 7;
 /**
  * Create a new service account.
  *
@@ -20076,15 +20078,15 @@ class New {
     index = tryAsHostCallIndex(18);
     basicGasCost = tryAsSmallGas(10);
     tracedRegisters = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-        ? traceRegisters(IN_OUT_REG$9, 8, 9, 10, 11, 12)
-        : traceRegisters(IN_OUT_REG$9, 8, 9, 10, 11);
+        ? traceRegisters(IN_OUT_REG$a, 8, 9, 10, 11, 12)
+        : traceRegisters(IN_OUT_REG$a, 8, 9, 10, 11);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `o`
-        const codeHashStart = regs.get(IN_OUT_REG$9);
+        const codeHashStart = regs.get(IN_OUT_REG$a);
         // `l`
         const codeLength = regs.get(8);
         // `g`
@@ -20106,28 +20108,28 @@ class New {
         const assignedId = this.partialState.newService(codeHash.asOpaque(), codeLength, gas, allowance, gratisStorage, requestedServiceId);
         logger$7.trace `[${this.currentServiceId}] NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- ${resultToString(assignedId)}`;
         if (assignedId.isOk) {
-            regs.set(IN_OUT_REG$9, tryAsU64(assignedId.ok));
+            regs.set(IN_OUT_REG$a, tryAsU64(assignedId.ok));
             return;
         }
         const e = assignedId.error;
         if (e === NewServiceError.InsufficientFunds) {
-            regs.set(IN_OUT_REG$9, HostCallResult.CASH);
+            regs.set(IN_OUT_REG$a, HostCallResult.CASH);
             return;
         }
         if (e === NewServiceError.UnprivilegedService) {
-            regs.set(IN_OUT_REG$9, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$a, HostCallResult.HUH);
             return;
         }
         // Post 0.7.1
         if (e === NewServiceError.RegistrarServiceIdAlreadyTaken) {
-            regs.set(IN_OUT_REG$9, HostCallResult.FULL);
+            regs.set(IN_OUT_REG$a, HostCallResult.FULL);
             return;
         }
         assertNever(e);
     }
 }
 
-const IN_OUT_REG$8 = 7;
+const IN_OUT_REG$9 = 7;
 /**
  * Provide a preimage for a given service.
  *
@@ -20138,14 +20140,14 @@ class Provide {
     partialState;
     index = tryAsHostCallIndex(26);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$8, 8, 9);
+    tracedRegisters = traceRegisters(IN_OUT_REG$9, 8, 9);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `s`
-        const serviceId = getServiceIdOrCurrent(IN_OUT_REG$8, regs, this.currentServiceId);
+        const serviceId = getServiceIdOrCurrent(IN_OUT_REG$9, regs, this.currentServiceId);
         // `o`
         const preimageStart = regs.get(8);
         // `z`
@@ -20161,16 +20163,16 @@ class Provide {
         const result = this.partialState.providePreimage(serviceId, preimage);
         logger$7.trace `[${this.currentServiceId}] PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`;
         if (result.isOk) {
-            regs.set(IN_OUT_REG$8, HostCallResult.OK);
+            regs.set(IN_OUT_REG$9, HostCallResult.OK);
             return;
         }
         const e = result.error;
         if (e === ProvidePreimageError.ServiceNotFound) {
-            regs.set(IN_OUT_REG$8, HostCallResult.WHO);
+            regs.set(IN_OUT_REG$9, HostCallResult.WHO);
             return;
         }
         if (e === ProvidePreimageError.WasNotRequested || e === ProvidePreimageError.AlreadyProvided) {
-            regs.set(IN_OUT_REG$8, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$9, HostCallResult.HUH);
             return;
         }
         assertNever(e);
@@ -20242,7 +20244,7 @@ class Query {
     }
 }
 
-const IN_OUT_REG$7 = 7;
+const IN_OUT_REG$8 = 7;
 /**
  * Request a preimage to be available.
  *
@@ -20253,14 +20255,14 @@ class Solicit {
     partialState;
     index = tryAsHostCallIndex(23);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$7, 8);
+    tracedRegisters = traceRegisters(IN_OUT_REG$8, 8);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `o`
-        const hashStart = regs.get(IN_OUT_REG$7);
+        const hashStart = regs.get(IN_OUT_REG$8);
         // `z`
         const length = regs.get(8);
         const hash = Bytes.zero(HASH_SIZE);
@@ -20272,23 +20274,23 @@ class Solicit {
         const result = this.partialState.requestPreimage(hash.asOpaque(), length);
         logger$7.trace `[${this.currentServiceId}] SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`;
         if (result.isOk) {
-            regs.set(IN_OUT_REG$7, HostCallResult.OK);
+            regs.set(IN_OUT_REG$8, HostCallResult.OK);
             return;
         }
         const e = result.error;
         if (e === RequestPreimageError.AlreadyAvailable || e === RequestPreimageError.AlreadyRequested) {
-            regs.set(IN_OUT_REG$7, HostCallResult.HUH);
+            regs.set(IN_OUT_REG$8, HostCallResult.HUH);
             return;
         }
         if (e === RequestPreimageError.InsufficientFunds) {
-            regs.set(IN_OUT_REG$7, HostCallResult.FULL);
+            regs.set(IN_OUT_REG$8, HostCallResult.FULL);
             return;
         }
         assertNever(e);
     }
 }
 
-const IN_OUT_REG$6 = 7; // `d`
+const IN_OUT_REG$7 = 7; // `d`
 const AMOUNT_REG = 8; // `a`
 const TRANSFER_GAS_FEE_REG = 9; // `l`
 const MEMO_START_REG = 10; // `o`
@@ -20319,14 +20321,14 @@ class Transfer {
     basicGasCost = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)
         ? tryAsSmallGas(10)
         : (regs) => tryAsGas(10n + regs.get(TRANSFER_GAS_FEE_REG));
-    tracedRegisters = traceRegisters(IN_OUT_REG$6, AMOUNT_REG, TRANSFER_GAS_FEE_REG, MEMO_START_REG);
+    tracedRegisters = traceRegisters(IN_OUT_REG$7, AMOUNT_REG, TRANSFER_GAS_FEE_REG, MEMO_START_REG);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(gas, regs, memory) {
         // `d`: destination
-        const destination = getServiceId(regs.get(IN_OUT_REG$6));
+        const destination = getServiceId(regs.get(IN_OUT_REG$7));
         // `a`: amount
         const amount = regs.get(AMOUNT_REG);
         // `l`: gas
@@ -20351,27 +20353,27 @@ class Transfer {
                     return PvmExecution.OOG;
                 }
             }
-            regs.set(IN_OUT_REG$6, HostCallResult.OK);
+            regs.set(IN_OUT_REG$7, HostCallResult.OK);
             return;
         }
         const e = transferResult.error;
         if (e === TransferError.DestinationNotFound) {
-            regs.set(IN_OUT_REG$6, HostCallResult.WHO);
+            regs.set(IN_OUT_REG$7, HostCallResult.WHO);
             return;
         }
         if (e === TransferError.GasTooLow) {
-            regs.set(IN_OUT_REG$6, HostCallResult.LOW);
+            regs.set(IN_OUT_REG$7, HostCallResult.LOW);
             return;
         }
         if (e === TransferError.BalanceBelowThreshold) {
-            regs.set(IN_OUT_REG$6, HostCallResult.CASH);
+            regs.set(IN_OUT_REG$7, HostCallResult.CASH);
             return;
         }
         assertNever(e);
     }
 }
 
-const IN_OUT_REG$5 = 7; // `o`
+const IN_OUT_REG$6 = 7; // `o`
 const GAS_REG = 8; // `g`
 const ALLOWANCE_REG = 9; // `m`
 /**
@@ -20384,14 +20386,14 @@ class Upgrade {
     partialState;
     index = tryAsHostCallIndex(19);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$5, GAS_REG, ALLOWANCE_REG);
+    tracedRegisters = traceRegisters(IN_OUT_REG$6, GAS_REG, ALLOWANCE_REG);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `o`
-        const codeHashStart = regs.get(IN_OUT_REG$5);
+        const codeHashStart = regs.get(IN_OUT_REG$6);
         // `g`
         const gas = regs.get(GAS_REG);
         // `m`
@@ -20405,11 +20407,11 @@ class Upgrade {
         }
         this.partialState.upgradeService(codeHash.asOpaque(), gas, allowance);
         logger$7.trace `[${this.currentServiceId}] UPGRADE(${codeHash}, ${gas}, ${allowance})`;
-        regs.set(IN_OUT_REG$5, HostCallResult.OK);
+        regs.set(IN_OUT_REG$6, HostCallResult.OK);
     }
 }
 
-const IN_OUT_REG$4 = 7;
+const IN_OUT_REG$5 = 7;
 /**
  * Yield accumulation trie result.
  *
@@ -20420,14 +20422,14 @@ class Yield {
     partialState;
     index = tryAsHostCallIndex(25);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$4);
+    tracedRegisters = traceRegisters(IN_OUT_REG$5);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
     async execute(_gas, regs, memory) {
         // `o`
-        const hashStart = regs.get(IN_OUT_REG$4);
+        const hashStart = regs.get(IN_OUT_REG$5);
         const hash = Bytes.zero(HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
@@ -20436,11 +20438,11 @@ class Yield {
         }
         this.partialState.yield(hash);
         logger$7.trace `[${this.currentServiceId}] YIELD(${hash})`;
-        regs.set(IN_OUT_REG$4, HostCallResult.OK);
+        regs.set(IN_OUT_REG$5, HostCallResult.OK);
     }
 }
 
-const IN_OUT_REG$3 = 7;
+const IN_OUT_REG$4 = 7;
 /**
  * https://graypaper.fluffylabs.dev/#/7e6ff6a/324000324000?v=0.6.7
  */
@@ -20449,7 +20451,7 @@ class Fetch {
     fetch;
     index = tryAsHostCallIndex(1);
     basicGasCost = tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(IN_OUT_REG$3, 8, 9, 10, 11, 12);
+    tracedRegisters = traceRegisters(IN_OUT_REG$4, 8, 9, 10, 11, 12);
     constructor(currentServiceId, fetch) {
         this.currentServiceId = currentServiceId;
         this.fetch = fetch;
@@ -20459,7 +20461,7 @@ class Fetch {
         const kind = clampU64ToU32(fetchKindU64);
         const value = this.getValue(kind, regs);
         // o
-        const output = regs.get(IN_OUT_REG$3);
+        const output = regs.get(IN_OUT_REG$4);
         const valueLength = tryAsU64(value?.length ?? 0);
         // f
         const offset = minU64(regs.get(8), valueLength);
@@ -20475,7 +20477,7 @@ class Fetch {
         }
         logger$7.trace `[${this.currentServiceId}] FETCH(${kind}) <- ${value?.toStringTruncated()}`;
         // write result
-        regs.set(IN_OUT_REG$3, value === null ? HostCallResult.NONE : valueLength);
+        regs.set(IN_OUT_REG$4, value === null ? HostCallResult.NONE : valueLength);
     }
     getValue(kind, regs) {
         if (kind === FetchKind.Constants) {
@@ -20590,6 +20592,7 @@ var Levels;
     Levels[Levels["NIT"] = 4] = "NIT";
     Levels[Levels["UNKNOWN"] = 5] = "UNKNOWN";
 })(Levels || (Levels = {}));
+const IN_OUT_REG$3 = 7;
 /**
  * Log message to the console
  *
@@ -20598,13 +20601,13 @@ var Levels;
 class LogHostCall {
     currentServiceId;
     index = tryAsHostCallIndex(100);
-    basicGasCost = tryAsSmallGas(0);
+    basicGasCost = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? tryAsSmallGas(10) : tryAsSmallGas(0);
     // intentionally not tracing anything here, since the message will be printed anyway.
     tracedRegisters = traceRegisters();
     constructor(currentServiceId) {
         this.currentServiceId = currentServiceId;
     }
-    execute(_gas, regs, memory) {
+    async execute(_gas, regs, memory) {
         const lvl = regs.get(7);
         const targetStart = regs.get(8);
         const targetLength = regs.get(9);
@@ -20618,7 +20621,9 @@ class LogHostCall {
         memory.loadInto(message, msgStart);
         const level = clampU64ToU32(lvl);
         logger$7.trace `[${this.currentServiceId}] LOG(${this.currentServiceId}, ${level < Levels.UNKNOWN ? Levels[level] : Levels[Levels.UNKNOWN]}(${lvl}), ${decoder.decode(target)}, ${decoder.decode(message)})`;
-        return Promise.resolve(undefined);
+        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)) {
+            regs.set(IN_OUT_REG$3, HostCallResult.WHAT);
+        }
     }
 }
 
@@ -24166,6 +24171,863 @@ var index$4 = /*#__PURE__*/Object.freeze({
   stfError: stfError
 });
 
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** only globals that common to node and browsers are allowed */
+// eslint-disable-next-line node/no-unsupported-features/es-builtins
+var _globalThis = typeof globalThis === 'object' ? globalThis : global;
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// this is autogenerated file, see scripts/version-update.js
+var VERSION = '1.9.0';
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+/**
+ * Create a function to test an API version to see if it is compatible with the provided ownVersion.
+ *
+ * The returned function has the following semantics:
+ * - Exact match is always compatible
+ * - Major versions must match exactly
+ *    - 1.x package cannot use global 2.x package
+ *    - 2.x package cannot use global 1.x package
+ * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+ *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+ *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+ * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+ * - Patch and build tag differences are not considered at this time
+ *
+ * @param ownVersion version which should be checked against
+ */
+function _makeCompatibilityCheck(ownVersion) {
+    var acceptedVersions = new Set([ownVersion]);
+    var rejectedVersions = new Set();
+    var myVersionMatch = ownVersion.match(re);
+    if (!myVersionMatch) {
+        // we cannot guarantee compatibility so we always return noop
+        return function () { return false; };
+    }
+    var ownVersionParsed = {
+        major: +myVersionMatch[1],
+        minor: +myVersionMatch[2],
+        patch: +myVersionMatch[3],
+        prerelease: myVersionMatch[4],
+    };
+    // if ownVersion has a prerelease tag, versions must match exactly
+    if (ownVersionParsed.prerelease != null) {
+        return function isExactmatch(globalVersion) {
+            return globalVersion === ownVersion;
+        };
+    }
+    function _reject(v) {
+        rejectedVersions.add(v);
+        return false;
+    }
+    function _accept(v) {
+        acceptedVersions.add(v);
+        return true;
+    }
+    return function isCompatible(globalVersion) {
+        if (acceptedVersions.has(globalVersion)) {
+            return true;
+        }
+        if (rejectedVersions.has(globalVersion)) {
+            return false;
+        }
+        var globalVersionMatch = globalVersion.match(re);
+        if (!globalVersionMatch) {
+            // cannot parse other version
+            // we cannot guarantee compatibility so we always noop
+            return _reject(globalVersion);
+        }
+        var globalVersionParsed = {
+            major: +globalVersionMatch[1],
+            minor: +globalVersionMatch[2],
+            patch: +globalVersionMatch[3],
+            prerelease: globalVersionMatch[4],
+        };
+        // if globalVersion has a prerelease tag, versions must match exactly
+        if (globalVersionParsed.prerelease != null) {
+            return _reject(globalVersion);
+        }
+        // major versions must match
+        if (ownVersionParsed.major !== globalVersionParsed.major) {
+            return _reject(globalVersion);
+        }
+        if (ownVersionParsed.major === 0) {
+            if (ownVersionParsed.minor === globalVersionParsed.minor &&
+                ownVersionParsed.patch <= globalVersionParsed.patch) {
+                return _accept(globalVersion);
+            }
+            return _reject(globalVersion);
+        }
+        if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+            return _accept(globalVersion);
+        }
+        return _reject(globalVersion);
+    };
+}
+/**
+ * Test an API version to see if it is compatible with this API.
+ *
+ * - Exact match is always compatible
+ * - Major versions must match exactly
+ *    - 1.x package cannot use global 2.x package
+ *    - 2.x package cannot use global 1.x package
+ * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+ *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+ *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+ * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+ * - Patch and build tag differences are not considered at this time
+ *
+ * @param version version of the API requesting an instance of the global API
+ */
+var isCompatible = _makeCompatibilityCheck(VERSION);
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var major = VERSION.split('.')[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+var _global = _globalThis;
+function registerGlobal(type, instance, diag, allowOverride) {
+    var _a;
+    if (allowOverride === void 0) { allowOverride = false; }
+    var api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+        version: VERSION,
+    });
+    if (!allowOverride && api[type]) {
+        // already registered an API of this type
+        var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+        diag.error(err.stack || err.message);
+        return false;
+    }
+    if (api.version !== VERSION) {
+        // All registered APIs must be of the same version exactly
+        var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+        diag.error(err.stack || err.message);
+        return false;
+    }
+    api[type] = instance;
+    diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+    return true;
+}
+function getGlobal(type) {
+    var _a, _b;
+    var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+    if (!globalVersion || !isCompatible(globalVersion)) {
+        return;
+    }
+    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+    diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+    var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+    if (api) {
+        delete api[type];
+    }
+}
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __read$1 = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray$1 = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * Component Logger which is meant to be used as part of any component which
+ * will add automatically additional namespace in front of the log message.
+ * It will then forward all message to global diag logger
+ * @example
+ * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });
+ * cLogger.debug('test');
+ * // @opentelemetry/instrumentation-http test
+ */
+var DiagComponentLogger = /** @class */ (function () {
+    function DiagComponentLogger(props) {
+        this._namespace = props.namespace || 'DiagComponentLogger';
+    }
+    DiagComponentLogger.prototype.debug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return logProxy('debug', this._namespace, args);
+    };
+    DiagComponentLogger.prototype.error = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return logProxy('error', this._namespace, args);
+    };
+    DiagComponentLogger.prototype.info = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return logProxy('info', this._namespace, args);
+    };
+    DiagComponentLogger.prototype.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return logProxy('warn', this._namespace, args);
+    };
+    DiagComponentLogger.prototype.verbose = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return logProxy('verbose', this._namespace, args);
+    };
+    return DiagComponentLogger;
+}());
+function logProxy(funcName, namespace, args) {
+    var logger = getGlobal('diag');
+    // shortcut if logger not set
+    if (!logger) {
+        return;
+    }
+    args.unshift(namespace);
+    return logger[funcName].apply(logger, __spreadArray$1([], __read$1(args), false));
+}
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Defines the available internal logging levels for the diagnostic logger, the numeric values
+ * of the levels are defined to match the original values from the initial LogLevel to avoid
+ * compatibility/migration issues for any implementation that assume the numeric ordering.
+ */
+var DiagLogLevel;
+(function (DiagLogLevel) {
+    /** Diagnostic Logging level setting to disable all logging (except and forced logs) */
+    DiagLogLevel[DiagLogLevel["NONE"] = 0] = "NONE";
+    /** Identifies an error scenario */
+    DiagLogLevel[DiagLogLevel["ERROR"] = 30] = "ERROR";
+    /** Identifies a warning scenario */
+    DiagLogLevel[DiagLogLevel["WARN"] = 50] = "WARN";
+    /** General informational log message */
+    DiagLogLevel[DiagLogLevel["INFO"] = 60] = "INFO";
+    /** General debug log message */
+    DiagLogLevel[DiagLogLevel["DEBUG"] = 70] = "DEBUG";
+    /**
+     * Detailed trace level logging should only be used for development, should only be set
+     * in a development environment.
+     */
+    DiagLogLevel[DiagLogLevel["VERBOSE"] = 80] = "VERBOSE";
+    /** Used to set the logging level to include all logging */
+    DiagLogLevel[DiagLogLevel["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function createLogLevelDiagLogger(maxLevel, logger) {
+    if (maxLevel < DiagLogLevel.NONE) {
+        maxLevel = DiagLogLevel.NONE;
+    }
+    else if (maxLevel > DiagLogLevel.ALL) {
+        maxLevel = DiagLogLevel.ALL;
+    }
+    // In case the logger is null or undefined
+    logger = logger || {};
+    function _filterFunc(funcName, theLevel) {
+        var theFunc = logger[funcName];
+        if (typeof theFunc === 'function' && maxLevel >= theLevel) {
+            return theFunc.bind(logger);
+        }
+        return function () { };
+    }
+    return {
+        error: _filterFunc('error', DiagLogLevel.ERROR),
+        warn: _filterFunc('warn', DiagLogLevel.WARN),
+        info: _filterFunc('info', DiagLogLevel.INFO),
+        debug: _filterFunc('debug', DiagLogLevel.DEBUG),
+        verbose: _filterFunc('verbose', DiagLogLevel.VERBOSE),
+    };
+}
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var API_NAME$1 = 'diag';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry internal
+ * diagnostic API
+ */
+var DiagAPI = /** @class */ (function () {
+    /**
+     * Private internal constructor
+     * @private
+     */
+    function DiagAPI() {
+        function _logProxy(funcName) {
+            return function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var logger = getGlobal('diag');
+                // shortcut if logger not set
+                if (!logger)
+                    return;
+                return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
+            };
+        }
+        // Using self local variable for minification purposes as 'this' cannot be minified
+        var self = this;
+        // DiagAPI specific functions
+        var setLogger = function (logger, optionsOrLogLevel) {
+            var _a, _b, _c;
+            if (optionsOrLogLevel === void 0) { optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }; }
+            if (logger === self) {
+                // There isn't much we can do here.
+                // Logging to the console might break the user application.
+                // Try to log to self. If a logger was previously registered it will receive the log.
+                var err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation');
+                self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+                return false;
+            }
+            if (typeof optionsOrLogLevel === 'number') {
+                optionsOrLogLevel = {
+                    logLevel: optionsOrLogLevel,
+                };
+            }
+            var oldLogger = getGlobal('diag');
+            var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+            // There already is an logger registered. We'll let it know before overwriting it.
+            if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+                var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : '<failed to generate stacktrace>';
+                oldLogger.warn("Current logger will be overwritten from " + stack);
+                newLogger.warn("Current logger will overwrite one already registered from " + stack);
+            }
+            return registerGlobal('diag', newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = function () {
+            unregisterGlobal(API_NAME$1, self);
+        };
+        self.createComponentLogger = function (options) {
+            return new DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy('verbose');
+        self.debug = _logProxy('debug');
+        self.info = _logProxy('info');
+        self.warn = _logProxy('warn');
+        self.error = _logProxy('error');
+    }
+    /** Get the singleton instance of the DiagAPI API */
+    DiagAPI.instance = function () {
+        if (!this._instance) {
+            this._instance = new DiagAPI();
+        }
+        return this._instance;
+    };
+    return DiagAPI;
+}());
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses
+ * constant NoopMetrics for all of its methods.
+ */
+var NoopMeter = /** @class */ (function () {
+    function NoopMeter() {
+    }
+    /**
+     * @see {@link Meter.createGauge}
+     */
+    NoopMeter.prototype.createGauge = function (_name, _options) {
+        return NOOP_GAUGE_METRIC;
+    };
+    /**
+     * @see {@link Meter.createHistogram}
+     */
+    NoopMeter.prototype.createHistogram = function (_name, _options) {
+        return NOOP_HISTOGRAM_METRIC;
+    };
+    /**
+     * @see {@link Meter.createCounter}
+     */
+    NoopMeter.prototype.createCounter = function (_name, _options) {
+        return NOOP_COUNTER_METRIC;
+    };
+    /**
+     * @see {@link Meter.createUpDownCounter}
+     */
+    NoopMeter.prototype.createUpDownCounter = function (_name, _options) {
+        return NOOP_UP_DOWN_COUNTER_METRIC;
+    };
+    /**
+     * @see {@link Meter.createObservableGauge}
+     */
+    NoopMeter.prototype.createObservableGauge = function (_name, _options) {
+        return NOOP_OBSERVABLE_GAUGE_METRIC;
+    };
+    /**
+     * @see {@link Meter.createObservableCounter}
+     */
+    NoopMeter.prototype.createObservableCounter = function (_name, _options) {
+        return NOOP_OBSERVABLE_COUNTER_METRIC;
+    };
+    /**
+     * @see {@link Meter.createObservableUpDownCounter}
+     */
+    NoopMeter.prototype.createObservableUpDownCounter = function (_name, _options) {
+        return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+    };
+    /**
+     * @see {@link Meter.addBatchObservableCallback}
+     */
+    NoopMeter.prototype.addBatchObservableCallback = function (_callback, _observables) { };
+    /**
+     * @see {@link Meter.removeBatchObservableCallback}
+     */
+    NoopMeter.prototype.removeBatchObservableCallback = function (_callback) { };
+    return NoopMeter;
+}());
+var NoopMetric = /** @class */ (function () {
+    function NoopMetric() {
+    }
+    return NoopMetric;
+}());
+var NoopCounterMetric = /** @class */ (function (_super) {
+    __extends(NoopCounterMetric, _super);
+    function NoopCounterMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NoopCounterMetric.prototype.add = function (_value, _attributes) { };
+    return NoopCounterMetric;
+}(NoopMetric));
+var NoopUpDownCounterMetric = /** @class */ (function (_super) {
+    __extends(NoopUpDownCounterMetric, _super);
+    function NoopUpDownCounterMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NoopUpDownCounterMetric.prototype.add = function (_value, _attributes) { };
+    return NoopUpDownCounterMetric;
+}(NoopMetric));
+var NoopGaugeMetric = /** @class */ (function (_super) {
+    __extends(NoopGaugeMetric, _super);
+    function NoopGaugeMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NoopGaugeMetric.prototype.record = function (_value, _attributes) { };
+    return NoopGaugeMetric;
+}(NoopMetric));
+var NoopHistogramMetric = /** @class */ (function (_super) {
+    __extends(NoopHistogramMetric, _super);
+    function NoopHistogramMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NoopHistogramMetric.prototype.record = function (_value, _attributes) { };
+    return NoopHistogramMetric;
+}(NoopMetric));
+var NoopObservableMetric = /** @class */ (function () {
+    function NoopObservableMetric() {
+    }
+    NoopObservableMetric.prototype.addCallback = function (_callback) { };
+    NoopObservableMetric.prototype.removeCallback = function (_callback) { };
+    return NoopObservableMetric;
+}());
+var NoopObservableCounterMetric = /** @class */ (function (_super) {
+    __extends(NoopObservableCounterMetric, _super);
+    function NoopObservableCounterMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return NoopObservableCounterMetric;
+}(NoopObservableMetric));
+var NoopObservableGaugeMetric = /** @class */ (function (_super) {
+    __extends(NoopObservableGaugeMetric, _super);
+    function NoopObservableGaugeMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return NoopObservableGaugeMetric;
+}(NoopObservableMetric));
+var NoopObservableUpDownCounterMetric = /** @class */ (function (_super) {
+    __extends(NoopObservableUpDownCounterMetric, _super);
+    function NoopObservableUpDownCounterMetric() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return NoopObservableUpDownCounterMetric;
+}(NoopObservableMetric));
+var NOOP_METER = new NoopMeter();
+// Synchronous instruments
+var NOOP_COUNTER_METRIC = new NoopCounterMetric();
+var NOOP_GAUGE_METRIC = new NoopGaugeMetric();
+var NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+var NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+// Asynchronous instruments
+var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * An implementation of the {@link MeterProvider} which returns an impotent Meter
+ * for all calls to `getMeter`
+ */
+var NoopMeterProvider = /** @class */ (function () {
+    function NoopMeterProvider() {
+    }
+    NoopMeterProvider.prototype.getMeter = function (_name, _version, _options) {
+        return NOOP_METER;
+    };
+    return NoopMeterProvider;
+}());
+var NOOP_METER_PROVIDER = new NoopMeterProvider();
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var API_NAME = 'metrics';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Metrics API
+ */
+var MetricsAPI = /** @class */ (function () {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    function MetricsAPI() {
+    }
+    /** Get the singleton instance of the Metrics API */
+    MetricsAPI.getInstance = function () {
+        if (!this._instance) {
+            this._instance = new MetricsAPI();
+        }
+        return this._instance;
+    };
+    /**
+     * Set the current global meter provider.
+     * Returns true if the meter provider was successfully registered, else false.
+     */
+    MetricsAPI.prototype.setGlobalMeterProvider = function (provider) {
+        return registerGlobal(API_NAME, provider, DiagAPI.instance());
+    };
+    /**
+     * Returns the global meter provider.
+     */
+    MetricsAPI.prototype.getMeterProvider = function () {
+        return getGlobal(API_NAME) || NOOP_METER_PROVIDER;
+    };
+    /**
+     * Returns a meter from the global meter provider.
+     */
+    MetricsAPI.prototype.getMeter = function (name, version, options) {
+        return this.getMeterProvider().getMeter(name, version, options);
+    };
+    /** Remove the global meter provider */
+    MetricsAPI.prototype.disable = function () {
+        unregisterGlobal(API_NAME, DiagAPI.instance());
+    };
+    return MetricsAPI;
+}());
+
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+/** Entrypoint for metrics API */
+var metrics = MetricsAPI.getInstance();
+
+var name = "@typeberry/importer";
+var version = "0.4.1";
+var packageJson = {
+	name: name,
+	version: version};
+
+/**
+ * Block importer metrics for JAM implementation.
+ *
+ * https://github.com/polkadot-fellows/JIPs/blob/main/JIP-3.md#block-authoringimporting-events
+ */
+function createMetrics() {
+    const meter = metrics.getMeter(packageJson.name, packageJson.version);
+    const blockVerificationDuration = meter.createHistogram("jam.blockVerificationTime", {
+        description: "Duration of block verification",
+        unit: "ms",
+    });
+    const blockExecutionDuration = meter.createHistogram("jam.blockExecutionTime", {
+        description: "Duration of block execution",
+        unit: "ms",
+    });
+    const blockExecutionCost = meter.createHistogram("jam.blockExecutionGas", {
+        description: "Block execution cost (gas)",
+        unit: "gas",
+    });
+    const blockImportDuration = meter.createHistogram("jam.blockImportTime", {
+        description: "Total duration of block import (verification + execution)",
+        unit: "ms",
+    });
+    // JIP-3
+    // 43
+    const blockImportingCounter = meter.createCounter("jam.jip3.importing", {
+        description: "Block importing started",
+        unit: "blocks",
+    });
+    // 44
+    const blockVerificationFailedCounter = meter.createCounter("jam.jip3.verification_failed", {
+        description: "Block verification failed",
+        unit: "errors",
+    });
+    // 45
+    const blockVerifiedCounter = meter.createCounter("jam.jip3.verified", {
+        description: "Block verified successfully",
+        unit: "blocks",
+    });
+    // 46
+    const blockExecutionFailedCounter = meter.createCounter("jam.jip3.execution_failed", {
+        description: "Block execution failed",
+        unit: "errors",
+    });
+    // 47
+    const blockExecutedCounter = meter.createCounter("jam.jip3.executed", {
+        description: "Block executed successfully",
+        unit: "blocks",
+    });
+    return {
+        recordBlockImportComplete(totalDurationMs, success) {
+            blockImportDuration.record(totalDurationMs, { success });
+        },
+        recordBlockImportingStarted(slot) {
+            blockImportingCounter.add(1, { slot });
+        },
+        recordBlockVerificationFailed(reason) {
+            blockVerificationFailedCounter.add(1, { reason });
+        },
+        recordBlockVerified(durationMs) {
+            blockVerifiedCounter.add(1);
+            blockVerificationDuration.record(durationMs);
+        },
+        recordBlockExecutionFailed(reason) {
+            blockExecutionFailedCounter.add(1, { reason });
+        },
+        recordBlockExecuted(durationMs, cost) {
+            blockExecutedCounter.add(1);
+            blockExecutionDuration.record(durationMs);
+            blockExecutionCost.record(cost);
+        },
+    };
+}
+
 var ImporterErrorKind;
 (function (ImporterErrorKind) {
     ImporterErrorKind[ImporterErrorKind["Verifier"] = 0] = "Verifier";
@@ -24184,11 +25046,13 @@ class Importer {
     state;
     // Hash of the block that we have the posterior state for in `state`.
     currentHash;
+    metrics;
     constructor(spec, pvm, hasher, logger, blocks, states) {
         this.hasher = hasher;
         this.logger = logger;
         this.blocks = blocks;
         this.states = states;
+        this.metrics = createMetrics();
         const currentBestHeaderHash = this.blocks.getBestHeaderHash();
         const state = states.getState(currentBestHeaderHash);
         if (state === null) {
@@ -24221,26 +25085,35 @@ class Importer {
     async importBlock(block, omitSealVerification) {
         const timer = measure("importBlock");
         const timeSlot = extractTimeSlot(block);
+        this.metrics.recordBlockImportingStarted(timeSlot);
+        const startTime = now();
         const maybeBestHeader = await this.importBlockInternal(block, omitSealVerification);
+        const duration = now() - startTime;
         if (maybeBestHeader.isOk) {
             const bestHeader = maybeBestHeader.ok;
             this.logger.info `🧊 Best block: #${timeSlot} (${bestHeader.hash})`;
             this.logger.log `${timer()}`;
+            this.metrics.recordBlockImportComplete(duration, true);
             return maybeBestHeader;
         }
         this.logger.log `❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`;
         this.logger.log `${timer()}`;
+        this.metrics.recordBlockImportComplete(duration, false);
         return maybeBestHeader;
     }
     async importBlockInternal(block, omitSealVerification = false) {
         const logger = this.logger;
         logger.log `🧱 Attempting to import a new block`;
         const timerVerify = measure("import:verify");
+        const verifyStart = now();
         const hash = await this.verifier.verifyBlock(block);
+        const verifyDuration = now() - verifyStart;
         logger.log `${timerVerify()}`;
         if (hash.isError) {
+            this.metrics.recordBlockVerificationFailed(resultToString(hash));
             return importerError(ImporterErrorKind.Verifier, hash);
         }
+        this.metrics.recordBlockVerified(verifyDuration);
         // TODO [ToDr] This is incomplete/temporary fork support!
         const parentHash = block.header.view().parentHeaderHash.materialize();
         if (!this.currentHash.isEqualTo(parentHash)) {
@@ -24260,11 +25133,15 @@ class Importer {
         const headerHash = hash.ok;
         logger.log `🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`;
         const timerStf = measure("import:stf");
+        const stfStart = now();
         const res = await this.stf.transition(block, headerHash, omitSealVerification);
+        const stfDuration = now() - stfStart;
         logger.log `${timerStf()}`;
         if (res.isError) {
+            this.metrics.recordBlockExecutionFailed(resultToString(res));
             return importerError(ImporterErrorKind.Stf, res);
         }
+        this.metrics.recordBlockExecuted(stfDuration, 0);
         // modify the state
         const update = res.ok;
         const timerState = measure("import:state");
@@ -24447,10 +25324,8 @@ class Channel {
             // listen to request incoming to worker
             this.port.on(key, val.request, async ({ responseId, data }) => {
                 try {
-                    console.log(`[${this.port.threadId}] handling ${key}. Responseid: ${responseId}`);
                     // handle them
                     const response = await handler(data);
-                    console.log(`[${this.port.threadId}] sending response: ${responseId}`);
                     // and send response back on dedicated event
                     this.port.postMessage(responseId, val.response, {
                         responseId,
@@ -24468,14 +25343,12 @@ class Channel {
         return (data) => {
             this.nextResponseId++;
             const responseId = `${key}:${this.nextResponseId}`;
-            console.log(`[${this.port.threadId}] will wait for ${key}`);
             return new Promise((resolve, reject) => {
                 this.pendingPromises.add(reject);
                 // attach response listener first
                 this.port.once(responseId, val.response, (msg) => {
                     // we got response, so will resolve
                     this.pendingPromises.delete(reject);
-                    console.log(`[${this.port.threadId}] got ${key}`);
                     resolve(msg.data);
                 });
                 // send message to the port
@@ -24504,14 +25377,16 @@ function isMessageCodecs(val) {
  * Worker config with in-thread database.
  */
 class DirectWorkerConfig {
+    nodeName;
     chainSpec;
     workerParams;
     blocksDb;
     statesDb;
-    static new({ chainSpec, blocksDb, statesDb, params, }) {
-        return new DirectWorkerConfig(chainSpec, params, blocksDb, statesDb);
+    static new({ nodeName, chainSpec, blocksDb, statesDb, params, }) {
+        return new DirectWorkerConfig(nodeName, chainSpec, params, blocksDb, statesDb);
     }
-    constructor(chainSpec, workerParams, blocksDb, statesDb) {
+    constructor(nodeName, chainSpec, workerParams, blocksDb, statesDb) {
+        this.nodeName = nodeName;
         this.chainSpec = chainSpec;
         this.workerParams = workerParams;
         this.blocksDb = blocksDb;
@@ -25043,6 +25918,7 @@ var index$2 = /*#__PURE__*/Object.freeze({
   ImporterConfig: ImporterConfig,
   WORKER: WORKER,
   createImporter: createImporter,
+  createMetrics: createMetrics,
   main: main,
   protocol: protocol
 });