@typeberry/lib 0.5.10 → 0.5.11-1fbacf3

package/packages/jam/transition/externalities/accumulate-externalities.test.js

@@ -6,7 +6,7 @@ import { asKnownSize, FixedSizeArray, HashDictionary } from "#@typeberry/collect
 import { tinyChainSpec } from "#@typeberry/config";
 import { BANDERSNATCH_KEY_BYTES, BLS_KEY_BYTES, ED25519_KEY_BYTES } from "#@typeberry/crypto";
 import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
-import { EjectError, ForgetPreimageError, NewServiceError, PartiallyUpdatedState, PendingTransfer, PreimageStatusKind, ProvidePreimageError, RequestPreimageError, TRANSFER_MEMO_BYTES, TransferError, UnprivilegedError, UpdatePrivilegesError, writeServiceIdAsLeBytes, } from "#@typeberry/jam-host-calls";
+import { CURRENT_SERVICE_ID, EjectError, ForgetPreimageError, NewServiceError, PartiallyUpdatedState, PendingTransfer, PreimageStatusKind, ProvidePreimageError, RequestPreimageError, TRANSFER_MEMO_BYTES, TransferError, UnprivilegedError, UpdatePrivilegesError, writeServiceIdAsLeBytes, } from "#@typeberry/jam-host-calls";
 import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
 import { AUTHORIZATION_QUEUE_SIZE, InMemoryService, InMemoryState, LookupHistoryItem, PreimageItem, PrivilegedServices, ServiceAccountInfo, StorageItem, tryAsLookupHistorySlots, tryAsPerCore, UpdatePreimage, UpdateService, VALIDATOR_META_BYTES, ValidatorData, } from "#@typeberry/state";
 import { testState } from "#@typeberry/state/test.utils.js";
