@typeberry/jam 0.1.3-c2321fb → 0.1.3-ca63b35

package/bootstrap-importer.mjs

@@ -2753,7 +2753,7 @@ module.exports = __nccwpck_require__.p + "e2fdc1b646378dd96eda.js?ed25519_wasm_b
 
 /***/ }),
 
-/***/ 566:
+/***/ 185:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 module.exports = __nccwpck_require__.p + "ccf8ada94096a8f232f5.js?reed_solomon_wasm_bg.wasm";
@@ -3452,7 +3452,7 @@ async function __wbg_init(module_or_path) {
 	if (wasm !== void 0) return wasm;
 	if (typeof module_or_path !== "undefined") if (Object.getPrototypeOf(module_or_path) === Object.prototype) ({module_or_path} = module_or_path);
 	else console.warn("using deprecated parameters for the initialization function; pass a single object instead");
-	if (typeof module_or_path === "undefined") module_or_path = new URL(/* asset import */ __nccwpck_require__(566), __nccwpck_require__.b);
+	if (typeof module_or_path === "undefined") module_or_path = new URL(/* asset import */ __nccwpck_require__(185), __nccwpck_require__.b);
 	const imports = __wbg_get_imports();
 	if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) module_or_path = fetch(module_or_path);
 	__wbg_init_memory(imports);
@@ -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) => {
@@ -6741,6 +6744,49 @@ function hashBlobs(hasher, blobs) {
 
 
 
+;// CONCATENATED MODULE: ./packages/core/collections/array-view.ts
+
+/**
+ * A utility class providing a readonly view over a portion of an array without copying it.
+ */
+class ArrayView {
+    start;
+    end;
+    source;
+    length;
+    constructor(source, start, end) {
+        this.start = start;
+        this.end = end;
+        this.source = source;
+        this.length = end - start;
+    }
+    static from(source, start = 0, end = source.length) {
+        debug_check `
+      ${start >= 0 && end <= source.length && start <= end} 
+      Invalid start (${start})/end (${end}) for ArrayView 
+    `;
+        return new ArrayView(source, start, end);
+    }
+    get(i) {
+        debug_check `
+      ${i >= 0 && i < this.length}
+      Index out of bounds: ${i} < ${this.length}
+    `;
+        return this.source[this.start + i];
+    }
+    subview(from, to = this.length) {
+        return ArrayView.from(this.source, this.start + from, this.start + to);
+    }
+    toArray() {
+        return this.source.slice(this.start, this.end);
+    }
+    *[Symbol.iterator]() {
+        for (let i = this.start; i < this.end; i++) {
+            yield this.source[i];
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/collections/hash-dictionary.ts
 /** A map which uses hashes as keys. */
 class hash_dictionary_HashDictionary {
@@ -7352,6 +7398,7 @@ class TruncatedHashDictionary {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/config/chain-spec.ts
 
 
@@ -7584,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) => {
@@ -9551,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.
  *
@@ -9562,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;
@@ -9586,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;
     }
 }
@@ -9706,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) => {
@@ -9821,258 +10086,85 @@ var SafroleSealingKeysKind;
 const codecBandersnatchKey = descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
 class SafroleSealingKeysData extends WithDebug {
     kind;
-    keys;
-    tickets;
-    static Codec = codecWithContext((context) => {
-        return descriptors_codec.custom({
-            name: "SafroleSealingKeys",
-            sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
-        }, (e, x) => {
-            e.varU32(numbers_tryAsU32(x.kind));
-            if (x.kind === SafroleSealingKeysKind.Keys) {
-                e.sequenceFixLen(codecBandersnatchKey, x.keys);
-            }
-            else {
-                e.sequenceFixLen(Ticket.Codec, x.tickets);
-            }
-        }, (d) => {
-            const epochLength = context.epochLength;
-            const kind = d.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
-                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
-                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        }, (s) => {
-            const kind = s.decoder.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
-                return;
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                s.sequenceFixLen(Ticket.Codec, context.epochLength);
-                return;
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        });
-    });
-    static keys(keys) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
-    }
-    static tickets(tickets) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
-    }
-    constructor(kind, keys, tickets) {
-        super();
-        this.kind = kind;
-        this.keys = keys;
-        this.tickets = tickets;
-    }
-}
-class SafroleData {
-    nextValidatorData;
-    epochRoot;
-    sealingKeySeries;
-    ticketsAccumulator;
-    static Codec = descriptors_codec.Class(SafroleData, {
-        nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
-        sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
-    });
-    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
-        return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
-    }
-    constructor(
-    /** gamma_k */
-    nextValidatorData, 
-    /** gamma_z */
-    epochRoot, 
-    /** gamma_s */
-    sealingKeySeries, 
-    /** gamma_a */
-    ticketsAccumulator) {
-        this.nextValidatorData = nextValidatorData;
-        this.epochRoot = epochRoot;
-        this.sealingKeySeries = sealingKeySeries;
-        this.ticketsAccumulator = ticketsAccumulator;
-    }
-}
-
-;// 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) => { });
-/**
- * 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,
+    keys;
+    tickets;
+    static Codec = codecWithContext((context) => {
+        return descriptors_codec.custom({
+            name: "SafroleSealingKeys",
+            sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
+        }, (e, x) => {
+            e.varU32(numbers_tryAsU32(x.kind));
+            if (x.kind === SafroleSealingKeysKind.Keys) {
+                e.sequenceFixLen(codecBandersnatchKey, x.keys);
+            }
+            else {
+                e.sequenceFixLen(Ticket.Codec, x.tickets);
+            }
+        }, (d) => {
+            const epochLength = context.epochLength;
+            const kind = d.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
+                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
+                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        }, (s) => {
+            const kind = s.decoder.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
+                return;
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                s.sequenceFixLen(Ticket.Codec, context.epochLength);
+                return;
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        });
     });
-    static create({ hash, blob }) {
-        return new PreimageItem(hash, blob);
-    }
-    constructor(hash, blob) {
-        super();
-        this.hash = hash;
-        this.blob = blob;
+    static keys(keys) {
+        return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
     }
-}
-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);
+    static tickets(tickets) {
+        return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
     }
-    constructor(key, value) {
+    constructor(kind, keys, tickets) {
         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.`);
+        this.kind = kind;
+        this.keys = keys;
+        this.tickets = tickets;
     }
-    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;
+class SafroleData {
+    nextValidatorData;
+    epochRoot;
+    sealingKeySeries;
+    ticketsAccumulator;
+    static Codec = descriptors_codec.Class(SafroleData, {
+        nextValidatorData: codecPerValidator(ValidatorData.Codec),
+        epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        sealingKeySeries: SafroleSealingKeysData.Codec,
+        ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+    });
+    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
+        return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
     }
-    static isRequested(item) {
-        if ("slots" in item) {
-            return item.slots.length === 0;
-        }
-        return item.length === 0;
+    constructor(
+    /** gamma_k */
+    nextValidatorData, 
+    /** gamma_z */
+    epochRoot, 
+    /** gamma_s */
+    sealingKeySeries, 
+    /** gamma_a */
+    ticketsAccumulator) {
+        this.nextValidatorData = nextValidatorData;
+        this.epochRoot = epochRoot;
+        this.sealingKeySeries = sealingKeySeries;
+        this.ticketsAccumulator = ticketsAccumulator;
     }
 }
 
