@typeberry/jam 0.1.3-8fd7637 → 0.1.3-b0374a8

package/bootstrap-importer.mjs

@@ -3569,8 +3569,9 @@ function parseCurrentVersion(env) {
     }
 }
 function parseCurrentSuite(env) {
-    if (env === undefined)
+    if (env === undefined) {
         return undefined;
+    }
     switch (env) {
         case TestSuite.W3F_DAVXY:
         case TestSuite.JAMDUNA:
@@ -4001,10 +4002,12 @@ function deepEqual(actual, expected, { context = [], errorsCollector, ignore = [
                 .sort((a, b) => {
                 const aKey = `${a.key}`;
                 const bKey = `${b.key}`;
-                if (aKey < bKey)
+                if (aKey < bKey) {
                     return -1;
-                if (bKey < aKey)
+                }
+                if (bKey < aKey) {
                     return 1;
+                }
                 return 0;
             });
         };
@@ -5604,7 +5607,7 @@ class Skipper {
  *
  * Descriptors can be composed to form more complex typings.
  */
-class descriptor_Descriptor {
+class Descriptor {
     name;
     sizeHint;
     encode;
@@ -5614,11 +5617,11 @@ class descriptor_Descriptor {
     View;
     /** New descriptor with specialized `View`. */
     static withView(name, sizeHint, encode, decode, skip, view) {
-        return new descriptor_Descriptor(name, sizeHint, encode, decode, skip, view);
+        return new Descriptor(name, sizeHint, encode, decode, skip, view);
     }
     /** Create a new descriptor without a specialized `View`. */
     static new(name, sizeHint, encode, decode, skip) {
-        return new descriptor_Descriptor(name, sizeHint, encode, decode, skip, null);
+        return new Descriptor(name, sizeHint, encode, decode, skip, null);
     }
     constructor(
     /** Descriptive name of the coded data. */
@@ -5655,7 +5658,7 @@ class descriptor_Descriptor {
     }
     /** Return a new descriptor that converts data into some other type. */
     convert(input, output) {
-        return new descriptor_Descriptor(this.name, this.sizeHint, (e, elem) => this.encode(e, input(elem)), (d) => output(this.decode(d)), this.skip, this.View);
+        return new Descriptor(this.name, this.sizeHint, (e, elem) => this.encode(e, input(elem)), (d) => output(this.decode(d)), this.skip, this.View);
     }
     /** Safely cast the descriptor value to a opaque type. */
     asOpaque() {
@@ -6353,51 +6356,51 @@ var descriptors_codec;
         return (len) => {
             let ret = cache.get(len);
             if (ret === undefined) {
-                ret = descriptor_Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
+                ret = Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
                 cache.set(len, ret);
             }
             return ret;
         };
     })();
     /** Variable-length U32. */
-    codec.varU32 = descriptor_Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
+    codec.varU32 = Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
     /** Variable-length U64. */
-    codec.varU64 = descriptor_Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
+    codec.varU64 = Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
     /** Unsigned 64-bit number. */
-    codec.u64 = descriptor_Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), codec.bytes(8));
+    codec.u64 = Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), codec.bytes(8));
     /** Unsigned 32-bit number. */
-    codec.u32 = descriptor_Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), codec.bytes(4));
+    codec.u32 = Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), codec.bytes(4));
     /** Unsigned 24-bit number. */
-    codec.u24 = descriptor_Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), codec.bytes(3));
+    codec.u24 = Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), codec.bytes(3));
     /** Unsigned 16-bit number. */
-    codec.u16 = descriptor_Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), codec.bytes(2));
+    codec.u16 = Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), codec.bytes(2));
     /** Unsigned 8-bit number. */
-    codec.u8 = descriptor_Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
+    codec.u8 = Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
     /** Signed 64-bit number. */
-    codec.i64 = descriptor_Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), codec.bytes(8));
+    codec.i64 = Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), codec.bytes(8));
     /** Signed 32-bit number. */
-    codec.i32 = descriptor_Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), codec.bytes(4));
+    codec.i32 = Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), codec.bytes(4));
     /** Signed 24-bit number. */
-    codec.i24 = descriptor_Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), codec.bytes(3));
+    codec.i24 = Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), codec.bytes(3));
     /** Signed 16-bit number. */
-    codec.i16 = descriptor_Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), codec.bytes(2));
+    codec.i16 = Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), codec.bytes(2));
     /** Signed 8-bit number. */
-    codec.i8 = descriptor_Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
+    codec.i8 = Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
     /** 1-byte boolean value. */
-    codec.bool = descriptor_Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
+    codec.bool = Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
     /** Variable-length bytes blob. */
-    codec.blob = descriptor_Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
+    codec.blob = Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
     /** String encoded as variable-length bytes blob. */
-    codec.string = descriptor_Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), codec.blob);
+    codec.string = Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), codec.blob);
     /** Variable-length bit vector. */
-    codec.bitVecVarLen = descriptor_Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
+    codec.bitVecVarLen = Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
     /** Fixed-length bit vector. */
-    codec.bitVecFixLen = (bitLen) => descriptor_Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
+    codec.bitVecFixLen = (bitLen) => Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
     /** Optionality wrapper for given type. */
     codec.optional = (type) => {
-        const self = descriptor_Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
+        const self = Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
         if (hasUniqueView(type)) {
-            return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.optional(type.View));
+            return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.optional(type.View));
         }
         return self;
     };
@@ -6408,7 +6411,7 @@ var descriptors_codec;
     }) => {
         const name = `Sequence<${type.name}>[?]`;
         const typicalLength = options.typicalLength ?? TYPICAL_SEQUENCE_LENGTH;
-        return descriptor_Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
+        return Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
             validateLength(options, v.length, name);
             e.sequenceVarLen(type, v);
         }, (d) => {
@@ -6422,10 +6425,10 @@ var descriptors_codec;
         }, sequenceViewVarLen(type, options));
     };
     /** Fixed-length sequence of given type. */