@@ -17,13 +17,20 @@ before(async () => {
     blake2b = await Blake2b.createHasher();
 });
 function partiallyUpdatedState() {
-    return new PartiallyUpdatedState(testState());
+    return PartiallyUpdatedState.new(testState());
 }
 const INVALID_SERVICE_ID_ERROR = "Either manager or delegator or registrar is not a valid service id.";
 describe("PartialState.checkPreimageStatus", () => {
     it("should check preimage status from state", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.parseBytes("0xc16326432b5b3213dfd1609495e13c6b276cb474d679645337e5c2c09f19b53c", HASH_SIZE).asOpaque();
         const status = partialState.checkPreimageStatus(preimageHash, tryAsU64(35));
         assert.deepStrictEqual(status, {
@@ -34,12 +41,19 @@ describe("PartialState.checkPreimageStatus", () => {
     it("should return preimage status when its in updated state", () => {
         const state = partiallyUpdatedState();
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.parseBytes("0xc16326432b5b3213dfd1609495e13c6b276cb474d679645337e5c2c09f19b53c", HASH_SIZE).asOpaque();
         const length = tryAsU64(35);
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(preimageHash, tryAsU32(Number(length)), tryAsLookupHistorySlots([])),
+            lookupHistory: LookupHistoryItem.new(preimageHash, tryAsU32(Number(length)), tryAsLookupHistorySlots([])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const status = partialState.checkPreimageStatus(preimageHash, length);
@@ -57,7 +71,14 @@ describe("PartialState.requestPreimage", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.fill(HASH_SIZE, 0xa).asOpaque();
         const status = partialState.requestPreimage(preimageHash, tryAsU64(5));
         assert.deepStrictEqual(status, Result.ok(OK));
@@ -66,7 +87,7 @@ describe("PartialState.requestPreimage", () => {
                 serviceId,
                 [
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(preimageHash, tryAsU32(5), tryAsLookupHistorySlots([])),
+                        lookupHistory: LookupHistoryItem.new(preimageHash, tryAsU32(5), tryAsLookupHistorySlots([])),
                     }),
                 ],
             ],
@@ -92,7 +113,14 @@ describe("PartialState.requestPreimage", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.fill(HASH_SIZE, 0xa).asOpaque();
         const status = partialState.requestPreimage(preimageHash, tryAsU64(5));
         assert.deepStrictEqual(status, Result.ok(OK));
@@ -101,7 +129,7 @@ describe("PartialState.requestPreimage", () => {
                 serviceId,
                 [
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(preimageHash, tryAsU32(5), tryAsLookupHistorySlots([])),
+                        lookupHistory: LookupHistoryItem.new(preimageHash, tryAsU32(5), tryAsLookupHistorySlots([])),
                     }),
                 ],
             ],
@@ -121,7 +149,14 @@ describe("PartialState.requestPreimage", () => {
     });
     it("should fail if preimage is already requested", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.fill(HASH_SIZE, 0xa).asOpaque();
         const status = partialState.requestPreimage(preimageHash, tryAsU64(5));
         assert.deepStrictEqual(status, Result.ok(OK));
@@ -130,14 +165,28 @@ describe("PartialState.requestPreimage", () => {
     });
     it("should fail if preimage is already available", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.parseBytes("0xc16326432b5b3213dfd1609495e13c6b276cb474d679645337e5c2c09f19b53c", HASH_SIZE).asOpaque();
         const status = partialState.requestPreimage(preimageHash, tryAsU64(35));
         deepEqual(status, Result.error(RequestPreimageError.AlreadyAvailable, () => "Preimage already available: hash=0xc16326432b5b3213dfd1609495e13c6b276cb474d679645337e5c2c09f19b53c"));
     });
     it("should fail if balance is insufficient", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.fill(HASH_SIZE, 0xa).asOpaque();
         const status = partialState.requestPreimage(preimageHash, tryAsU64(2n ** 34n - 1n));
         deepEqual(status, Result.error(RequestPreimageError.InsufficientFunds, () => "Service balance (10000000000) below threshold (17179869696)"));
@@ -146,7 +195,14 @@ describe("PartialState.requestPreimage", () => {
 describe("PartialState.forgetPreimage", () => {
     it("should error if preimage does not exist", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const hash = Bytes.fill(HASH_SIZE, 0x01).asOpaque();
         const result = partialState.forgetPreimage(hash, tryAsU64(42));
         deepEqual(result, Result.error(ForgetPreimageError.NotFound, () => "Preimage not found: hash=0x0101010101010101010101010101010101010101010101010101010101010101, length=42"));
@@ -156,10 +212,17 @@ describe("PartialState.forgetPreimage", () => {
         const serviceId = tryAsServiceId(0);
         const hash = Bytes.parseBytes("0xc16326432b5b3213dfd1609495e13c6b276cb474d679645337e5c2c09f19b53c", HASH_SIZE).asOpaque();
         const length = tryAsU64(35);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(50));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(50),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), tryAsTimeSlot(1)])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), tryAsTimeSlot(1)])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result1 = partialState.forgetPreimage(hash, length);
@@ -173,7 +236,14 @@ describe("PartialState.forgetPreimage", () => {
         const serviceId = tryAsServiceId(0);
         const hash = Bytes.fill(HASH_SIZE, 0x03).asOpaque();
         const length = tryAsU64(42);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         partialState.requestPreimage(hash, length);
         const result = partialState.forgetPreimage(hash, length);
         assert.deepStrictEqual(result, Result.ok(OK));
@@ -182,7 +252,7 @@ describe("PartialState.forgetPreimage", () => {
                 serviceId,
                 [
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([])),
+                        lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([])),
                     }),
                     UpdatePreimage.remove({
                         hash,
@@ -201,10 +271,17 @@ describe("PartialState.forgetPreimage", () => {
         const length = tryAsU64(42);
         const oldSlot = tryAsTimeSlot(0); // very old
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(50));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(50),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([oldSlot, oldSlot])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([oldSlot, oldSlot])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result = partialState.forgetPreimage(hash, length);
@@ -214,7 +291,7 @@ describe("PartialState.forgetPreimage", () => {
                 serviceId,
                 [
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([oldSlot, oldSlot])),
+                        lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([oldSlot, oldSlot])),
                     }),
                     UpdatePreimage.remove({
                         hash,
@@ -233,10 +310,17 @@ describe("PartialState.forgetPreimage", () => {
         const length = tryAsU64(42);
         const recentSlot = tryAsTimeSlot(90); // within expunge period
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([recentSlot])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([recentSlot])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result = partialState.forgetPreimage(hash, length);
@@ -251,10 +335,17 @@ describe("PartialState.forgetPreimage", () => {
         const length = tryAsU64(42);
         const availableSlot = tryAsTimeSlot(80);
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(100));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(100),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([availableSlot])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([availableSlot])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result = partialState.forgetPreimage(hash, length);
@@ -264,10 +355,10 @@ describe("PartialState.forgetPreimage", () => {
                 serviceId,
                 [
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([availableSlot])),
+                        lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([availableSlot])),
                     }),
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([availableSlot, state.state.timeslot])),
+                        lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([availableSlot, state.state.timeslot])),
                     }),
                 ],
             ],
@@ -283,10 +374,17 @@ describe("PartialState.forgetPreimage", () => {
         const y = tryAsTimeSlot(0);
         const z = tryAsTimeSlot(70);
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(100000));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(100000),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), y, z])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), y, z])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result = partialState.forgetPreimage(hash, length);
@@ -296,10 +394,10 @@ describe("PartialState.forgetPreimage", () => {
                 serviceId,
                 [
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), y, z])),
+                        lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), y, z])),
                     }),
                     UpdatePreimage.updateOrAdd({
-                        lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([z, state.state.timeslot])),
+                        lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([z, state.state.timeslot])),
                     }),
                 ],
             ],