@@ -10512,6 +10604,7 @@ class StatisticsData {
 
 
 
+
 
 
 var in_memory_state_UpdateError;
@@ -10915,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, []),
@@ -11010,6 +11104,7 @@ class NotYetAccumulatedReport extends WithDebug {
 
 
 
+
 /** Serialization for particular state entries. */
 var serialize;
 (function (serialize) {
@@ -11124,7 +11219,9 @@ var serialize;
     /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
     serialize.serviceData = (serviceId) => ({
         key: stateKeys.serviceInfo(serviceId),
-        Codec: ServiceAccountInfo.Codec,
+        Codec: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? codecWithVersion(ServiceAccountInfo.Codec)
+            : ServiceAccountInfo.Codec,
     });
     /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
     serialize.serviceStorage = (blake2b, serviceId, key) => ({
@@ -11149,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
 
@@ -12460,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) => {
@@ -15049,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;
@@ -17188,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
 
 
@@ -19224,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) {
@@ -19360,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
@@ -19368,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),
@@ -19422,6 +19514,7 @@ function clampU64ToU32(value) {
 
 
 
+
 /**
  * Number of storage items required for ejection of the service.
  *
@@ -19513,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
@@ -19524,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) {
@@ -19681,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);
@@ -19703,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));
@@ -19744,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;
@@ -19756,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);
@@ -19899,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
@@ -20143,6 +20274,44 @@ function signingPayload(blake2b, anchor, blob) {
 
 
 
+var TransferOperandKind;
+(function (TransferOperandKind) {
+    TransferOperandKind[TransferOperandKind["OPERAND"] = 0] = "OPERAND";
+    TransferOperandKind[TransferOperandKind["TRANSFER"] = 1] = "TRANSFER";
+})(TransferOperandKind || (TransferOperandKind = {}));
+const TRANSFER_OR_OPERAND = descriptors_codec.custom({
+    name: "TransferOrOperand",
+    sizeHint: { bytes: 1, isExact: false },
+}, (e, x) => {
+    e.varU32(numbers_tryAsU32(x.kind));
+    if (x.kind === TransferOperandKind.OPERAND) {
+        e.object(Operand.Codec, x.value);
+    }
+    if (x.kind === TransferOperandKind.TRANSFER) {
+        e.object(PendingTransfer.Codec, x.value);
+    }
+}, (d) => {
+    const kind = d.varU32();
+    if (kind === TransferOperandKind.OPERAND) {
+        return {
+            kind: TransferOperandKind.OPERAND,
+            value: d.object(Operand.Codec),
+        };
+    }
+    if (kind === TransferOperandKind.TRANSFER) {
+        return { kind: TransferOperandKind.TRANSFER, value: d.object(PendingTransfer.Codec) };
+    }
+    throw new Error(`Unable to decode TransferOrOperand. Invalid kind: ${kind}.`);
+}, (s) => {
+    const kind = s.decoder.varU32();
+    if (kind === TransferOperandKind.OPERAND) {
+        s.object(Operand.Codec);
+    }
+    if (kind === TransferOperandKind.TRANSFER) {
+        s.object(PendingTransfer.Codec);
+    }
+});
+const TRANSFERS_AND_OPERANDS = descriptors_codec.sequenceVarLen(TRANSFER_OR_OPERAND);
 // https://github.com/gavofyork/graypaper/pull/414
 // 0.7.0 encoding is used for prior versions as well.
 const CONSTANTS_CODEC = descriptors_codec.object({
@@ -20227,7 +20396,10 @@ function getEncodedConstants(chainSpec) {
 var FetchContext;
 (function (FetchContext) {
     FetchContext[FetchContext["Accumulate"] = 0] = "Accumulate";
-    FetchContext[FetchContext["OnTransfer"] = 1] = "OnTransfer";
+    /** @deprecated since 0.7.1 */
+    FetchContext[FetchContext["LegacyAccumulate"] = 1] = "LegacyAccumulate";
+    /** @deprecated since 0.7.1 */
+    FetchContext[FetchContext["LegacyOnTransfer"] = 2] = "LegacyOnTransfer";
 })(FetchContext || (FetchContext = {}));
 class FetchExternalities {
     fetchData;
@@ -20236,11 +20408,14 @@ class FetchExternalities {
         this.fetchData = fetchData;
         this.chainSpec = chainSpec;
     }
+    static createForPre071Accumulate(fetchData, chainSpec) {
+        return new FetchExternalities({ context: FetchContext.LegacyAccumulate, ...fetchData }, chainSpec);
+    }
     static createForAccumulate(fetchData, chainSpec) {
         return new FetchExternalities({ context: FetchContext.Accumulate, ...fetchData }, chainSpec);
     }
     static createForOnTransfer(fetchData, chainSpec) {
-        return new FetchExternalities({ context: FetchContext.OnTransfer, ...fetchData }, chainSpec);
+        return new FetchExternalities({ context: FetchContext.LegacyOnTransfer, ...fetchData }, chainSpec);
     }
     constants() {
         return getEncodedConstants(this.chainSpec);
@@ -20283,46 +20458,73 @@ class FetchExternalities {
         return null;
     }
     allOperands() {
-        if (this.fetchData.context !== FetchContext.Accumulate) {
-            return null;
+        if (this.fetchData.context === FetchContext.LegacyAccumulate) {
+            const operands = this.fetchData.operands;
+            return encoder_Encoder.encodeObject(descriptors_codec.sequenceVarLen(Operand.Codec), operands, this.chainSpec);
         }
-        const operands = this.fetchData.operands;
-        return encoder_Encoder.encodeObject(descriptors_codec.sequenceVarLen(Operand.Codec), operands, this.chainSpec);
+        return null;
     }
     oneOperand(operandIndex) {
-        if (this.fetchData.context !== FetchContext.Accumulate) {
-            return null;
-        }
-        const { operands } = this.fetchData;
-        if (operandIndex >= 2n ** 32n) {
-            return null;
-        }
-        const operand = operands[Number(operandIndex)];
-        if (operand === undefined) {
-            return null;
+        if (this.fetchData.context === FetchContext.LegacyAccumulate) {
+            const { operands } = this.fetchData;
+            if (operandIndex >= 2n ** 32n) {
+                return null;
+            }
+            const operand = operands[Number(operandIndex)];
+            if (operand === undefined) {
+                return null;
+            }
+            return encoder_Encoder.encodeObject(Operand.Codec, operand, this.chainSpec);
         }
-        return encoder_Encoder.encodeObject(Operand.Codec, operand, this.chainSpec);
+        return null;
     }
     allTransfers() {
-        if (this.fetchData.context !== FetchContext.OnTransfer) {
-            return null;
+        if (this.fetchData.context === FetchContext.LegacyOnTransfer) {
+            const { transfers } = this.fetchData;
+            return encoder_Encoder.encodeObject(descriptors_codec.sequenceVarLen(PendingTransfer.Codec), transfers, this.chainSpec);
         }
-        const { transfers } = this.fetchData;
-        return encoder_Encoder.encodeObject(descriptors_codec.sequenceVarLen(PendingTransfer.Codec), transfers, this.chainSpec);
+        return null;
     }
     oneTransfer(transferIndex) {
-        if (this.fetchData.context !== FetchContext.OnTransfer) {
-            return null;
+        if (this.fetchData.context === FetchContext.LegacyOnTransfer) {
+            const { transfers } = this.fetchData;
+            if (transferIndex >= 2n ** 32n) {
+                return null;
+            }
+            const transfer = transfers[Number(transferIndex)];
+            if (transfer === undefined) {
+                return null;
+            }
+            return encoder_Encoder.encodeObject(PendingTransfer.Codec, transfer, this.chainSpec);
         }
-        const { transfers } = this.fetchData;
-        if (transferIndex >= 2n ** 32n) {
-            return null;
+        return null;
+    }
+    allTransfersAndOperands() {
+        if (this.fetchData.context === FetchContext.Accumulate) {
+            const { transfers, operands } = this.fetchData;
+            const transfersAndOperands = transfers
+                .map((transfer) => ({ kind: TransferOperandKind.TRANSFER, value: transfer }))
+                .concat(operands.map((operand) => ({ kind: TransferOperandKind.OPERAND, value: operand })));
+            return encoder_Encoder.encodeObject(TRANSFERS_AND_OPERANDS, transfersAndOperands, this.chainSpec);
         }
-        const transfer = transfers[Number(transferIndex)];
-        if (transfer === undefined) {
-            return null;
+        return null;
+    }
+    oneTransferOrOperand(index) {
+        if (this.fetchData.context === FetchContext.Accumulate) {
+            const { operands, transfers } = this.fetchData;
+            if (index >= operands.length + transfers.length) {
+                return null;
+            }
+            const kind = index < operands.length ? TransferOperandKind.OPERAND : TransferOperandKind.TRANSFER;
+            const transferOrOperand = kind === TransferOperandKind.OPERAND
+                ? { kind: TransferOperandKind.OPERAND, value: operands[Number(index)] }
+                : { kind: TransferOperandKind.TRANSFER, value: transfers[Number(index) - operands.length] };
+            if (transferOrOperand.value === undefined) {
+                return null;
+            }
+            return encoder_Encoder.encodeObject(TRANSFER_OR_OPERAND, transferOrOperand, this.chainSpec);
         }
-        return encoder_Encoder.encodeObject(PendingTransfer.Codec, transfer, this.chainSpec);
+        return null;
     }
 }
 
@@ -20355,31 +20557,45 @@ class AccumulateDataItem {
  */
 class AccumulateData {
     reportsDataByServiceId;
+    transfersByServiceId;
     autoAccumulateServicesByServiceId;
     serviceIds;
-    constructor(reports, autoAccumulateServices) {
+    constructor(reports, transfers, autoAccumulateServices) {
         const { autoAccumulateServicesByServiceId, serviceIds: serviceIdsFromAutoAccumulate } = this.transformAutoAccumulateServices(autoAccumulateServices);
         this.autoAccumulateServicesByServiceId = autoAccumulateServicesByServiceId;
         const { reportsDataByServiceId, serviceIds: serviceIdsFromReports } = this.transformReports(reports);
         this.reportsDataByServiceId = reportsDataByServiceId;
+        const { transfersByServiceId, serviceIds: serviceIdsFromTransfers } = this.transformTransfers(transfers);
+        this.transfersByServiceId = transfersByServiceId;
         /**
-         * Merge service ids from reports and auto-accumulate services.
+         * Merge service ids from reports, auto-accumulate services and transfers.
          *
          * https://graypaper.fluffylabs.dev/#/68eaa1f/175f01175f01?v=0.6.4
          */
-        this.serviceIds = this.mergeServiceIds(serviceIdsFromReports, serviceIdsFromAutoAccumulate);
+        this.serviceIds = this.mergeServiceIds(serviceIdsFromReports, serviceIdsFromAutoAccumulate, serviceIdsFromTransfers);
     }
     /** Merge two sets of service ids */
-    mergeServiceIds(source1, source2) {
+    mergeServiceIds(...sources) {
         const merged = new Set();
-        for (const serviceId of source1) {
-            merged.add(serviceId);
-        }
-        for (const serviceId of source2) {
-            merged.add(serviceId);
+        for (const source of sources) {
+            for (const serviceId of source) {
+                merged.add(serviceId);
+            }
         }
         return Array.from(merged);
     }
+    transformTransfers(transfersToTransform) {
+        const transfersByServiceId = new Map();
+        const serviceIds = new Set();
+        for (const transfer of transfersToTransform) {
+            const serviceId = transfer.destination;
+            const transfers = transfersByServiceId.get(serviceId) ?? [];
+            transfers.push(transfer);
+            transfersByServiceId.set(serviceId, transfers);
+            serviceIds.add(serviceId);
+        }
+        return { transfersByServiceId, serviceIds };
+    }
     /** Transform the list of auto-accumulate services into a map by service id. */
     transformAutoAccumulateServices(autoAccumulateServices) {
         const serviceIds = new Set();
@@ -20443,6 +20659,10 @@ class AccumulateData {
     getOperands(serviceId) {
         return this.reportsDataByServiceId.get(serviceId)?.operands ?? [];
     }
+    /** Returns the list of transfers for a given service id */
+    getTransfers(serviceId) {
+        return this.transfersByServiceId.get(serviceId) ?? [];
+    }
     /** Returns the number of reports to acccumulate for a given service id */
     getReportsLength(serviceId) {
         return this.reportsDataByServiceId.get(serviceId)?.reportsLength ?? numbers_tryAsU32(0);
@@ -20467,6 +20687,8 @@ class AccumulateData {
 
 
 
+
+
 /**
  * A function that removes duplicates but does not change order - it keeps the first occurence.
  */
@@ -20496,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, {
@@ -20506,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
@@ -20918,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.
@@ -20935,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`;
@@ -20984,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;
@@ -20994,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
@@ -21015,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);
@@ -21028,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;
         }
@@ -21297,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;
@@ -21313,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;
@@ -21336,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);
     }
 }
@@ -21705,6 +21946,7 @@ class Yield {
 
 
 
+
 const fetch_IN_OUT_REG = 7;
 /**
  * https://graypaper.fluffylabs.dev/#/7e6ff6a/324000324000?v=0.6.7
@@ -21793,19 +22035,30 @@ class Fetch {
             const workItem = regs.get(11);
             return this.fetch.workItemPayload(workItem);
         }
-        if (kind === FetchKind.AllOperands) {
-            return this.fetch.allOperands();
-        }
-        if (kind === FetchKind.OneOperand) {
-            const index = regs.get(11);
-            return this.fetch.oneOperand(index);
-        }
-        if (kind === FetchKind.AllTransfers) {
-            return this.fetch.allTransfers();
+        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
+            if (kind === FetchKind.AllTransfersAndOperands) {
+                return this.fetch.allTransfersAndOperands();
+            }
+            if (kind === FetchKind.OneTransferOrOperand) {
+                const index = regs.get(11);
+                return this.fetch.oneTransferOrOperand(index);
+            }
         }
-        if (kind === FetchKind.OneTransfer) {
-            const index = regs.get(11);
-            return this.fetch.oneTransfer(index);
+        else {
+            if (kind === FetchKind.LegacyAllOperands) {
+                return this.fetch.allOperands();
+            }
+            if (kind === FetchKind.LegacyOneOperand) {
+                const index = regs.get(11);
+                return this.fetch.oneOperand(index);
+            }
+            if (kind === FetchKind.LegacyAllTransfers) {
+                return this.fetch.allTransfers();
+            }
+            if (kind === FetchKind.LegacyOneTransfer) {
+                const index = regs.get(11);
+                return this.fetch.oneTransfer(index);
+            }
         }
         return null;
     }
@@ -21826,10 +22079,12 @@ var FetchKind;
     FetchKind[FetchKind["AllWorkItems"] = 11] = "AllWorkItems";
     FetchKind[FetchKind["OneWorkItem"] = 12] = "OneWorkItem";
     FetchKind[FetchKind["WorkItemPayload"] = 13] = "WorkItemPayload";
-    FetchKind[FetchKind["AllOperands"] = 14] = "AllOperands";
-    FetchKind[FetchKind["OneOperand"] = 15] = "OneOperand";
-    FetchKind[FetchKind["AllTransfers"] = 16] = "AllTransfers";
-    FetchKind[FetchKind["OneTransfer"] = 17] = "OneTransfer";
+    FetchKind[FetchKind["LegacyAllOperands"] = 14] = "LegacyAllOperands";
+    FetchKind[FetchKind["AllTransfersAndOperands"] = 14] = "AllTransfersAndOperands";
+    FetchKind[FetchKind["LegacyOneOperand"] = 15] = "LegacyOneOperand";
+    FetchKind[FetchKind["OneTransferOrOperand"] = 15] = "OneTransferOrOperand";
+    FetchKind[FetchKind["LegacyAllTransfers"] = 16] = "LegacyAllTransfers";
+    FetchKind[FetchKind["LegacyOneTransfer"] = 17] = "LegacyOneTransfer";
 })(FetchKind || (FetchKind = {}));
 
 ;// CONCATENATED MODULE: ./packages/jam/jam-host-calls/info.ts
@@ -22526,7 +22781,7 @@ const accumulate_logger = Logger.new(import.meta.filename, "accumulate");
 const ARGS_CODEC = descriptors_codec.object({
     slot: descriptors_codec.varU32.asOpaque(),
     serviceId: descriptors_codec.varU32.asOpaque(),
-    operands: descriptors_codec.varU32,
+    argsLength: descriptors_codec.varU32,
 });
 class Accumulate {
     chainSpec;
@@ -22546,7 +22801,7 @@ class Accumulate {
         const reportsLength = reports.length;
         let currentGas = 0n;
         for (let i = 0; i < reportsLength; i++) {
-            const report = reports[i];
+            const report = reports.get(i);
             const resultsGas = report.results.map((result) => result.gas).reduce((a, b) => a + b, 0n);
             if (currentGas + resultsGas > gasLimit) {
                 return i;
@@ -22560,7 +22815,7 @@ class Accumulate {
      *
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/2fdb012fdb01?v=0.6.7
      */
-    async pvmAccumulateInvocation(slot, serviceId, operands, gas, entropy, inputStateUpdate) {
+    async pvmAccumulateInvocation(slot, serviceId, transfers, operands, gas, entropy, inputStateUpdate) {
         const service = this.state.getService(serviceId);
         if (service === null) {
             accumulate_logger.log `Service with id ${serviceId} not found.`;
@@ -22579,14 +22834,21 @@ class Accumulate {
         }
         const nextServiceId = generateNextServiceId({ serviceId, entropy, timeslot: slot }, this.chainSpec, this.blake2b);
         const partialState = new AccumulateExternalities(this.chainSpec, this.blake2b, new PartiallyUpdatedState(this.state, inputStateUpdate), serviceId, nextServiceId, slot);
+        const fetchExternalities = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? FetchExternalities.createForAccumulate({ entropy, transfers, operands }, this.chainSpec)
+            : FetchExternalities.createForPre071Accumulate({ entropy, operands }, this.chainSpec);
         const externalities = {
             partialState,
             serviceExternalities: partialState,
-            fetchExternalities: FetchExternalities.createForAccumulate({ entropy, operands }, this.chainSpec),
+            fetchExternalities,
         };
         const executor = PvmExecutor.createAccumulateExecutor(serviceId, code, externalities, this.chainSpec);
-        const args = encoder_Encoder.encodeObject(ARGS_CODEC, { slot, serviceId, operands: numbers_tryAsU32(operands.length) });
-        const result = await executor.run(args, tryAsGas(gas));
+        const invocationArgs = encoder_Encoder.encodeObject(ARGS_CODEC, {
+            slot,
+            serviceId,
+            argsLength: numbers_tryAsU32(transfers.length + operands.length),
+        });
+        const result = await executor.run(invocationArgs, tryAsGas(gas));
         const [newState, checkpoint] = partialState.getStateUpdates();
         /**
          * PVM invocation returned and error so we return the checkpoint
@@ -22623,9 +22885,9 @@ class Accumulate {
      *
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/18d70118d701?v=0.6.7
      */
-    async accumulateSingleService(serviceId, operands, gasCost, slot, entropy, inputStateUpdate) {
-        accumulate_logger.log `Accumulating service ${serviceId}, items: ${operands.length} at slot: ${slot}.`;
-        const result = await this.pvmAccumulateInvocation(slot, serviceId, operands, gasCost, entropy, inputStateUpdate);
+    async accumulateSingleService(serviceId, transfers, operands, gasCost, slot, entropy, inputStateUpdate) {
+        accumulate_logger.log `Accumulating service ${serviceId}, transfers: ${transfers.length} operands: ${operands.length} at slot: ${slot}.`;
+        const result = await this.pvmAccumulateInvocation(slot, serviceId, transfers, operands, gasCost, entropy, inputStateUpdate);
         if (result.isError) {
             // https://graypaper.fluffylabs.dev/#/7e6ff6a/2fb6012fb601?v=0.6.7
             accumulate_logger.log `Accumulation failed for ${serviceId}.`;
@@ -22642,7 +22904,7 @@ class Accumulate {
      *
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/179d00179d00?v=0.6.7
      */
-    async accumulateSequentially(gasLimit, reports, slot, entropy, statistics, stateUpdate) {
+    async accumulateSequentiallyLegacy(gasLimit, reports, slot, entropy, statistics, stateUpdate, autoAccumulateServices) {
         const i = this.findReportCutoffIndex(gasLimit, reports);
         if (i === 0) {
             return {
@@ -22651,14 +22913,46 @@ class Accumulate {
                 state: stateUpdate,
             };
         }
-        const reportsToAccumulateInParallel = reports.slice(0, i);
-        const autoAccumulateServices = this.state.privilegedServices.autoAccumulateServices;
-        const accumulateData = new AccumulateData(reportsToAccumulateInParallel, autoAccumulateServices);
-        const reportsToAccumulateSequentially = reports.slice(i);
+        const reportsToAccumulateInParallel = reports.subview(0, i);
+        const accumulateData = new AccumulateData(reportsToAccumulateInParallel, [], autoAccumulateServices);
+        const reportsToAccumulateSequentially = reports.subview(i);
+        const { gasCost, state: stateAfterParallelAcc, ...rest } = await this.accumulateInParallel(accumulateData, slot, entropy, statistics, stateUpdate);
+        assertEmpty(rest);
+        // NOTE [ToDr] recursive invocation
+        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentiallyLegacy(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, slot, entropy, statistics, stateAfterParallelAcc, []);
+        assertEmpty(seqRest);
+        return {
+            accumulatedReports: numbers_tryAsU32(i + accumulatedReports),
+            gasCost: tryAsServiceGas(gasCost + seqGasCost),
+            state,
+        };
+    }
+    /**
+     * The outer accumulation function ∆+ which transforms a gas-limit, a sequence of work-reports,
+     * an initial partial-state and a dictionary of services enjoying free accumulation,
+     * into a tuple of the number of work-results accumulated, a posterior state-context,
+     * the resultant deferred-transfers and accumulation-output pairing.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/172901172901?v=0.7.2
+     */
+    async accumulateSequentially(gasLimit, reports, transfers, slot, entropy, statistics, stateUpdate, autoAccumulateServices) {
+        const i = this.findReportCutoffIndex(gasLimit, reports);
+        const n = transfers.length + i + reports.length;
+        if (n === 0) {
+            return {
+                accumulatedReports: numbers_tryAsU32(0),
+                gasCost: tryAsServiceGas(0),
+                state: stateUpdate,
+            };
+        }
+        const reportsToAccumulateInParallel = reports.subview(0, i);
+        const accumulateData = new AccumulateData(reportsToAccumulateInParallel, transfers, autoAccumulateServices);
+        const reportsToAccumulateSequentially = reports.subview(i);
         const { gasCost, state: stateAfterParallelAcc, ...rest } = await this.accumulateInParallel(accumulateData, slot, entropy, statistics, stateUpdate);
+        const newTransfers = stateAfterParallelAcc.transfers;
         assertEmpty(rest);
         // NOTE [ToDr] recursive invocation
-        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentially(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, slot, entropy, statistics, stateAfterParallelAcc);
+        const { accumulatedReports, gasCost: seqGasCost, state, ...seqRest } = await this.accumulateSequentially(tryAsServiceGas(gasLimit - gasCost), reportsToAccumulateSequentially, newTransfers, slot, entropy, statistics, stateAfterParallelAcc, []);
         assertEmpty(seqRest);
         return {
             accumulatedReports: numbers_tryAsU32(i + accumulatedReports),
@@ -22674,7 +22968,7 @@ class Accumulate {
      * into a tuple of the total gas utilized in pvm execution u, a posterior state-context
      * and the resultant accumulation-output pairings b and deferred-transfers.
      *
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/175501175501?v=0.6.7
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/174602174602?v=0.7.2
      */
     async accumulateInParallel(accumulateData, slot, entropy, statistics, inputStateUpdate) {
         const serviceIds = accumulateData.getServiceIds();
@@ -22683,7 +22977,7 @@ class Accumulate {
         const currentManager = (inputStateUpdate.privilegedServices ?? this.state.privilegedServices).manager;
         for (const serviceId of serviceIds) {
             const checkpoint = AccumulationStateUpdate.copyFrom(currentState);
-            const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getOperands(serviceId), accumulateData.getGasCost(serviceId), slot, entropy, currentState);
+            const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), accumulateData.getOperands(serviceId), accumulateData.getGasCost(serviceId), slot, entropy, currentState);
             gasCost = tryAsServiceGas(gasCost + consumedGas);
             const serviceStatistics = statistics.get(serviceId) ?? { count: numbers_tryAsU32(0), gasUsed: tryAsServiceGas(0) };
             serviceStatistics.count = numbers_tryAsU32(serviceStatistics.count + accumulateData.getReportsLength(serviceId));
@@ -22691,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`
-                    const { stateUpdate } = await this.accumulateSingleService(newV, accumulateData.getOperands(newV), accumulateData.getGasCost(newV), slot, entropy, checkpoint);
-                    const correctV = stateUpdate?.privilegedServices?.validatorsManager ?? this.state.privilegedServices.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?.delegator ?? this.state.privilegedServices.delegator;
                     currentState.privilegedServices = PrivilegedServices.create({
                         ...currentState.privilegedServices,
-                        validatorsManager: correctV,
+                        delegator: correctV,
                     });
                 }
             }
@@ -22757,7 +23051,7 @@ class Accumulate {
      *
      * Please note it cannot overflow because we use `BigInt`, and the final result is clamped to `maxBlockGas` (W_G).
      *
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/18f40118f401?v=0.6.7
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/183402184502?v=0.7.2
      */
     getGasLimit() {
         const calculatedGasLimit = GAS_TO_INVOKE_WORK_REPORT * BigInt(this.chainSpec.coresCount) +
@@ -22765,6 +23059,20 @@ class Accumulate {
         const gasLimit = tryAsServiceGas(this.chainSpec.maxBlockGas > calculatedGasLimit ? this.chainSpec.maxBlockGas : calculatedGasLimit);
         return tryAsServiceGas(gasLimit);
     }
+    hasDuplicatedServicesCreated(updateServices) {
+        const createdServiceIds = new Set();
+        for (const update of updateServices) {
+            if (update.action.kind === UpdateServiceKind.Create) {
+                const serviceId = update.serviceId;
+                if (createdServiceIds.has(serviceId)) {
+                    accumulate_logger.log `Duplicated Service creation detected ${serviceId}. Block is invalid.`;
+                    return true;
+                }
+                createdServiceIds.add(serviceId);
+            }
+        }
+        return false;
+    }
     async transition({ reports, slot, entropy }) {
         const statistics = new Map();
         const accumulateQueue = new AccumulateQueue(this.chainSpec, this.state);
@@ -22773,16 +23081,22 @@ class Accumulate {
         const queueFromState = accumulateQueue.getQueueFromState(slot);
         const toEnqueue = pruneQueue(queueFromState.concat(toAccumulateLater), getWorkPackageHashes(toAccumulateImmediately));
         const queue = accumulateQueue.enqueueReports(toEnqueue);
-        const accumulatableReports = toAccumulateImmediately.concat(queue);
+        const accumulatableReports = ArrayView.from(toAccumulateImmediately.concat(queue));
         const gasLimit = this.getGasLimit();
-        const { accumulatedReports, gasCost, state, ...rest } = await this.accumulateSequentially(gasLimit, accumulatableReports, slot, entropy, statistics, AccumulationStateUpdate.empty());
+        const autoAccumulateServices = this.state.privilegedServices.autoAccumulateServices;
+        const { accumulatedReports, gasCost, state, ...rest } = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? await this.accumulateSequentially(gasLimit, accumulatableReports, [], slot, entropy, statistics, AccumulationStateUpdate.empty(), autoAccumulateServices)
+            : await this.accumulateSequentiallyLegacy(gasLimit, accumulatableReports, slot, entropy, statistics, AccumulationStateUpdate.empty(), autoAccumulateServices);
         // we can safely ignore top-level gas cost from accSequentially.
         const _gasCost = gasCost;
         assertEmpty(rest);
-        const accumulated = accumulatableReports.slice(0, accumulatedReports);
+        const accumulated = accumulatableReports.subview(0, accumulatedReports);
         const { services, yieldedRoots, transfers, validatorsData, privilegedServices, authorizationQueues, ...stateUpdateRest } = state;
         assertEmpty(stateUpdateRest);
-        const accStateUpdate = this.getAccumulationStateUpdate(accumulated, toAccumulateLater, slot, Array.from(statistics.keys()), services);
+        if (this.hasDuplicatedServicesCreated(services.servicesUpdates)) {
+            return result_Result.error(ACCUMULATION_ERROR);
+        }
+        const accStateUpdate = this.getAccumulationStateUpdate(accumulated.toArray(), toAccumulateLater, slot, Array.from(statistics.keys()), services);
         const accumulationOutputUnsorted = Array.from(yieldedRoots.entries()).map(([serviceId, root]) => {
             return { serviceId, output: root.asOpaque() };
         });
@@ -24414,18 +24728,24 @@ class OnChain {
         }
         const { stateUpdate: accumulateUpdate, accumulationStatistics, pendingTransfers, accumulationOutputLog, ...accumulateRest } = accumulateResult.ok;
         assertEmpty(accumulateRest);
-        const { privilegedServices: maybePrivilegedServices, authQueues: maybeAuthorizationQueues, designatedValidatorData: maybeDesignatedValidatorData, preimages: accumulatePreimages, accumulationQueue, recentlyAccumulated, ...servicesUpdate } = accumulateUpdate;
-        const deferredTransfersResult = await this.deferredTransfers.transition({
-            entropy: entropy[0],
-            pendingTransfers,
-            servicesUpdate: { ...servicesUpdate, preimages: accumulatePreimages },
-            timeslot: timeSlot,
-        });
-        if (deferredTransfersResult.isError) {
-            return stfError(StfErrorKind.DeferredTransfers, deferredTransfersResult);
+        const { privilegedServices: maybePrivilegedServices, authQueues: maybeAuthorizationQueues, designatedValidatorData: maybeDesignatedValidatorData, preimages: accumulatePreimages, accumulationQueue, recentlyAccumulated, ...servicesUpdateFromAccumulate } = accumulateUpdate;
+        let transferStatistics = new Map();
+        let servicesUpdate = { ...servicesUpdateFromAccumulate, preimages: accumulatePreimages };
+        if (Compatibility.isLessThan(GpVersion.V0_7_1)) {
+            const deferredTransfersResult = await this.deferredTransfers.transition({
+                entropy: entropy[0],
+                pendingTransfers,
+                servicesUpdate,
+                timeslot: timeSlot,
+            });
+            if (deferredTransfersResult.isError) {
+                return stfError(StfErrorKind.DeferredTransfers, deferredTransfersResult);
+            }
+            const { servicesUpdate: servicesUpdateFromDeferredTransfers, transferStatistics: transferStatisticsFromDeferredTransfers, ...deferredTransfersRest } = deferredTransfersResult.ok;
+            transferStatistics = transferStatisticsFromDeferredTransfers;
+            servicesUpdate = servicesUpdateFromDeferredTransfers;
+            assertEmpty(deferredTransfersRest);
         }
-        const { servicesUpdate: newServicesUpdate, transferStatistics, ...deferredTransfersRest } = deferredTransfersResult.ok;
-        assertEmpty(deferredTransfersRest);
         const accumulateRoot = await this.accumulateOutput.transition({ accumulationOutputLog });
         // recent history
         const recentHistoryUpdate = this.recentHistory.transition({
@@ -24475,7 +24795,7 @@ class OnChain {
             accumulationQueue,
             recentlyAccumulated,
             accumulationOutputLog,
-            ...newServicesUpdate,
+            ...servicesUpdate,
             preimages: preimages.concat(accumulatePreimages),
         });
     }