-    codec.sequenceFixLen = (type, len) => descriptor_Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
+    codec.sequenceFixLen = (type, len) => Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
     /** Small dictionary codec. */
     codec.dictionary = (key, value, { sortKeys, fixedLength, }) => {
-        const self = descriptor_Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
+        const self = Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
             bytes: fixedLength !== undefined
                 ? fixedLength * addSizeHints(key.sizeHint, value.sizeHint).bytes
                 : TYPICAL_DICTIONARY_LENGTH * (addSizeHints(key.sizeHint, value.sizeHint).bytes ?? 0),
@@ -6464,13 +6467,13 @@ var descriptors_codec;
             s.sequenceFixLen(value, len);
         });
         if (hasUniqueView(value)) {
-            return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.dictionary(key, value.View, { sortKeys, fixedLength }));
+            return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.dictionary(key, value.View, { sortKeys, fixedLength }));
         }
         return self;
     };
     /** Encoding of pair of two values. */
     codec.pair = (a, b) => {
-        const self = descriptor_Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
+        const self = Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
             a.encode(e, elem[0]);
             b.encode(e, elem[1]);
         }, (d) => {
@@ -6482,14 +6485,14 @@ var descriptors_codec;
             b.skip(s);
         });
         if (hasUniqueView(a) && hasUniqueView(b)) {
-            return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.pair(a.View, b.View));
+            return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.pair(a.View, b.View));
         }
         return self;
     };
     /** Custom encoding / decoding logic. */
-    codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => descriptor_Descriptor.new(name, sizeHint, encode, decode, skip);
+    codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
     /** Choose a descriptor depending on the encoding/decoding context. */
-    codec.select = ({ name, sizeHint, }, chooser) => descriptor_Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), chooser(null).View);
+    codec.select = ({ name, sizeHint, }, chooser) => Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), chooser(null).View);
     /**
      * A descriptor for a more complex POJO.
      *
@@ -6526,7 +6529,7 @@ var descriptors_codec;
         };
         const view = objectView(Class, descriptors, sizeHint, skipper);
         // and create the descriptor for the entire class.
-        return descriptor_Descriptor.withView(Class.name, sizeHint, (e, t) => {
+        return Descriptor.withView(Class.name, sizeHint, (e, t) => {
             forEachDescriptor(descriptors, (key, descriptor) => {
                 const value = t[key];
                 descriptor.encode(e, value);
@@ -6577,7 +6580,7 @@ function objectView(Class, descriptors, sizeHint, skipper) {
             });
         }
     });
-    return descriptor_Descriptor.new(`View<${Class.name}>`, sizeHint, (e, t) => {
+    return Descriptor.new(`View<${Class.name}>`, sizeHint, (e, t) => {
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
@@ -6596,7 +6599,7 @@ function sequenceViewVarLen(type, options) {
         validateLength(options, length, name);
         return s.sequenceFixLen(type, length);
     };
-    return descriptor_Descriptor.new(name, sizeHint, (e, t) => {
+    return Descriptor.new(name, sizeHint, (e, t) => {
         validateLength(options, t.length, name);
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
@@ -6612,7 +6615,7 @@ function sequenceViewFixLen(type, { fixedLength }) {
     const skipper = (s) => s.sequenceFixLen(type, fixedLength);
     const view = type.name !== type.View.name ? `, ${type.View.name}` : "";
     const name = `SeqView<${type.name}${view}>[${fixedLength}]`;
-    return descriptor_Descriptor.new(name, sizeHint, (e, t) => {
+    return Descriptor.new(name, sizeHint, (e, t) => {
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
@@ -7628,7 +7631,7 @@ const codecFixedSizeArray = (val, len) => {
 };
 /** Codec for a hash-dictionary. */
 const codecHashDictionary = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