@@ -315,10 +413,17 @@ describe("PartialState.forgetPreimage", () => {
         const y = tryAsTimeSlot(95); // too recent
         const z = tryAsTimeSlot(70);
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(100));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(100),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), y, z])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), y, z])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result = partialState.forgetPreimage(hash, length);
@@ -329,10 +434,17 @@ describe("PartialState.forgetPreimage", () => {
         const hash = Bytes.fill(HASH_SIZE, 0x08).asOpaque();
         const length = tryAsU64(42);
         const serviceId = tryAsServiceId(0);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(10), tryAsTimeSlot(2));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: serviceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(2),
+        });
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.updateOrAdd({
-            lookupHistory: new LookupHistoryItem(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), tryAsTimeSlot(1)])),
+            lookupHistory: LookupHistoryItem.new(hash, tryAsU32(Number(length)), tryAsLookupHistorySlots([tryAsTimeSlot(0), tryAsTimeSlot(1)])),
         }));
         state.stateUpdate.services.preimages.set(serviceId, updates);
         const result = partialState.forgetPreimage(hash, length);
@@ -347,7 +459,14 @@ describe("PartialState.newService", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0x11).asOpaque();
         const codeLength = tryAsU32(100);
         const codeLengthU64 = tryAsU64(codeLength);
@@ -389,7 +508,7 @@ describe("PartialState.newService", () => {
                         lastAccumulation: tryAsTimeSlot(0),
                         parentService: service.serviceId,
                     }),
-                    lookupHistory: new LookupHistoryItem(codeHash, codeLength, tryAsLookupHistorySlots([])),
+                    lookupHistory: LookupHistoryItem.new(codeHash, codeLength, tryAsLookupHistorySlots([])),
                 }),
             ],
         ]));
@@ -410,7 +529,14 @@ describe("PartialState.newService", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(serviceId), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(serviceId),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0x11).asOpaque();
         const codeLength = tryAsU32(100);
         const codeLengthU64 = tryAsU64(codeLength);
@@ -454,7 +580,7 @@ describe("PartialState.newService", () => {
                         lastAccumulation: tryAsTimeSlot(0),
                         parentService: service.serviceId,
                     }),
-                    lookupHistory: new LookupHistoryItem(codeHash, codeLength, tryAsLookupHistorySlots([])),
+                    lookupHistory: LookupHistoryItem.new(codeHash, codeLength, tryAsLookupHistorySlots([])),
                 }),
             ],
         ]));