-    return descriptor_Descriptor.new(`HashDictionary<${value.name}>[?]`, {
+    return Descriptor.new(`HashDictionary<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
     }, (e, v) => {
@@ -9595,6 +9598,13 @@ const W_T = 128;
 /** `W_M`: The maximum number of exports in a work-package. */
 const W_X = 3_072;
 // TODO [ToDr] Not sure where these should live yet :(
+/**
+ * `S`: The minimum public service index.
+ * Services of indices below these may only be created by the Registrar.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/447a00447a00?v=0.7.2
+ */
+const MIN_PUBLIC_SERVICE_INDEX = 2 ** 16;
 /**
  * `J`: The maximum sum of dependency items in a work-report.
  *
@@ -9606,9 +9616,209 @@ const AUTHORIZATION_QUEUE_SIZE = Q;
 /** `O`: Maximal authorization pool size. */
 const MAX_AUTH_POOL_SIZE = O;
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-consts.ts
+const MAX_VALUE = 4294967295;
+const math_consts_MAX_VALUE_U64 = (/* unused pure expression or super */ null && (2n ** 63n));
+const MIN_VALUE = -(2 ** 31);
+const MAX_SHIFT_U32 = 32;
+const MAX_SHIFT_U64 = 64n;
+
+;// CONCATENATED MODULE: ./packages/jam/state/service.ts
+
+
+
+
+
+
+/**
+ * `B_S`: The basic minimum balance which all services require.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
+ */
+const BASE_SERVICE_BALANCE = 100n;
+/**
+ * `B_I`: The additional minimum balance required per item of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
+ */
+const ELECTIVE_ITEM_BALANCE = 10n;
+/**
+ * `B_L`: The additional minimum balance required per octet of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
+ */
+const ELECTIVE_BYTE_BALANCE = 1n;
+const zeroSizeHint = {
+    bytes: 0,
+    isExact: true,
+};
+/** 0-byte read, return given default value */
+const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
+/** Encode and decode object with leading version number. */
+const codecWithVersion = (val) => Descriptor.new("withVersion", {
+    bytes: val.sizeHint.bytes + 8,
+    isExact: false,
+}, (e, v) => {
+    e.varU64(0n);
+    val.encode(e, v);
+}, (d) => {
+    const version = d.varU64();
+    if (version !== 0n) {
+        throw new Error("Non-zero version is not supported!");
+    }
+    return val.decode(d);
+}, (s) => {
+    s.varU64();
+    val.skip(s);
+});
+/**
+ * Service account details.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
+ */
+class ServiceAccountInfo extends WithDebug {
+    codeHash;
+    balance;
+    accumulateMinGas;
+    onTransferMinGas;
+    storageUtilisationBytes;
+    gratisStorage;
+    storageUtilisationCount;
+    created;
+    lastAccumulation;
+    parentService;
+    static Codec = descriptors_codec.Class(ServiceAccountInfo, {
+        codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        balance: descriptors_codec.u64,
+        accumulateMinGas: descriptors_codec.u64.convert((x) => x, tryAsServiceGas),
+        onTransferMinGas: descriptors_codec.u64.convert((x) => x, tryAsServiceGas),
+        storageUtilisationBytes: descriptors_codec.u64,
+        gratisStorage: descriptors_codec.u64,
+        storageUtilisationCount: descriptors_codec.u32,
+        created: descriptors_codec.u32.convert((x) => x, common_tryAsTimeSlot),
+        lastAccumulation: descriptors_codec.u32.convert((x) => x, common_tryAsTimeSlot),
+        parentService: descriptors_codec.u32.convert((x) => x, tryAsServiceId),
+    });
+    static create(a) {
+        return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
+    }
+    /**
+     * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
+     */
+    static calculateThresholdBalance(items, bytes, gratisStorage) {
+        const storageCost = BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
+        if (storageCost < 0n) {
+            return numbers_tryAsU64(0);
+        }
+        if (storageCost >= 2n ** 64n) {
+            return numbers_tryAsU64(2n ** 64n - 1n);
+        }
+        return numbers_tryAsU64(storageCost);
+    }
+    constructor(
+    /** `a_c`: Hash of the service code. */
+    codeHash, 
+    /** `a_b`: Current account balance. */
+    balance, 
+    /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
+    accumulateMinGas, 
+    /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
+    onTransferMinGas, 
+    /** `a_o`: Total number of octets in storage. */
+    storageUtilisationBytes, 
+    /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
+    gratisStorage, 
+    /** `a_i`: Number of items in storage. */
+    storageUtilisationCount, 
+    /** `a_r`: Creation account time slot. */
+    created, 
+    /** `a_a`: Most recent accumulation time slot. */
+    lastAccumulation, 
+    /** `a_p`: Parent service ID. */
+    parentService) {
+        super();
+        this.codeHash = codeHash;
+        this.balance = balance;
+        this.accumulateMinGas = accumulateMinGas;
+        this.onTransferMinGas = onTransferMinGas;
+        this.storageUtilisationBytes = storageUtilisationBytes;
+        this.gratisStorage = gratisStorage;
+        this.storageUtilisationCount = storageUtilisationCount;
+        this.created = created;
+        this.lastAccumulation = lastAccumulation;
+        this.parentService = parentService;
+    }
+}
+class PreimageItem extends WithDebug {
+    hash;
+    blob;
+    static Codec = descriptors_codec.Class(PreimageItem, {
+        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        blob: descriptors_codec.blob,
+    });
+    static create({ hash, blob }) {
+        return new PreimageItem(hash, blob);
+    }
+    constructor(hash, blob) {
+        super();
+        this.hash = hash;
+        this.blob = blob;
+    }
+}
+class StorageItem extends WithDebug {
+    key;
+    value;
+    static Codec = descriptors_codec.Class(StorageItem, {
+        key: descriptors_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
+        value: descriptors_codec.blob,
+    });
+    static create({ key, value }) {
+        return new StorageItem(key, value);
+    }
+    constructor(key, value) {
+        super();
+        this.key = key;
+        this.value = value;
+    }
+}
+const MAX_LOOKUP_HISTORY_SLOTS = 3;
+function tryAsLookupHistorySlots(items) {
+    const knownSize = sized_array_asKnownSize(items);
+    if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
+        throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
+    }
+    return knownSize;
+}
+/** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
+class LookupHistoryItem {
+    hash;
+    length;
+    slots;
+    constructor(hash, length, 
+    /**
+     * Preimage availability history as a sequence of time slots.
+     * See PreimageStatus and the following GP fragment for more details.
+     * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
+    slots) {
+        this.hash = hash;
+        this.length = length;
+        this.slots = slots;
+    }
+    static isRequested(item) {
+        if ("slots" in item) {
+            return item.slots.length === 0;
+        }
+        return item.length === 0;
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/state/privileged-services.ts
 
 
+
+
+
 /** Dictionary entry of services that auto-accumulate every block. */
 class AutoAccumulate {
     service;
@@ -9630,39 +9840,50 @@ class AutoAccumulate {
     }
 }
 /**
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11da0111da01?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
  */
 class PrivilegedServices {
     manager;
-    authManager;
-    validatorsManager;
+    delegator;
+    registrar;
+    assigners;
     autoAccumulateServices;
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
     static Codec = descriptors_codec.Class(PrivilegedServices, {
         manager: descriptors_codec.u32.asOpaque(),
-        authManager: codecPerCore(descriptors_codec.u32.asOpaque()),
-        validatorsManager: descriptors_codec.u32.asOpaque(),
+        assigners: codecPerCore(descriptors_codec.u32.asOpaque()),
+        delegator: descriptors_codec.u32.asOpaque(),
+        registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? descriptors_codec.u32.asOpaque()
+            : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
         autoAccumulateServices: readonlyArray(descriptors_codec.sequenceVarLen(AutoAccumulate.Codec)),
     });
-    static create({ manager, authManager, validatorsManager, autoAccumulateServices }) {
-        return new PrivilegedServices(manager, authManager, validatorsManager, autoAccumulateServices);
+    static create(a) {
+        return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
     }
     constructor(
     /**
-     * `chi_m`: The first, χm, is the index of the manager service which is
-     * the service able to effect an alteration of χ from block to block,
+     * `χ_M`: Manages alteration of χ from block to block,
      * as well as bestow services with storage deposit credits.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/11a40111a801?v=0.6.7
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
      */
     manager, 
-    /** `chi_a`: Manages authorization queue one for each core. */
-    authManager, 
-    /** `chi_v`: Managers validator keys. */
-    validatorsManager, 
-    /** `chi_g`: Dictionary of services that auto-accumulate every block with their gas limit. */
+    /** `χ_V`: Managers validator keys. */
+    delegator, 
+    /**
+     * `χ_R`: Manages the creation of services in protected range.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
+     */
+    registrar, 
+    /** `χ_A`: Manages authorization queue one for each core. */
+    assigners, 
+    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
     autoAccumulateServices) {
         this.manager = manager;
-        this.authManager = authManager;
-        this.validatorsManager = validatorsManager;
+        this.delegator = delegator;
+        this.registrar = registrar;
+        this.assigners = assigners;
         this.autoAccumulateServices = autoAccumulateServices;
     }
 }
@@ -9750,7 +9971,7 @@ class RecentBlocks extends WithDebug {
  */
 class RecentBlocksHistory extends WithDebug {
     current;
-    static Codec = descriptor_Descriptor.new("RecentBlocksHistory", RecentBlocks.Codec.sizeHint, (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()), (decoder) => {
+    static Codec = Descriptor.new("RecentBlocksHistory", RecentBlocks.Codec.sizeHint, (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()), (decoder) => {
         const recentBlocks = RecentBlocks.Codec.decode(decoder);
         return RecentBlocksHistory.create(recentBlocks);
     }, (skip) => {
@@ -9947,196 +10168,6 @@ class SafroleData {
     }
 }
 
-;// CONCATENATED MODULE: ./packages/jam/state/service.ts
-
-
-
-
-
-
-/**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-const BASE_SERVICE_BALANCE = 100n;
-/**
- * `B_I`: The additional minimum balance required per item of elective service state.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
- */
-const ELECTIVE_ITEM_BALANCE = 10n;
-/**
- * `B_L`: The additional minimum balance required per octet of elective service state.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
- */
-const ELECTIVE_BYTE_BALANCE = 1n;
-const zeroSizeHint = {
-    bytes: 0,
-    isExact: true,
-};
-/** 0-byte read, return given default value */
-const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
-/** Encode and decode object with leading version number. */
-const codecWithVersion = (val) => descriptor_Descriptor.new("withVersion", {
-    bytes: val.sizeHint.bytes + 8,
-    isExact: false,
-}, (e, v) => {
-    e.varU64(0n);
-    val.encode(e, v);
-}, (d) => {
-    const version = d.varU64();
-    if (version !== 0n) {
-        throw new Error("Non-zero version is not supported!");
-    }
-    return val.decode(d);
-}, (s) => {
-    s.varU64();
-    val.skip(s);
-});
-/**
- * Service account details.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
- */
-class ServiceAccountInfo extends WithDebug {
-    codeHash;
-    balance;
-    accumulateMinGas;
-    onTransferMinGas;
-    storageUtilisationBytes;
-    gratisStorage;
-    storageUtilisationCount;
-    created;
-    lastAccumulation;
-    parentService;
-    static Codec = descriptors_codec.Class(ServiceAccountInfo, {
-        codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        balance: descriptors_codec.u64,
-        accumulateMinGas: descriptors_codec.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: descriptors_codec.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: descriptors_codec.u64,
-        gratisStorage: descriptors_codec.u64,
-        storageUtilisationCount: descriptors_codec.u32,
-        created: descriptors_codec.u32.convert((x) => x, common_tryAsTimeSlot),
-        lastAccumulation: descriptors_codec.u32.convert((x) => x, common_tryAsTimeSlot),
-        parentService: descriptors_codec.u32.convert((x) => x, tryAsServiceId),
-    });
-    static create(a) {
-        return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
-    }
-    /**
-     * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
-     */
-    static calculateThresholdBalance(items, bytes, gratisStorage) {
-        const storageCost = BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
-        if (storageCost < 0n) {
-            return numbers_tryAsU64(0);
-        }
-        if (storageCost >= 2n ** 64n) {
-            return numbers_tryAsU64(2n ** 64n - 1n);
-        }
-        return numbers_tryAsU64(storageCost);
-    }
-    constructor(
-    /** `a_c`: Hash of the service code. */
-    codeHash, 
-    /** `a_b`: Current account balance. */
-    balance, 
-    /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
-    accumulateMinGas, 
-    /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
-    onTransferMinGas, 
-    /** `a_o`: Total number of octets in storage. */
-    storageUtilisationBytes, 
-    /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
-    gratisStorage, 
-    /** `a_i`: Number of items in storage. */
-    storageUtilisationCount, 
-    /** `a_r`: Creation account time slot. */
-    created, 
-    /** `a_a`: Most recent accumulation time slot. */
-    lastAccumulation, 
-    /** `a_p`: Parent service ID. */
-    parentService) {
-        super();
-        this.codeHash = codeHash;
-        this.balance = balance;
-        this.accumulateMinGas = accumulateMinGas;
-        this.onTransferMinGas = onTransferMinGas;
-        this.storageUtilisationBytes = storageUtilisationBytes;
-        this.gratisStorage = gratisStorage;
-        this.storageUtilisationCount = storageUtilisationCount;
-        this.created = created;
-        this.lastAccumulation = lastAccumulation;
-        this.parentService = parentService;
-    }
-}
-class PreimageItem extends WithDebug {
-    hash;
-    blob;
-    static Codec = descriptors_codec.Class(PreimageItem, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        blob: descriptors_codec.blob,
-    });
-    static create({ hash, blob }) {
-        return new PreimageItem(hash, blob);
-    }
-    constructor(hash, blob) {
-        super();
-        this.hash = hash;
-        this.blob = blob;
-    }
-}
-class StorageItem extends WithDebug {
-    key;
-    value;
-    static Codec = descriptors_codec.Class(StorageItem, {
-        key: descriptors_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
-        value: descriptors_codec.blob,
-    });
-    static create({ key, value }) {
-        return new StorageItem(key, value);
-    }
-    constructor(key, value) {
-        super();
-        this.key = key;
-        this.value = value;
-    }
-}
-const MAX_LOOKUP_HISTORY_SLOTS = 3;
-function tryAsLookupHistorySlots(items) {
-    const knownSize = sized_array_asKnownSize(items);
-    if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
-        throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
-    }
-    return knownSize;
-}
-/** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
-class LookupHistoryItem {
-    hash;
-    length;
-    slots;
-    constructor(hash, length, 
-    /**
-     * Preimage availability history as a sequence of time slots.
-     * See PreimageStatus and the following GP fragment for more details.
-     * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
-    slots) {
-        this.hash = hash;
-        this.length = length;
-        this.slots = slots;
-    }
-    static isRequested(item) {
-        if ("slots" in item) {
-            return item.slots.length === 0;
-        }
-        return item.length === 0;
-    }
-}
-
 ;// CONCATENATED MODULE: ./packages/jam/state/state.ts
 /**
  * In addition to the entropy accumulator η_0, we retain
@@ -10573,6 +10604,7 @@ class StatisticsData {
 
 
 
+
 
 
 var in_memory_state_UpdateError;
@@ -10976,8 +11008,9 @@ class InMemoryState extends WithDebug {
             epochRoot: bytes_Bytes.zero(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
             privilegedServices: PrivilegedServices.create({
                 manager: tryAsServiceId(0),
-                authManager: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
-                validatorsManager: tryAsServiceId(0),
+                assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
+                delegator: tryAsServiceId(0),
+                registrar: tryAsServiceId(MAX_VALUE),
                 autoAccumulateServices: [],
             }),
             accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
@@ -11213,7 +11246,7 @@ var serialize;
  * determine the boundary of the bytes, so it can only be used
  * as the last element of the codec and can't be used in sequences!
  */
-const dumpCodec = descriptor_Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(bytes_Bytes.fromBlob(v.raw, v.raw.length)), (d) => bytes_BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
+const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(bytes_Bytes.fromBlob(v.raw, v.raw.length)), (d) => bytes_BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
 
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state.ts
 
@@ -12524,7 +12557,7 @@ const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH
     }
     return Ordering.Equal;
 }, } = {}) => {
-    return descriptor_Descriptor.new(`Map<${value.name}>[?]`, {
+    return Descriptor.new(`Map<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
     }, (e, v) => {
@@ -15113,7 +15146,7 @@ class AccumulationStateUpdate {
         if (from.privilegedServices !== null) {
             update.privilegedServices = PrivilegedServices.create({
                 ...from.privilegedServices,
-                authManager: sized_array_asKnownSize([...from.privilegedServices.authManager]),
+                assigners: sized_array_asKnownSize([...from.privilegedServices.assigners]),
             });
         }
         return update;
@@ -17252,13 +17285,6 @@ class BitOps {
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-consts.ts
-const MAX_VALUE = 4294967295;
-const math_consts_MAX_VALUE_U64 = (/* unused pure expression or super */ null && (2n ** 63n));
-const MIN_VALUE = -(2 ** 31);
-const MAX_SHIFT_U32 = 32;
-const MAX_SHIFT_U64 = 64n;
-
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-utils.ts
 
 
@@ -19288,6 +19314,8 @@ var NewServiceError;
     NewServiceError[NewServiceError["InsufficientFunds"] = 0] = "InsufficientFunds";
     /** Service is not privileged to set gratis storage. */
     NewServiceError[NewServiceError["UnprivilegedService"] = 1] = "UnprivilegedService";
+    /** Registrar attempting to create a service with already existing id. */
+    NewServiceError[NewServiceError["RegistrarServiceIdAlreadyTaken"] = 2] = "RegistrarServiceIdAlreadyTaken";
 })(NewServiceError || (NewServiceError = {}));
 var UpdatePrivilegesError;
 (function (UpdatePrivilegesError) {
@@ -19424,7 +19452,7 @@ const HostCallResult = {
     OOB: numbers_tryAsU64(0xfffffffffffffffdn), // 2**64 - 3
     /** Index unknown. */
     WHO: numbers_tryAsU64(0xfffffffffffffffcn), // 2**64 - 4
-    /** Storage full. */
+    /** Storage full or resource already allocated. */
     FULL: numbers_tryAsU64(0xfffffffffffffffbn), // 2**64 - 5
     /** Core index unknown. */
     CORE: numbers_tryAsU64(0xfffffffffffffffan), // 2**64 - 6
@@ -19432,7 +19460,7 @@ const HostCallResult = {
     CASH: numbers_tryAsU64(0xfffffffffffffff9n), // 2**64 - 7
     /** Gas limit too low. */
     LOW: numbers_tryAsU64(0xfffffffffffffff8n), // 2**64 - 8
-    /** The item is already solicited or cannot be forgotten. */
+    /** The item is already solicited, cannot be forgotten or the operation is invalid due to privilege level. */
     HUH: numbers_tryAsU64(0xfffffffffffffff7n), // 2**64 - 9
     /** The return value indicating general success. */
     OK: numbers_tryAsU64(0n),
@@ -19486,6 +19514,7 @@ function clampU64ToU32(value) {
 
 
 
+
 /**
  * Number of storage items required for ejection of the service.
  *
@@ -19577,10 +19606,13 @@ class AccumulateExternalities {
         const isExpired = status.data[1] < t - this.chainSpec.preimageExpungePeriod;
         return [isExpired, isExpired ? "" : "not expired"];
     }
-    /** `check`: https://graypaper.fluffylabs.dev/#/9a08063/303f02303f02?v=0.6.6 */
+    /** `check`: https://graypaper.fluffylabs.dev/#/ab2cdbd/30c60330c603?v=0.7.2 */
     getNextAvailableServiceId(serviceId) {
         let currentServiceId = serviceId;
-        const mod = 2 ** 32 - 2 ** 9;
+        const mod = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? 2 ** 32 - MIN_PUBLIC_SERVICE_INDEX - 2 ** 8
+            : 2 ** 32 - 2 ** 9;
+        const offset = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? MIN_PUBLIC_SERVICE_INDEX : 2 ** 8;
         for (;;) {
             const service = this.getServiceInfo(currentServiceId);
             // we found an empty id
@@ -19588,7 +19620,7 @@ class AccumulateExternalities {
                 return currentServiceId;
             }
             // keep trying
-            currentServiceId = tryAsServiceId(((currentServiceId - 2 ** 8 + 1 + mod) % mod) + 2 ** 8);
+            currentServiceId = tryAsServiceId(((currentServiceId - offset + 1 + mod) % mod) + offset);
         }
     }
     checkPreimageStatus(hash, length) {
@@ -19745,8 +19777,7 @@ class AccumulateExternalities {
         }));
         return result_Result.ok(result_OK);
     }
-    newService(codeHash, codeLength, accumulateMinGas, onTransferMinGas, gratisStorage) {
-        const newServiceId = this.nextNewServiceId;
+    newService(codeHash, codeLength, accumulateMinGas, onTransferMinGas, gratisStorage, wantedServiceId) {
         // calculate the threshold. Storage is empty, one preimage requested.
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/115901115901?v=0.6.7
         const items = numbers_tryAsU32(2 * 1 + 0);
@@ -19767,30 +19798,59 @@ class AccumulateExternalities {
         if (balanceLeftForCurrent < thresholdForCurrent || bytes.overflow) {
             return result_Result.error(NewServiceError.InsufficientFunds);
         }
+        // `a`: https://graypaper.fluffylabs.dev/#/ab2cdbd/366b02366d02?v=0.7.2
+        const newAccount = ServiceAccountInfo.create({
+            codeHash,
+            balance: thresholdForNew,
+            accumulateMinGas,
+            onTransferMinGas,
+            storageUtilisationBytes: bytes.value,
+            storageUtilisationCount: items,
+            gratisStorage,
+            created: this.currentTimeslot,
+            lastAccumulation: common_tryAsTimeSlot(0),
+            parentService: this.currentServiceId,
+        });
+        const newLookupItem = new LookupHistoryItem(codeHash.asOpaque(), clampedLength, tryAsLookupHistorySlots([]));
+        // `s`: https://graypaper.fluffylabs.dev/#/ab2cdbd/361003361003?v=0.7.2
+        const updatedCurrentAccount = ServiceAccountInfo.create({
+            ...currentService,
+            balance: numbers_tryAsU64(balanceLeftForCurrent),
+        });
+        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
+            if (wantedServiceId < MIN_PUBLIC_SERVICE_INDEX &&
+                this.currentServiceId === this.updatedState.getPrivilegedServices().registrar) {
+                // NOTE: It's safe to cast to `Number` here, bcs here service ID cannot be bigger than 2**16
+                const newServiceId = tryAsServiceId(Number(wantedServiceId));
+                if (this.getServiceInfo(newServiceId) !== null) {
+                    return result_Result.error(NewServiceError.RegistrarServiceIdAlreadyTaken);
+                }
+                // add the new service with selected ID
+                // https://graypaper.fluffylabs.dev/#/ab2cdbd/36be0336c003?v=0.7.2
+                this.updatedState.stateUpdate.services.servicesUpdates.push(UpdateService.create({
+                    serviceId: newServiceId,
+                    serviceInfo: newAccount,
+                    lookupHistory: newLookupItem,
+                }));
+                // update the balance of current service
+                // https://graypaper.fluffylabs.dev/#/ab2cdbd/36c20336c403?v=0.7.2
+                this.updatedState.updateServiceInfo(this.currentServiceId, updatedCurrentAccount);
+                return result_Result.ok(newServiceId);
+            }
+            // NOTE: in case the service is not a registrar or the requested serviceId is out of range,
+            // we completely ignore the `wantedServiceId` and assign a random one
+        }
+        const newServiceId = this.nextNewServiceId;
         // add the new service
-        // https://graypaper.fluffylabs.dev/#/7e6ff6a/36cb0236cb02?v=0.6.7
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/36e70336e903?v=0.7.2
         this.updatedState.stateUpdate.services.servicesUpdates.push(UpdateService.create({
             serviceId: newServiceId,
-            serviceInfo: ServiceAccountInfo.create({
-                codeHash,
-                balance: thresholdForNew,
-                accumulateMinGas,
-                onTransferMinGas,
-                storageUtilisationBytes: bytes.value,
-                storageUtilisationCount: items,
-                gratisStorage,
-                created: this.currentTimeslot,
-                lastAccumulation: common_tryAsTimeSlot(0),
-                parentService: this.currentServiceId,
-            }),
-            lookupHistory: new LookupHistoryItem(codeHash.asOpaque(), clampedLength, tryAsLookupHistorySlots([])),
+            serviceInfo: newAccount,
+            lookupHistory: newLookupItem,
         }));
         // update the balance of current service
-        // https://graypaper.fluffylabs.dev/#/7e6ff6a/364d03364d03?v=0.6.7
-        this.updatedState.updateServiceInfo(this.currentServiceId, ServiceAccountInfo.create({
-            ...currentService,
-            balance: numbers_tryAsU64(balanceLeftForCurrent),
-        }));
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/36ec0336ee03?v=0.7.2
+        this.updatedState.updateServiceInfo(this.currentServiceId, updatedCurrentAccount);
         // update the next service id we are going to create next
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/36a70336a703?v=0.6.7
         this.nextNewServiceId = this.getNextAvailableServiceId(bumpServiceId(newServiceId));
@@ -19808,9 +19868,9 @@ class AccumulateExternalities {
     }
     updateValidatorsData(validatorsData) {
         /** https://graypaper.fluffylabs.dev/#/7e6ff6a/362802362d02?v=0.6.7 */
-        const validatorsManager = this.updatedState.getPrivilegedServices().validatorsManager;
-        if (validatorsManager !== this.currentServiceId) {
-            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${validatorsManager}) and cannot update validators data. Ignoring`;
+        const currentDelegator = this.updatedState.getPrivilegedServices().delegator;
+        if (currentDelegator !== this.currentServiceId) {
+            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${currentDelegator}) and cannot update validators data. Ignoring`;
             return result_Result.error(UnprivilegedError);
         }
         this.updatedState.stateUpdate.validatorsData = validatorsData;
@@ -19820,34 +19880,38 @@ class AccumulateExternalities {
         /** https://graypaper.fluffylabs.dev/#/9a08063/362202362202?v=0.6.6 */
         this.checkpointedState = AccumulationStateUpdate.copyFrom(this.updatedState.stateUpdate);
     }
-    updateAuthorizationQueue(coreIndex, authQueue, authManager) {
+    updateAuthorizationQueue(coreIndex, authQueue, assigners) {
         /** https://graypaper.fluffylabs.dev/#/7e6ff6a/36a40136a401?v=0.6.7 */
         // NOTE `coreIndex` is already verified in the HC, so this is infallible.
-        const currentAuthManager = this.updatedState.getPrivilegedServices().authManager[coreIndex];
-        if (currentAuthManager !== this.currentServiceId) {
-            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAuthManager}) and cannot update authorization queue. Ignoring`;
+        const currentAssigners = this.updatedState.getPrivilegedServices().assigners[coreIndex];
+        if (currentAssigners !== this.currentServiceId) {
+            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAssigners}) and cannot update authorization queue.`;
             return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
         }
-        if (authManager === null && Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
-            accumulate_externalities_logger.trace `The new auth manager is not a valid service id. Ignoring`;
+        if (assigners === null && Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
+            accumulate_externalities_logger.trace `The new auth manager is not a valid service id.`;
             return result_Result.error(UpdatePrivilegesError.InvalidServiceId);
         }
         this.updatedState.stateUpdate.authorizationQueues.set(coreIndex, authQueue);
         return result_Result.ok(result_OK);
     }
-    updatePrivilegedServices(manager, authorizers, validatorsManager, autoAccumulate) {
+    updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate) {
         /** https://graypaper.fluffylabs.dev/#/7e6ff6a/36d90036de00?v=0.6.7 */
         const currentManager = this.updatedState.getPrivilegedServices().manager;
         if (currentManager !== this.currentServiceId) {
             return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
         }
-        if (manager === null || validatorsManager === null) {
-            return result_Result.error(UpdatePrivilegesError.InvalidServiceId);
+        if (manager === null || delegator === null) {
+            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Either manager or delegator is not valid service id.");
+        }
+        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) && registrar === null) {
+            return result_Result.error(UpdatePrivilegesError.InvalidServiceId, "Register manager is not valid service id.");
         }
         this.updatedState.stateUpdate.privilegedServices = PrivilegedServices.create({
             manager,
-            authManager: authorizers,
-            validatorsManager,
+            assigners: authorizers,
+            delegator,
+            registrar: registrar ?? tryAsServiceId(0), // introduced in 0.7.1
             autoAccumulateServices: autoAccumulate.map(([service, gasLimit]) => AutoAccumulate.create({ service, gasLimit })),
         });
         return result_Result.ok(result_OK);
@@ -19963,8 +20027,11 @@ class AccumulateExternalities {
     }
 }
 function bumpServiceId(serviceId) {
-    const mod = 2 ** 32 - 2 ** 9;
-    return tryAsServiceId(2 ** 8 + ((serviceId - 2 ** 8 + 42 + mod) % mod));
+    const mod = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+        ? 2 ** 32 - MIN_PUBLIC_SERVICE_INDEX - 2 ** 8
+        : 2 ** 32 - 2 ** 9;
+    const offset = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? MIN_PUBLIC_SERVICE_INDEX : 2 ** 8;
+    return tryAsServiceId(offset + ((serviceId - offset + 42 + mod) % mod));
 }
 
 ;// CONCATENATED MODULE: ./packages/jam/transition/accumulate/accumulate-state.ts
@@ -20620,6 +20687,8 @@ class AccumulateData {
 
 
 
+
+
 /**
  * A function that removes duplicates but does not change order - it keeps the first occurence.
  */
@@ -20649,7 +20718,7 @@ const NEXT_ID_CODEC = descriptors_codec.object({
  *
  * Please not that it does not call `check` function!
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/2f4c022f4c02?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fa9042fc304?v=0.7.2
  */
 function generateNextServiceId({ serviceId, entropy, timeslot }, chainSpec, blake2b) {
     const encoded = encoder_Encoder.encodeObject(NEXT_ID_CODEC, {
@@ -20659,7 +20728,11 @@ function generateNextServiceId({ serviceId, entropy, timeslot }, chainSpec, blak
     }, chainSpec);
     const result = blake2b.hashBytes(encoded).raw.subarray(0, 4);
     const number = leBytesAsU32(result) >>> 0;
-    return tryAsServiceId((number % (2 ** 32 - 2 ** 9)) + 2 ** 8);
+    const mod = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+        ? 2 ** 32 - MIN_PUBLIC_SERVICE_INDEX - 2 ** 8
+        : 2 ** 32 - 2 ** 9;
+    const offset = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? MIN_PUBLIC_SERVICE_INDEX : 2 ** 8;
+    return tryAsServiceId((number % mod) + offset);
 }
 
 ;// CONCATENATED MODULE: ./packages/jam/transition/accumulate/accumulate-queue.ts
@@ -21071,7 +21144,7 @@ class Assign {
         // o
         const authorizationQueueStart = regs.get(8);
         // a
-        const authManager = getServiceId(regs.get(9));
+        const assigners = getServiceId(regs.get(9));
         const res = safeAllocUint8Array(hash_HASH_SIZE * AUTHORIZATION_QUEUE_SIZE);
         const memoryReadResult = memory.loadInto(res, authorizationQueueStart);
         // error while reading the memory.
@@ -21088,7 +21161,7 @@ class Assign {
         const decoder = decoder_Decoder.fromBlob(res);
         const authQueue = decoder.sequenceFixLen(descriptors_codec.bytes(hash_HASH_SIZE), AUTHORIZATION_QUEUE_SIZE);
         const fixedSizeAuthQueue = FixedSizeArray.new(authQueue, AUTHORIZATION_QUEUE_SIZE);
-        const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, authManager);
+        const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
             regs.set(IN_OUT_REG, HostCallResult.OK);
             logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`;
@@ -21137,7 +21210,9 @@ class Bless {
     chainSpec;
     index = host_call_handler_tryAsHostCallIndex(14);
     basicGasCost = gas_tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(bless_IN_OUT_REG, 8, 9, 10, 11);
+    tracedRegisters = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+        ? traceRegisters(bless_IN_OUT_REG, 8, 9, 10, 11, 12)
+        : traceRegisters(bless_IN_OUT_REG, 8, 9, 10, 11);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
@@ -21147,14 +21222,17 @@ class Bless {
         // `m`: manager service (can change privileged services)
         const manager = getServiceId(regs.get(bless_IN_OUT_REG));
         // `a`: manages authorization queue
-        // NOTE It can be either ServiceId (pre GP 067) or memory index (GP ^067)
         const authorization = regs.get(8);
         // `v`: manages validator keys
-        const validator = getServiceId(regs.get(9));
+        const delegator = getServiceId(regs.get(9));
+        // `r`: manages creation of new services with id within protected range
+        const registrar = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? getServiceId(regs.get(10))
+            : tryAsServiceId(2 ** 32 - 1);
         // `o`: memory offset
-        const sourceStart = regs.get(10);
+        const sourceStart = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? regs.get(11) : regs.get(10);
         // `n`: number of items in the auto-accumulate dictionary
-        const numberOfItems = regs.get(11);
+        const numberOfItems = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? regs.get(12) : regs.get(11);
         /*
          * `z`: array of key-value pairs serviceId -> gas that auto-accumulate every block
          * https://graypaper.fluffylabs.dev/#/7e6ff6a/368100368100?v=0.6.7
@@ -21168,7 +21246,7 @@ class Bless {
             decoder.resetTo(0);
             const memoryReadResult = memory.loadInto(result, memIndex);
             if (memoryReadResult.isError) {
-                logger_logger.trace `BLESS(${manager}, ${validator}) <- PANIC`;
+                logger_logger.trace `BLESS(${manager}, ${delegator}, ${registrar}) <- PANIC`;
                 return PvmExecution.Panic;
             }
             const { serviceId, gas } = decoder.object(serviceIdAndGasCodec);
@@ -21181,24 +21259,25 @@ class Bless {
         const authorizersDecoder = decoder_Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
-            logger_logger.trace `BLESS(${manager}, ${validator}, ${autoAccumulateEntries}) <- PANIC`;
+            logger_logger.trace `BLESS(${manager}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- 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, validator, autoAccumulateEntries);
+        const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulateEntries);
         if (updateResult.isOk) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- OK`;
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- OK`;
             regs.set(bless_IN_OUT_REG, HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- HUH`;
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- HUH`;
             regs.set(bless_IN_OUT_REG, HostCallResult.HUH);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- WHO`;
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${delegator}, ${registrar}, ${autoAccumulateEntries}) <- WHO`;
             regs.set(bless_IN_OUT_REG, HostCallResult.WHO);
             return;
         }
@@ -21450,7 +21529,9 @@ class New {
     partialState;
     index = host_call_handler_tryAsHostCallIndex(18);
     basicGasCost = gas_tryAsSmallGas(10);
-    tracedRegisters = traceRegisters(new_IN_OUT_REG, 8, 9, 10, 11);
+    tracedRegisters = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+        ? traceRegisters(new_IN_OUT_REG, 8, 9, 10, 11, 12)
+        : traceRegisters(new_IN_OUT_REG, 8, 9, 10, 11);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
@@ -21466,16 +21547,18 @@ class New {
         const allowance = tryAsServiceGas(regs.get(10));
         // `f`
         const gratisStorage = regs.get(11);
+        // `i`: requested service id. Ignored if current service is not registrar or value is bigger than `S`.
+        const requestedServiceId = regs.get(12);
         // `c`
         const codeHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- PANIC`;
+            logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- PANIC`;
             return PvmExecution.Panic;
         }
-        const assignedId = this.partialState.newService(codeHash.asOpaque(), codeLength, gas, allowance, gratisStorage);
-        logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- ${resultToString(assignedId)}`;
+        const assignedId = this.partialState.newService(codeHash.asOpaque(), codeLength, gas, allowance, gratisStorage, requestedServiceId);
+        logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}, ${requestedServiceId}) <- ${resultToString(assignedId)}`;
         if (assignedId.isOk) {
             regs.set(new_IN_OUT_REG, numbers_tryAsU64(assignedId.ok));
             return;
@@ -21489,6 +21572,11 @@ class New {
             regs.set(new_IN_OUT_REG, HostCallResult.HUH);
             return;
         }
+        // Post 0.7.1
+        if (e === NewServiceError.RegistrarServiceIdAlreadyTaken) {
+            regs.set(new_IN_OUT_REG, HostCallResult.FULL);
+            return;
+        }
         debug_assertNever(e);
     }
 }
@@ -22897,17 +22985,17 @@ class Accumulate {
             statistics.set(serviceId, serviceStatistics);
             currentState = stateUpdate === null ? checkpoint : stateUpdate;
             if (Compatibility.is(GpVersion.V0_7_0) && serviceId === currentManager) {
-                const newV = currentState.privilegedServices?.validatorsManager;
+                const newV = currentState.privilegedServices?.delegator;
                 if (currentState.privilegedServices !== null && newV !== undefined && serviceIds.includes(newV)) {
-                    accumulate_logger.info `Entering completely incorrect code that probably reverts validatorsManager change. This is valid in 0.7.0 only and incorrect in 0.7.1+`;
+                    accumulate_logger.info `Entering completely incorrect code that probably reverts delegator change. This is valid in 0.7.0 only and incorrect in 0.7.1+`;
                     // Since serviceIds already contains newV, this service gets accumulated twice.
                     // To avoid double-counting, we skip stats and gas cost tracking here.
-                    // We need this accumulation to get the correct `validatorsManager`
+                    // We need this accumulation to get the correct `delegator`
                     const { stateUpdate } = await this.accumulateSingleService(newV, [], accumulateData.getOperands(newV), accumulateData.getGasCost(newV), slot, entropy, checkpoint);
-                    const correctV = stateUpdate?.privilegedServices?.validatorsManager ?? this.state.privilegedServices.validatorsManager;
+                    const correctV = stateUpdate?.privilegedServices?.delegator ?? this.state.privilegedServices.delegator;
                     currentState.privilegedServices = PrivilegedServices.create({
                         ...currentState.privilegedServices,
-                        validatorsManager: correctV,
+                        delegator: correctV,
                     });
                 }
             }