@@ -469,7 +595,7 @@ describe("PartialState.newService", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const updatedService = new InMemoryService(service.serviceId, {
+        const updatedService = InMemoryService.new(service.serviceId, {
             ...service.data,
             info: ServiceAccountInfo.create({
                 ...service.data.info,
@@ -478,7 +604,14 @@ describe("PartialState.newService", () => {
             }),
         });
         state.state.services.set(tryAsServiceId(0), updatedService);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0x12).asOpaque();
         // artificially large to exceed balance
         const codeLength = tryAsU64(2 ** 32 + 1);
@@ -504,7 +637,7 @@ describe("PartialState.newService", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const updatedService = new InMemoryService(service.serviceId, {
+        const updatedService = InMemoryService.new(service.serviceId, {
             ...service.data,
             info: ServiceAccountInfo.create({
                 ...service.data.info,
@@ -512,7 +645,14 @@ describe("PartialState.newService", () => {
             }),
         });
         state.state.services.set(tryAsServiceId(0), updatedService);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0x12).asOpaque();
         const codeLength = tryAsU64(1024);
         const accumulateMinGas = tryAsServiceGas(10n);
@@ -538,7 +678,14 @@ describe("PartialState.newService", () => {
         if (maybeService === undefined) {
             throw new Error("Invalid service!");
         }
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0x11).asOpaque();
         const codeLength = tryAsU32(100);
         const codeLengthU64 = tryAsU64(codeLength);
@@ -565,7 +712,14 @@ describe("PartialState.newService", () => {
         if (maybeService === undefined) {
             throw new Error("Invalid service!");
         }
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0x12).asOpaque();
         const codeLength = tryAsU64(1024);
         const accumulateMinGas = tryAsServiceGas(10n);
@@ -583,7 +737,14 @@ describe("PartialState.newService", () => {
 describe("PartialState.updateValidatorsData", () => {
     it("should update validators data", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         // when
         const result = partialState.updateValidatorsData(asKnownSize([
             ValidatorData.create({
@@ -603,7 +764,14 @@ describe("PartialState.updateValidatorsData", () => {
             ...state.state.privilegedServices,
             delegator: tryAsServiceId(1),
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         // when
         const result = partialState.updateValidatorsData(asKnownSize([
             ValidatorData.create({
@@ -621,7 +789,14 @@ describe("PartialState.updateValidatorsData", () => {
 describe("PartialState.checkpoint", () => {
     it("should checkpoint the updates", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const preimageHash = Bytes.fill(HASH_SIZE, 0xa).asOpaque();
         // put something into updated state
         const status = partialState.requestPreimage(preimageHash, tryAsU64(5));
@@ -640,7 +815,14 @@ describe("PartialState.upgradeService", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const codeHash = Bytes.fill(HASH_SIZE, 0xcd).asOpaque();
         const gas = tryAsU64(1000n);
         const allowance = tryAsU64(2000n);
@@ -663,20 +845,46 @@ describe("PartialState.upgradeService", () => {
     });
 });
 describe("PartialState.updateAuthorizationQueue", () => {
-    it("should update the authorization queue for a given core index", () => {
+    it("should update the authorization queue and transfer the assigner for the given core", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const initialPrivileged = state.state.privilegedServices;
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const coreIndex = tryAsCoreIndex(0);
-        const assigners = tryAsServiceId(0);
+        const newAssigner = tryAsServiceId(99);
         const queue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xee).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
         // when
-        partialState.updateAuthorizationQueue(coreIndex, queue, assigners);
+        const result = partialState.updateAuthorizationQueue(coreIndex, queue, newAssigner);
         // then
+        deepEqual(result, Result.ok(OK));
         assert.deepStrictEqual(state.stateUpdate.authorizationQueues.get(coreIndex), queue);
+        // the privilegedServices update must be written, with only the targeted
+        // core's assigner transferred; all other fields must be preserved.
+        const updated = state.stateUpdate.privilegedServices;
+        assert.ok(updated !== null, "stateUpdate.privilegedServices should be written");
+        assert.strictEqual(updated.assigners[0], newAssigner);
+        assert.strictEqual(updated.assigners[1], initialPrivileged.assigners[1]);
+        assert.strictEqual(updated.manager, initialPrivileged.manager);
+        assert.strictEqual(updated.delegator, initialPrivileged.delegator);
+        assert.strictEqual(updated.registrar, initialPrivileged.registrar);
+        assert.strictEqual(updated.autoAccumulateServices, initialPrivileged.autoAccumulateServices);
     });
     it("should return InvalidServiceId when given auth manager is invalid", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const coreIndex = tryAsCoreIndex(0);
         const assigners = null;
         const queue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xee).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
@@ -685,6 +893,8 @@ describe("PartialState.updateAuthorizationQueue", () => {
         // then
         deepEqual(result, Result.error(UpdatePrivilegesError.InvalidServiceId, () => "New auth manager is null for core 0"));
         assert.deepStrictEqual(state.stateUpdate.authorizationQueues.get(coreIndex), undefined);
+        // no partial privilegedServices write on error
+        assert.strictEqual(state.stateUpdate.privilegedServices, null);
     });
     it("should return UnprivilegedService when current service is not privileged", () => {
         const state = partiallyUpdatedState();
@@ -692,7 +902,14 @@ describe("PartialState.updateAuthorizationQueue", () => {
             ...state.state.privilegedServices,
             assigners: asOpaqueType(FixedSizeArray.new([tryAsServiceId(1), tryAsServiceId(2)], tinyChainSpec.coresCount)),
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const coreIndex = tryAsCoreIndex(0);
         const assigners = tryAsServiceId(0);
         const queue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xee).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
@@ -701,6 +918,8 @@ describe("PartialState.updateAuthorizationQueue", () => {
         // then
         deepEqual(result, Result.error(UpdatePrivilegesError.UnprivilegedService, () => "Service 0 not assigner for core 0 (expected: 1)"));
         assert.deepStrictEqual(state.stateUpdate.authorizationQueues.get(coreIndex), undefined);
+        // no partial privilegedServices write on error
+        assert.strictEqual(state.stateUpdate.privilegedServices, null);
     });
     it("should return UnprivilegedService before InvalidServiceId if given auth manager is incorrect, but current servis is also unprivileged", () => {
         const state = partiallyUpdatedState();
@@ -708,7 +927,14 @@ describe("PartialState.updateAuthorizationQueue", () => {
             ...state.state.privilegedServices,
             assigners: asOpaqueType(FixedSizeArray.new([tryAsServiceId(1), tryAsServiceId(2)], tinyChainSpec.coresCount)),
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const coreIndex = tryAsCoreIndex(0);
         const assigners = null;
         const queue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xee).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
@@ -717,12 +943,87 @@ describe("PartialState.updateAuthorizationQueue", () => {
         // then
         deepEqual(result, Result.error(UpdatePrivilegesError.UnprivilegedService, () => "Service 0 not assigner for core 0 (expected: 1)"));
         assert.deepStrictEqual(state.stateUpdate.authorizationQueues.get(coreIndex), undefined);
+        // no partial privilegedServices write on error
+        assert.strictEqual(state.stateUpdate.privilegedServices, null);
+    });
+    it("should succeed on a self-transfer using CURRENT_SERVICE_ID", () => {
+        const state = partiallyUpdatedState();
+        // inject a service info for CURRENT_SERVICE_ID so it can act as the
+        // current (and assigning) service on core 0
+        const baseService = state.state.services.get(tryAsServiceId(0));
+        if (baseService === undefined) {
+            throw new Error("Invalid service!");
+        }
+        state.state.services.set(CURRENT_SERVICE_ID, InMemoryService.new(CURRENT_SERVICE_ID, {
+            info: baseService.data.info,
+            preimages: HashDictionary.new(),
+            lookupHistory: HashDictionary.new(),
+            storage: new Map(),
+        }));
+        state.state.privilegedServices = PrivilegedServices.create({
+            ...state.state.privilegedServices,
+            assigners: asOpaqueType(FixedSizeArray.new([CURRENT_SERVICE_ID, tryAsServiceId(0)], tinyChainSpec.coresCount)),
+        });
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: CURRENT_SERVICE_ID,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
+        const coreIndex = tryAsCoreIndex(0);
+        const queue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xee).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
+        // when
+        const result = partialState.updateAuthorizationQueue(coreIndex, queue, CURRENT_SERVICE_ID);
+        // then
+        deepEqual(result, Result.ok(OK));
+        assert.deepStrictEqual(state.stateUpdate.authorizationQueues.get(coreIndex), queue);
+        const updated = state.stateUpdate.privilegedServices;
+        assert.ok(updated !== null, "stateUpdate.privilegedServices should be written");
+        assert.strictEqual(updated.assigners[0], CURRENT_SERVICE_ID);
+        assert.strictEqual(updated.assigners[1], tryAsServiceId(0));
+    });
+    it("should prevent the previous assigner from re-assigning after transfer", () => {
+        const state = partiallyUpdatedState();
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
+        const coreIndex = tryAsCoreIndex(0);
+        const newAssigner = tryAsServiceId(99);
+        const firstQueue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xee).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
+        const secondQueue = FixedSizeArray.new(Array.from({ length: AUTHORIZATION_QUEUE_SIZE }, () => Bytes.fill(HASH_SIZE, 0xff).asOpaque()), AUTHORIZATION_QUEUE_SIZE);
+        // when: first call succeeds and transfers the assigner to service 99
+        const first = partialState.updateAuthorizationQueue(coreIndex, firstQueue, newAssigner);
+        // and the previous assigner (service 0) immediately tries to re-assign
+        const second = partialState.updateAuthorizationQueue(coreIndex, secondQueue, tryAsServiceId(0));
+        // then
+        deepEqual(first, Result.ok(OK));
+        deepEqual(second, Result.error(UpdatePrivilegesError.UnprivilegedService, () => "Service 0 not assigner for core 0 (expected: 99)"));
+        // the first queue remains — the failing second call must not overwrite it
+        assert.deepStrictEqual(state.stateUpdate.authorizationQueues.get(coreIndex), firstQueue);
+        // and the transferred assigner is still in place
+        const updated = state.stateUpdate.privilegedServices;
+        assert.ok(updated !== null);
+        assert.strictEqual(updated.assigners[0], newAssigner);
     });
 });
 describe("PartialState.updatePrivilegedServices", () => {
     it("should update privileged services", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const manager = tryAsServiceId(1);
         const assigners = tryAsPerCore(new Array(tinyChainSpec.coresCount).fill(tryAsServiceId(2)), tinyChainSpec);
         const delegator = tryAsServiceId(3);
@@ -745,7 +1046,14 @@ describe("PartialState.updatePrivilegedServices", () => {
     });
     it("should return InvalidService when given manager is invalid service id", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const manager = null;
         const assigners = tryAsPerCore(new Array(tinyChainSpec.coresCount).fill(tryAsServiceId(2)), tinyChainSpec);
         const delegator = tryAsServiceId(3);
@@ -762,7 +1070,14 @@ describe("PartialState.updatePrivilegedServices", () => {
     });
     it("should return InvalidService when given validator is invalid service id", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const manager = tryAsServiceId(1);
         const assigners = tryAsPerCore(new Array(tinyChainSpec.coresCount).fill(tryAsServiceId(2)), tinyChainSpec);
         const delegator = null;
@@ -779,7 +1094,14 @@ describe("PartialState.updatePrivilegedServices", () => {
     });
     it("should return InvalidService when given registrar is invalid service id", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const manager = tryAsServiceId(1);
         const assigners = tryAsPerCore(new Array(tinyChainSpec.coresCount).fill(tryAsServiceId(2)), tinyChainSpec);
         const delegator = tryAsServiceId(3);
@@ -803,7 +1125,7 @@ describe("PartialState.transfer", () => {
             throw new Error("Invalid service!");
         }
         const service = maybeService;
-        state.state.services.set(tryAsServiceId(1), new InMemoryService(tryAsServiceId(1), {
+        state.state.services.set(tryAsServiceId(1), InMemoryService.new(tryAsServiceId(1), {
             info: ServiceAccountInfo.create({
                 ...service.data.info,
                 onTransferMinGas: tryAsServiceGas(1000),
@@ -819,7 +1141,14 @@ describe("PartialState.transfer", () => {
     };
     it("should perform a successful transfer", () => {
         const { state, service } = partiallyUpdatedStateWithSecondService();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const destinationId = tryAsServiceId(1);
         const amount = tryAsU64(500n);
         const gas = tryAsServiceGas(1000n);
@@ -852,7 +1181,14 @@ describe("PartialState.transfer", () => {
     });
     it("should return DestinationNotFound error if destination doesnt exist", () => {
         const { state } = partiallyUpdatedStateWithSecondService();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const amount = tryAsU64(100n);
         const gas = tryAsServiceGas(1000n);
         const memo = Bytes.fill(TRANSFER_MEMO_BYTES, 0xbb);
@@ -863,7 +1199,14 @@ describe("PartialState.transfer", () => {
     });
     it("should return GasTooLow error if gas is below destination's minimum", () => {
         const { state } = partiallyUpdatedStateWithSecondService();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const destinationId = tryAsServiceId(1);
         const amount = tryAsU64(100n);
         const gas = tryAsServiceGas(999n); // too low
@@ -875,7 +1218,14 @@ describe("PartialState.transfer", () => {
     });
     it("should return BalanceBelowThreshold error if balance would fall too low", () => {
         const { state } = partiallyUpdatedStateWithSecondService();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const destinationId = tryAsServiceId(1);
         const amount = tryAsU64(9999999999n); // dangerously high
         const gas = tryAsServiceGas(1000n);
@@ -890,7 +1240,14 @@ describe("PartialState.yield", () => {
     it("should yield root", () => {
         const currentServiceId = tryAsServiceId(0);
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: currentServiceId,
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const expectedYieldedRoot = Bytes.fill(HASH_SIZE, 0xef);
         // when
         partialState.yield(Bytes.fill(HASH_SIZE, 0xef));
@@ -916,19 +1273,19 @@ describe("PartialState.providePreimage", () => {
             ? [
                 [
                     preimage.hash,
-                    [new LookupHistoryItem(preimage.hash, tryAsU32(preimage.blob.length), tryAsLookupHistorySlots([]))],
+                    [LookupHistoryItem.new(preimage.hash, tryAsU32(preimage.blob.length), tryAsLookupHistorySlots([]))],
                 ],
             ]
             : []);
         if (self) {
             // we need to replace the existing service
-            state.state.services.set(service.serviceId, new InMemoryService(service.serviceId, {
+            state.state.services.set(service.serviceId, InMemoryService.new(service.serviceId, {
                 ...service.data,
                 preimages,
                 lookupHistory,
             }));
         }
-        const secondService = new InMemoryService(tryAsServiceId(1), {
+        const secondService = InMemoryService.new(tryAsServiceId(1), {
             info: ServiceAccountInfo.create({
                 ...service.data.info,
                 onTransferMinGas: tryAsServiceGas(1000),
@@ -948,7 +1305,14 @@ describe("PartialState.providePreimage", () => {
             self: false,
             requested: true,
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(1);
         assert.deepStrictEqual(state.stateUpdate.services.preimages.size, 0);
         // when
@@ -986,7 +1350,14 @@ describe("PartialState.providePreimage", () => {
     });
     it("should provide a preimage for itself", () => {
         const { state, preimage } = partiallyUpdatedStateWithSecondService({ self: true, requested: true });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(0);
         assert.deepStrictEqual(state.stateUpdate.services.preimages.size, 0);
         // when
@@ -1014,7 +1385,14 @@ describe("PartialState.providePreimage", () => {
             self: false,
             requested: false,
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(1);
         assert.deepStrictEqual(state.stateUpdate.services.preimages.size, 0);
         // when
@@ -1029,7 +1407,14 @@ describe("PartialState.providePreimage", () => {
             requested: true,
             available: true,
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(1);
         const updates = state.stateUpdate.services.preimages.get(serviceId) ?? [];
         updates.push(UpdatePreimage.provide({
@@ -1067,7 +1452,14 @@ describe("PartialState.providePreimage", () => {
             requested: true,
             available: true,
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(0);
         // when
         const result = partialState.providePreimage(serviceId, preimage.blob);
@@ -1081,7 +1473,14 @@ describe("PartialState.providePreimage", () => {
             requested: true,
             available: false,
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(0);
         assert.deepStrictEqual(state.stateUpdate.services.preimages, new Map());
         // when
@@ -1112,7 +1511,14 @@ describe("PartialState.providePreimage", () => {
             requested: true,
             available: false,
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const serviceId = tryAsServiceId(1);
         assert.deepStrictEqual(state.stateUpdate.services.preimages, new Map());
         // when
@@ -1170,7 +1576,7 @@ describe("PartialState.eject", () => {
         let lookupHistory = HashDictionary.new();
         if (overrides.tombstone !== undefined) {
             const { hash, length, slots } = overrides.tombstone;
-            const item = new LookupHistoryItem(hash, length, slots);
+            const item = LookupHistoryItem.new(hash, length, slots);
             lookupHistory = HashDictionary.fromEntries([[hash, [item]]]);
             if (item.slots.length === 1 || item.slots.length === 2) {
                 preimages = HashDictionary.fromEntries([
@@ -1184,7 +1590,7 @@ describe("PartialState.eject", () => {
                 ]);
             }
         }
-        const destinationService = new InMemoryService(destinationId, {
+        const destinationService = InMemoryService.new(destinationId, {
             info: ServiceAccountInfo.create({
                 ...baseService.data.info,
                 codeHash,
@@ -1200,7 +1606,14 @@ describe("PartialState.eject", () => {
     }
     it("should return InvalidService if destination is null", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const tombstone = Bytes.fill(HASH_SIZE, 0xef).asOpaque();
         // when
         const result = partialState.eject(null, tombstone);
@@ -1210,7 +1623,14 @@ describe("PartialState.eject", () => {
     });
     it("should return InvalidService if destination service does not exist", () => {
         const state = partiallyUpdatedState();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         const nonExistentServiceId = tryAsServiceId(99); // not present in stateUpdate
         const tombstone = Bytes.fill(HASH_SIZE, 0xee).asOpaque();
         // when
@@ -1233,7 +1653,14 @@ describe("PartialState.eject", () => {
                 slots: tryAsLookupHistorySlots([0, 1].map((x) => tryAsTimeSlot(x))),
             },
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(50));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(50),
+        });
         // when
         const correctEjectResult = partialState.eject(destinationId, tombstone); // correct eject
         assert.strictEqual(correctEjectResult.isOk, true);
@@ -1248,7 +1675,14 @@ describe("PartialState.eject", () => {
             codeHash: Bytes.fill(HASH_SIZE, 0x99).asOpaque(), // wrong codeHash
         });
         const tombstone = Bytes.fill(HASH_SIZE, 0xec).asOpaque();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         // when
         const result = partialState.eject(destinationId, tombstone);
         // then
@@ -1261,7 +1695,14 @@ describe("PartialState.eject", () => {
             storageUtilisationCount: tryAsU32(2 + 1), // off by 1
         });
         const tombstone = Bytes.fill(HASH_SIZE, 0xeb).asOpaque();
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         // when
         const result = partialState.eject(destinationId, tombstone);
         // then
@@ -1273,7 +1714,14 @@ describe("PartialState.eject", () => {
         const tombstone = Bytes.fill(HASH_SIZE, 0xea).asOpaque();
         // destination service has valid codeHash and config, but no preimage or lookup history
         const destinationId = setupEjectableService(state.state);
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         // when
         const result = partialState.eject(destinationId, tombstone);
         // then
@@ -1292,7 +1740,14 @@ describe("PartialState.eject", () => {
                 slots: tryAsLookupHistorySlots([1].map((x) => tryAsTimeSlot(x))),
             },
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(16));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(16),
+        });
         // when
         const result = partialState.eject(destinationId, tombstone);
         // then
@@ -1311,7 +1766,14 @@ describe("PartialState.eject", () => {
                 slots: tryAsLookupHistorySlots([1, 11].map((x) => tryAsTimeSlot(x))),
             },
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(17));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(17),
+        });
         // when
         const result = partialState.eject(destinationId, tombstone);
         // then
@@ -1332,7 +1794,14 @@ describe("PartialState.eject", () => {
                 slots: tryAsLookupHistorySlots([0, 1].map((x) => tryAsTimeSlot(x))),
             },
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(50));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(50),
+        });
         // set the balance to overflow
         const currentService = state.state.services.get(tryAsServiceId(0));
         if (currentService === undefined) {
@@ -1362,7 +1831,14 @@ describe("PartialState.eject", () => {
                 slots: tryAsLookupHistorySlots([0, 1].map((x) => tryAsTimeSlot(x))),
             },
         });
-        const partialState = new AccumulateExternalities(tinyChainSpec, blake2b, state, tryAsServiceId(0), tryAsServiceId(10), tryAsTimeSlot(50));
+        const partialState = AccumulateExternalities.forService({
+            chainSpec: tinyChainSpec,
+            blake2b: blake2b,
+            updatedState: state,
+            currentServiceId: tryAsServiceId(0),
+            nextNewServiceIdCandidate: tryAsServiceId(10),
+            currentTimeslot: tryAsTimeSlot(50),
+        });
         // when
         const result = partialState.eject(destinationId, tombstone);
         // then
@@ -1379,12 +1855,12 @@ describe("AccumulateServiceExternalities", () => {
         }
         const state = InMemoryState.empty(tinyChainSpec);
         state.services = services;
-        return new PartiallyUpdatedState(state);
+        return PartiallyUpdatedState.new(state);
     };
     const prepareService = (serviceId, { storage, preimages, info, } = {}) => {
         const initialStorage = storage ?? new Map();
         const storageUtilisationBytes = Array.from(initialStorage.values()).reduce((sum, item) => sum + (item?.value.length ?? 0), 0);
-        return new InMemoryService(serviceId, {
+        return InMemoryService.new(serviceId, {
             info: ServiceAccountInfo.create({
                 balance: tryAsU64(2 ** 32),
                 accumulateMinGas: tryAsServiceGas(1000),
@@ -1417,7 +1893,14 @@ describe("AccumulateServiceExternalities", () => {
             const serviceId = null;
             const state = prepareState([prepareService(currentServiceId)]);
             const expectedServiceInfo = null;
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const serviceInfo = accumulateServiceExternalities.getServiceInfo(serviceId);
             assert.strictEqual(serviceInfo, expectedServiceInfo);
         });
@@ -1426,7 +1909,14 @@ describe("AccumulateServiceExternalities", () => {
             const serviceId = tryAsServiceId(5);
             const state = prepareState([prepareService(currentServiceId)]);
             const expectedServiceInfo = null;
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const serviceInfo = accumulateServiceExternalities.getServiceInfo(serviceId);
             assert.strictEqual(serviceInfo, expectedServiceInfo);
         });
@@ -1435,7 +1925,14 @@ describe("AccumulateServiceExternalities", () => {
             const serviceId = tryAsServiceId(5);
             const state = prepareState([prepareService(currentServiceId), prepareService(serviceId)]);
             const expectedServiceInfo = prepareService(serviceId).getInfo();
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const serviceInfo = accumulateServiceExternalities.getServiceInfo(serviceId);
             assert.deepStrictEqual(serviceInfo, expectedServiceInfo);
         });
@@ -1447,7 +1944,14 @@ describe("AccumulateServiceExternalities", () => {
             const hash = Bytes.fill(HASH_SIZE, 1).asOpaque();
             const state = prepareState([prepareService(currentServiceId)]);
             const expectedResult = null;
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.lookup(serviceId, hash);
             assert.strictEqual(result, expectedResult);
         });
@@ -1457,7 +1961,14 @@ describe("AccumulateServiceExternalities", () => {
             const hash = Bytes.fill(HASH_SIZE, 1).asOpaque();
             const state = prepareState([prepareService(currentServiceId)]);
             const expectedResult = null;
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.lookup(serviceId, hash);
             assert.strictEqual(result, expectedResult);
         });
@@ -1469,7 +1980,14 @@ describe("AccumulateServiceExternalities", () => {
             const service = prepareService(currentServiceId, { preimages });
             const state = prepareState([service]);
             const expectedResult = null;
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.lookup(currentServiceId, requestedHash);
             assert.strictEqual(result, expectedResult);
         });
@@ -1480,7 +1998,14 @@ describe("AccumulateServiceExternalities", () => {
             const preimages = preparePreimages([[requestedHash, expectedResult]]);
             const service = prepareService(serviceId, { preimages });
             const state = prepareState([service]);
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, serviceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: serviceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.lookup(serviceId, requestedHash);
             assert.deepStrictEqual(result, expectedResult);
         });
@@ -1491,7 +2016,14 @@ describe("AccumulateServiceExternalities", () => {
             const serviceId = null;
             const hash = Bytes.fill(HASH_SIZE, 1).asOpaque();
             const state = prepareState([prepareService(currentServiceId)]);
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.read(serviceId, hash);
             assert.strictEqual(result, null);
         });
@@ -1500,7 +2032,14 @@ describe("AccumulateServiceExternalities", () => {
             const serviceId = tryAsServiceId(33);
             const hash = Bytes.fill(HASH_SIZE, 1).asOpaque();
             const state = prepareState([prepareService(currentServiceId)]);
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.read(serviceId, hash);
             assert.strictEqual(result, null);
         });
@@ -1516,7 +2055,14 @@ describe("AccumulateServiceExternalities", () => {
             }));
             const service = prepareService(serviceId, { storage: initialStorage });
             const state = prepareState([prepareService(currentServiceId), service]);
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             const result = accumulateServiceExternalities.read(serviceId, key);
             assert.strictEqual(result, value);
         });
@@ -1525,7 +2071,14 @@ describe("AccumulateServiceExternalities", () => {
             const hash = Bytes.fill(HASH_SIZE, 1).asOpaque();
             const blob = BytesBlob.empty();
             const state = prepareState([prepareService(currentServiceId)]);
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             assert.strictEqual(state.stateUpdate.services.storage.size, 0);
             accumulateServiceExternalities.write(hash, blob);
             assert.strictEqual(state.stateUpdate.services.storage.size, 1);
@@ -1538,7 +2091,14 @@ describe("AccumulateServiceExternalities", () => {
             const newBlob = BytesBlob.parseBlob("0x11111111");
             initialStorage.set(key.toString(), StorageItem.create({ key, value }));
             const state = prepareState([prepareService(currentServiceId, { storage: initialStorage })]);
-            const accumulateServiceExternalities = new AccumulateExternalities(tinyChainSpec, blake2b, state, currentServiceId, tryAsServiceId(42), tryAsTimeSlot(16));
+            const accumulateServiceExternalities = AccumulateExternalities.forService({
+                chainSpec: tinyChainSpec,
+                blake2b: blake2b,
+                updatedState: state,
+                currentServiceId: currentServiceId,
+                nextNewServiceIdCandidate: tryAsServiceId(42),
+                currentTimeslot: tryAsTimeSlot(16),
+            });
             accumulateServiceExternalities.write(key, newBlob);
             assert.strictEqual(state.stateUpdate.services.storage.size, 1);
             const result = accumulateServiceExternalities.read(currentServiceId, key);