Services (δ)

Bases: StateComponent

Source code in pyjamaz/state/components.py

class Services(StateComponent):
    component_id = 255

    def validate_extrinsic_preimages(
            self,
            extrinsic_preimages: List[Preimage],
            pre_state_services: ServicesState,
    ):
        """
        Validate quality of extrinsic preimages.
        TODO Emiel: check if pre_state_services is correct, should be after accumulate?

        Parameters
        ----------
        extrinsic_preimages
        pre_state_services

        Returns
        -------

        """
        if len(extrinsic_preimages) > 0:
            if not self.are_preimages_unique(extrinsic_preimages):
                raise StateTransitionError(ServicesErrorCode.preimages_not_sorted_unique)

            if not self.are_preimages_sorted(extrinsic_preimages):
                raise StateTransitionError(ServicesErrorCode.preimages_not_sorted_unique)

            # GP-0.7.2-eq:12.37
            for preimage in extrinsic_preimages:
                if not pre_state_services.is_preimage_needed(preimage):
                    raise StateTransitionError(ServicesErrorCode.preimage_unneeded)

    @staticmethod
    def are_preimages_unique(preimages: List[Preimage]) -> bool:
        """
        GP-0.7.2-eq:12.36 | Are all preimages unique?

        Parameters
        ----------
        preimages: List[Preimage]

        Returns
        -------
        bool
        """
        return len(preimages) == len({(p.requester, p.blob) for p in preimages})

    @staticmethod
    def are_preimages_sorted(preimages: List[Preimage]) -> bool:
        """
        GP-0.7.2-eq:12.36 | Are all preimages sorted?

        Parameters
        ----------
        preimages: List[Preimage]

        Returns
        -------
        bool
        """

        sorted_preimage = lambda p: p.sort_key()

        return all(
            sorted_preimage(preimages[i]) <= sorted_preimage(preimages[i + 1]) for i in range(len(preimages) - 1)
        )

    @log_execution_time
    async def state_transition_after_preimages(
            self,
            extrinsic_preimages: List[Preimage],
            intermediate_state_after_accumulation: ServicesState,
            post_state_timeslot: TimeslotState
    ) -> ServicesAfterPreimagesOutput:
        """
        GP-0.7.2-eq:12.38 (δ') | Final state transition function after processing Preimages for the state's
        services.

        Parameters
        ----------
        extrinsic_preimages: List[Preimage]
            GP-0.7.2-eq:4.18 (bold_E_P)
        intermediate_state_after_accumulation: ServicesState
            GP-0.7.2-eq:4.18 (δ‡)
        post_state_timeslot: TimeslotState
            GP-0.7.2-eq:4.18 (τ')

        Returns
        -------
        ServicesAfterPreimagesOutput
            Output containing: Intermediate state after processing Preimages of ServicesState (δ†)
        """

        # GP-0.7.2-eq:12.37
        for preimage in extrinsic_preimages:

            preimage_hash = blake2b_256_hash(preimage.blob)
            preimage_length = len(preimage.blob)

            pre_image_exists = intermediate_state_after_accumulation.preimage_exists(preimage.requester, preimage_hash)
            try:
                is_newly_requested = intermediate_state_after_accumulation.retrieve_preimage_availability(
                    preimage.requester, preimage_hash, preimage_length
                ) == []
            except StateKeyNoResult:
                is_newly_requested = False

            # check if preimage does not already exist and is newly requested
            if not pre_image_exists and is_newly_requested:

                # Store preimage
                intermediate_state_after_accumulation.store_preimage(
                    service_account_id=preimage.requester,
                    preimage_blob=preimage.blob,
                    save_to_tx=True
                )

                if self.app_context.pubsub:
                    await self.app_context.pubsub.publish(
                        PubSubSignal(topic=MESSAGE_TYPES.PREIMAGE, data=[preimage.requester, preimage_hash, preimage.blob])
                    )

                # Update availability information
                intermediate_state_after_accumulation.store_preimage_availability(
                    service_account_id=preimage.requester,
                    preimage_hash=preimage_hash,
                    preimage_length=preimage_length,
                    value=[post_state_timeslot.number],
                    save_to_tx=True
                )

                if self.app_context.pubsub:
                    await self.app_context.pubsub.publish(
                        PubSubSignal(
                            topic=MESSAGE_TYPES.PREIMAGE_AVAILABILITY,
                            data=[preimage.requester, preimage_hash, preimage_length, [post_state_timeslot.number]]
                        )
                    )

        return ServicesAfterPreimagesOutput(
            post_state=intermediate_state_after_accumulation
        )

    @log_execution_time
    async def state_transition_accumulation(
            self,
            accumulatable_work_reports: List[WorkReport],
            pre_state_privileged_services: PrivilegedServicesState,
            pre_state_services: ServicesState,
            pre_state_validator_queue: ValidatorQueueState,
            pre_state_authorizer_queues: AuthorizerQueuesState,
            post_state_timeslot: TimeslotState,
            post_state_entropy: EntropyState,
    ) -> ServicesAfterAccumulationOutput:
        """
        GP-0.7.2-eq:12.27 (δ†) | State transition function for the state's services.

        Parameters
        ----------
        accumulatable_work_reports: List[WorkReport]
            GP-0.7.2-eq:4.16 (R*)
        pre_state_services: ServicesState
            GP-0.7.2-eq:4.16 (δ)
        pre_state_privileged_services: PrivilegedServicesState
            GP-0.7.2-eq:4.16 (χ)
        pre_state_validator_queue: ValidatorQueueState
            GP-0.7.2-eq:4.16 (ι)
        pre_state_authorizer_queues: AuthorizerQueuesState
            GP-0.7.2-eq:4.16 (𝜙)

        Returns
        -------
        ServicesAfterAccumulationOutput
            Output containing: intermediate state of ServicesState (δ†) and BeefyCommitmentMap (C).
        """

        services = deepcopy(pre_state_services)
        services.set_state_storage(self.app_context.state_storage)
        services.pending_changes = PendingChanges()

        accumulation_state = AccumulationStateComponents(
            services=services,
            validator_queue=deepcopy(pre_state_validator_queue),
            authorizer_queues=deepcopy(pre_state_authorizer_queues),
            privileged_services=deepcopy(pre_state_privileged_services)
        )

        # GP-0.7.2-eq:12.18
        gas_limit = max(
            gp_const.GAS_TOTAL, gp_const.GAS_ACCUMULATION * gp_const.CORE_COUNT + sum(
                pre_state_privileged_services.always_accumulators.values()
            )
        )

        DEBUG and logging.debug(f'ORDERED ACCUMULATION: W^*={[format_hash(w.package_spec.hash) for w in accumulatable_work_reports]}')

        # GP-0.7.2-eq:12.18
        output = await self.full_sequential_accumulation(
            gas_limit=gas_limit,
            deferred_transfers=[],
            work_reports=accumulatable_work_reports,
            accumulation_state=accumulation_state,
            auto_accumulate_services=pre_state_privileged_services.always_accumulators,
            post_state_timeslot=post_state_timeslot,
            post_state_entropy=post_state_entropy
        )

        # GP-0.7.2-eq:12.29
        self.block_context.set_accumulation_statistics(
            accumulation_gas_utilized=output.accumulation_gas_utilized,
            nr_work_results_accumulated=output.nr_work_results_accumulated,
        )

        # GP-0.7.2-eq:12.31 | Update last_accumulation_slot
        if self.block_context.accumulation_statistics is not None:
            for s in self.block_context.accumulation_statistics.keys():
                try:
                    service_account = output.post_accumulation_state.services.retrieve_service_account(s)
                    service_account.last_accumulation_slot = post_state_timeslot.number
                    output.post_accumulation_state.services.store_service_account(s, service_account, save_to_tx=True)
                except StateKeyNoResult:
                    pass

        # GP-0.6.0-eq:12.22
        return ServicesAfterAccumulationOutput(
            intermediate_state_after_accumulation=output.post_accumulation_state.services,
            post_state_privileged_services=output.post_accumulation_state.privileged_services,
            post_state_validator_queue=output.post_accumulation_state.validator_queue,
            post_state_authorizer_queues=output.post_accumulation_state.authorizer_queues,
            beefy_commitment_map=output.accumulation_commitment,
            nr_work_results_accumulated=output.nr_work_results_accumulated,
            accumulation_gas_utilized=output.accumulation_gas_utilized
        )

    async def full_sequential_accumulation(
            self,
            gas_limit: int,
            deferred_transfers: List[DeferredTransfer],
            work_reports: List[WorkReport],
            accumulation_state: AccumulationStateComponents,
            auto_accumulate_services: Dict[int, int],
            post_state_timeslot: TimeslotState,
            post_state_entropy: EntropyState
    ) -> FullAccumulationOutput:
        """
        GP-0.7.2-eq:12.18 ∆+ | full sequential accumulation function

        Parameters
        ----------
        gas_limit: int
        deferred_transfers: List[DeferredTransfer]
        work_reports: List[WorkReport]
        accumulation_state: AccumulationStateComponents
        auto_accumulate_services: Dict[int, int]
        post_state_timeslot: TimeslotState

        TODO how to deal with post_state_timeslot and post_state_entropy, not according to GP?

        Returns
        -------
        FullAccumulationOutput
        """

        gas_used = 0
        i = 0

        for i, work_report in enumerate(work_reports, start=1):
            gas_used += sum([r.accumulate_gas for r in work_report.results])
            if gas_used > gas_limit:
                i -= 1
                break

        n = len(deferred_transfers) + i + len(auto_accumulate_services)

        if n == 0:
            return FullAccumulationOutput(
                nr_work_results_accumulated=0,
                post_accumulation_state=accumulation_state,
                accumulation_commitment=BeefyCommitmentMap(),
                accumulation_gas_utilized={}
            )

        output = await self.parallel_accumulation(
            accumulation_state=accumulation_state,
            deferred_transfers=deferred_transfers,
            work_reports=work_reports[:i],
            auto_accumulate_services=auto_accumulate_services,
            post_state_timeslot=post_state_timeslot,
            post_state_entropy=post_state_entropy
        )

        gas_limit += sum([t.gas_limit for t in deferred_transfers])  # g*

        second_output = await self.full_sequential_accumulation(
            gas_limit=gas_limit - sum([u for u in output.accumulation_gas_utilized.values()]),
            deferred_transfers=output.deferred_transfers,
            work_reports=work_reports[i:],
            accumulation_state=output.accumulation_state,
            auto_accumulate_services={},
            post_state_timeslot=post_state_timeslot,
            post_state_entropy=post_state_entropy
        )

        output.accumulation_commitment.beefy_commitment_map.update(
            second_output.accumulation_commitment.beefy_commitment_map
            )

        # Update gas statistics
        output.accumulation_gas_utilized = sum_dict_values(
            output.accumulation_gas_utilized, second_output.accumulation_gas_utilized
        )

        return FullAccumulationOutput(
            nr_work_results_accumulated=i + second_output.nr_work_results_accumulated,
            post_accumulation_state=accumulation_state,
            accumulation_commitment=output.accumulation_commitment,
            accumulation_gas_utilized=output.accumulation_gas_utilized,
        )

    async def parallel_accumulation(
            self,
            accumulation_state: AccumulationStateComponents,
            deferred_transfers: List[DeferredTransfer],
            work_reports: List[WorkReport],
            auto_accumulate_services: Dict[int, int],
            post_state_timeslot: TimeslotState,
            post_state_entropy: EntropyState
    ) -> ParallelAccumulationOutput:
        """
        GP-0.7.2-eq:12.19 ∆* | parallel accumulation function

        Parameters
        ----------
        deferred_transfers: List[DeferredTransfer]
        accumulation_state: AccumulationStateComponents
        work_reports: List[WorkReport]
        auto_accumulate_services: Dict[int, int]
        post_state_timeslot: TimeslotState
        post_state_entropy: EntropyState

        Returns
        -------
        ParallelAccumulationOutput
        """
        # s (sorted!)
        service_ids = sorted(
            set(
                [r.service_id for w in work_reports for r in w.results] + list(auto_accumulate_services.keys()) +
                [t.receiver for t in deferred_transfers]
            )
        )

        # u
        accumulation_gas_utilized = {}
        # b
        beefy_commitment_map = BeefyCommitmentMap()

        DEBUG and logging.debug(f'Services to accumulate: {service_ids}')

        outputs = []

        pre_state_delegator = accumulation_state.privileged_services.delegator  # v
        pre_state_manager = accumulation_state.privileged_services.manager  # m
        pre_state_assigners = copy(accumulation_state.privileged_services.assigners)  # a
        pre_state_registrar = accumulation_state.privileged_services.registrar  # r

        manager_delegator = pre_state_delegator  # v*
        manager_assigners = copy(pre_state_assigners)  # a*
        manager_registrar = pre_state_registrar  # r*

        if USE_THREAD_POOL_ACCUMULATE:

            DEBUG and logging.debug(f'Using ThreadPool max_workers={THREAD_POOL_MAX_WORKERS}')

            with ThreadPoolExecutor(max_workers=THREAD_POOL_MAX_WORKERS) as tp:
                futs = {
                    tp.submit(
                        self.single_step_accumulation,
                        accumulation_state=accumulation_state,
                        deferred_transfers=deferred_transfers,
                        post_state_timeslot=post_state_timeslot,
                        post_state_entropy=post_state_entropy,
                        work_reports=work_reports,
                        auto_accumulate_services=auto_accumulate_services,
                        service_id=service_id,
                    ): service_id
                    for service_id in service_ids
                }

                for fut in as_completed(futs):
                    output = fut.result()
                    service_id = futs[fut]
                    outputs.append((service_id, output))

                # Sort output again on service ID (because of async processing)
                outputs.sort(key=lambda x: x[0])
        else:
            # Process services
            for service_id in service_ids:
                output = self.single_step_accumulation(
                    accumulation_state=accumulation_state,
                    deferred_transfers=deferred_transfers,
                    post_state_timeslot=post_state_timeslot,
                    post_state_entropy=post_state_entropy,
                    work_reports=work_reports,
                    auto_accumulate_services=auto_accumulate_services,
                    service_id=service_id
                )

                outputs.append((service_id, output))

        deferred_transfers = []

        deleted_service_ids = [] # bold_m
        updated_service_ids = []

        for service_id, output in outputs:
            # Update gas usage (u)
            accumulation_gas_utilized[service_id] = output.gas_used

            # Update transfers (t')
            deferred_transfers += output.deferred_transfers

            # GP-0.7.2-eq:12.21 Process provided pre-images
            for s, i in output.preimages:
                try:
                    availability = output.state_context.services.retrieve_preimage_availability(
                        s, blake2b_256_hash(i), len(i)
                        )
                except StateKeyNoResult:
                    # TODO check this
                    availability = None
                if availability == []:
                    output.state_context.services.store_preimage_availability(
                        s, blake2b_256_hash(i), len(i), [post_state_timeslot.number]
                    )
                    output.state_context.services.store_preimage(s, i)

            if output.accumulation_output is not None:
                beefy_commitment_map.add_accumulation_output(service_id, output.accumulation_output)  # b

            if service_id == pre_state_manager:
                # Process privilege services (m', a*, v*, z')
                accumulation_state.privileged_services.manager = output.state_context.privileged_services.manager  # m'
                accumulation_state.privileged_services.always_accumulators = output.state_context.privileged_services.always_accumulators  # z'
                manager_assigners = output.state_context.privileged_services.assigners  # a*
                manager_delegator = output.state_context.privileged_services.delegator  # v*
                manager_registrar = output.state_context.privileged_services.registrar  # r*

            # Process assigners (a')
            for c in range(CORE_COUNT):
                if service_id == accumulation_state.privileged_services.assigners[c]:
                    accumulation_state.privileged_services.assigners[c] = \
                    output.state_context.privileged_services.assigners[c]

            # Process delegator (v')
            if service_id == accumulation_state.privileged_services.delegator:
                accumulation_state.privileged_services.delegator = output.state_context.privileged_services.delegator  # v'

            # Process registrar (r')
            if service_id == accumulation_state.privileged_services.registrar:
                accumulation_state.privileged_services.registrar = output.state_context.privileged_services.registrar  # r'

            # Process validator queue (i')
            if service_id == pre_state_delegator:
                accumulation_state.validator_queue = output.state_context.validator_queue

            # Process authorizer queue (q')
            for c in range(CORE_COUNT):
                if service_id == pre_state_assigners[c]:
                    accumulation_state.authorizer_queues = output.state_context.authorizer_queues

            # Apply pending changes in services to global transaction (d')

            for (s_id, storage_hash), value in output.state_context.services.pending_changes.storage_items.items():
                if value is None:
                    output.state_context.services.delete_storage_item(s_id, storage_hash, save_to_tx=True)
                else:
                    output.state_context.services.store_storage_item(s_id, storage_hash, value, save_to_tx=True)

                if self.app_context.pubsub:
                    await self.app_context.pubsub.publish(
                        PubSubSignal(topic=MESSAGE_TYPES.STORAGE_ITEM, data=[service_id, storage_hash, value])
                    )

            for (s_id, preimage_hash), value in output.state_context.services.pending_changes.preimages.items():
                if value is None:
                    output.state_context.services.delete_preimage(s_id, preimage_hash, save_to_tx=True)
                else:
                    output.state_context.services.store_preimage(s_id, value, save_to_tx=True)

                if self.app_context.pubsub:
                    await self.app_context.pubsub.publish(
                        PubSubSignal(topic=MESSAGE_TYPES.PREIMAGE, data=[service_id, preimage_hash, value])
                    )

            for (s_id, preimage_hash,
                 preimage_length), value in output.state_context.services.pending_changes.preimages_availability.items():
                if value is None:
                    output.state_context.services.delete_preimage_availability(
                        s_id, preimage_hash, preimage_length, save_to_tx=True
                        )
                else:
                    output.state_context.services.store_preimage_availability(
                        s_id, preimage_hash, preimage_length, value, save_to_tx=True
                        )

                if self.app_context.pubsub:
                    await self.app_context.pubsub.publish(
                        PubSubSignal(
                            topic=MESSAGE_TYPES.PREIMAGE_AVAILABILITY,
                            data=[service_id, preimage_hash, preimage_length, value]
                        )
                    )

            for s_id, service_account in output.state_context.services.pending_changes.service_accounts.items():

                if service_account is None:
                    deleted_service_ids.append(s_id)
                else:
                    updated_service_ids.append((s_id, service_account))

            # Apply pending_changes to accumulation_state
            accumulation_state.services.add_pending_changes(output.state_context.services.pending_changes)

        # Apply pending deleted services
        for s_id in deleted_service_ids:
            accumulation_state.services.delete_service_account(s_id, save_to_tx=True)
            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(topic=MESSAGE_TYPES.SERVICE_ACCOUNT, data=[s_id, None])
                )

        # Apply pending service account changes
        for s_id, service_account in updated_service_ids:
            if s_id not in deleted_service_ids:
                accumulation_state.services.store_service_account(s_id, service_account, save_to_tx=True)

                if self.app_context.pubsub:
                    await self.app_context.pubsub.publish(
                        PubSubSignal(topic=MESSAGE_TYPES.SERVICE_ACCOUNT, data=[s_id, service_account])
                    )

        # Check if manager service modified a', v' and r' and then override
        for c in range(CORE_COUNT):
            if pre_state_assigners[c] != manager_assigners[c]:
                accumulation_state.privileged_services.assigners[c] = manager_assigners[c]

        if pre_state_delegator != manager_delegator:
            accumulation_state.privileged_services.delegator = manager_delegator

        if pre_state_registrar != manager_registrar:
            accumulation_state.privileged_services.registrar = manager_registrar

        return ParallelAccumulationOutput(
            accumulation_state=accumulation_state,
            deferred_transfers=deferred_transfers,
            accumulation_commitment=beefy_commitment_map,
            accumulation_gas_utilized=accumulation_gas_utilized
        )

    @staticmethod
    def single_step_accumulation(
            accumulation_state: AccumulationStateComponents,
            deferred_transfers: List[DeferredTransfer],
            post_state_timeslot: TimeslotState,
            post_state_entropy: EntropyState,
            work_reports: List[WorkReport],
            auto_accumulate_services: Dict[int, int],
            service_id: int
    ) -> 'PvmAccumulateOutput':
        """
        GP-0.7.2-eq:12.24 ∆1 | single step accumulation function

        Parameters
        ----------
        accumulation_state: AccumulationStateComponents
        deferred_transfers: List[DeferredTransfer]
        post_state_timeslot: TimeslotState
        post_state_entropy: EntropyState
        work_reports: List[WorkReport]
        auto_accumulate_services: Dict[int, int]
        service_id: int

        Returns
        -------
        PvmAccumulateOutput
        """
        # g = substitute_if_nothing(auto_accumulate_services.get(service_id), 0)
        g: int = auto_accumulate_services.get(service_id, 0)

        i: List[AccumulationInput] = []

        # Add deferred transfers (i^T)
        for t in deferred_transfers:
            if t.receiver == service_id:
                g += t.gas_limit

                i.append(AccumulationInput(deferred_transfer=t))

        # Add accumulation operands (i^U)
        for w in work_reports:
            for r in w.results:
                if r.service_id == service_id:
                    g += r.accumulate_gas

                    i.append(
                        AccumulationInput(
                            accumulation_operand=AccumulationOperand(
                                work_report_hash=w.package_spec.hash,
                                work_report_exports_root=w.package_spec.exports_root,
                                work_report_authorizer_hash=w.authorizer_hash,
                                work_report_auth_output=w.auth_output,
                                work_result_payload_hash=r.payload_hash,
                                work_result_gas_limit=r.accumulate_gas,
                                work_exec_result=r.result,
                            )
                        )
                    )

        state_context = deepcopy(accumulation_state)
        state_context.services.pending_changes = PendingChanges()

        return pvm_invoke_accumulate(
            state_context=state_context,
            timeslot=post_state_timeslot.number,
            service_id=service_id,
            gas_limit=g,
            accumulation_inputs=i,
            post_entropy=post_state_entropy
        )

    def retrieve_state(self) -> ServicesState:
        # State is retrieved per service
        return ServicesState(services={})

    async def store_state(self, state: ServicesState, transaction: Optional[Transaction] = None):
        """
        State for services are stored per service account

        Parameters
        ----------
        state
        transaction

        Returns
        -------

        """
        pass

validate_extrinsic_preimages(extrinsic_preimages: List[Preimage], pre_state_services: ServicesState)

Validate quality of extrinsic preimages. TODO Emiel: check if pre_state_services is correct, should be after accumulate?

Parameters:

Name	Type	Description	Default
extrinsic_preimages	List[Preimage]		required
pre_state_services	ServicesState		required

Source code in pyjamaz/state/components.py

def validate_extrinsic_preimages(
        self,
        extrinsic_preimages: List[Preimage],
        pre_state_services: ServicesState,
):
    """
    Validate quality of extrinsic preimages.
    TODO Emiel: check if pre_state_services is correct, should be after accumulate?

    Parameters
    ----------
    extrinsic_preimages
    pre_state_services

    Returns
    -------

    """
    if len(extrinsic_preimages) > 0:
        if not self.are_preimages_unique(extrinsic_preimages):
            raise StateTransitionError(ServicesErrorCode.preimages_not_sorted_unique)

        if not self.are_preimages_sorted(extrinsic_preimages):
            raise StateTransitionError(ServicesErrorCode.preimages_not_sorted_unique)

        # GP-0.7.2-eq:12.37
        for preimage in extrinsic_preimages:
            if not pre_state_services.is_preimage_needed(preimage):
                raise StateTransitionError(ServicesErrorCode.preimage_unneeded)

are_preimages_unique(preimages: List[Preimage]) -> bool staticmethod

GP-0.7.2-eq:12.36 | Are all preimages unique?

Parameters:

Name	Type	Description	Default
preimages	List[Preimage]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
def are_preimages_unique(preimages: List[Preimage]) -> bool:
    """
    GP-0.7.2-eq:12.36 | Are all preimages unique?

    Parameters
    ----------
    preimages: List[Preimage]

    Returns
    -------
    bool
    """
    return len(preimages) == len({(p.requester, p.blob) for p in preimages})

are_preimages_sorted(preimages: List[Preimage]) -> bool staticmethod

GP-0.7.2-eq:12.36 | Are all preimages sorted?

Parameters:

Name	Type	Description	Default
preimages	List[Preimage]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
def are_preimages_sorted(preimages: List[Preimage]) -> bool:
    """
    GP-0.7.2-eq:12.36 | Are all preimages sorted?

    Parameters
    ----------
    preimages: List[Preimage]

    Returns
    -------
    bool
    """

    sorted_preimage = lambda p: p.sort_key()

    return all(
        sorted_preimage(preimages[i]) <= sorted_preimage(preimages[i + 1]) for i in range(len(preimages) - 1)
    )

state_transition_after_preimages(extrinsic_preimages: List[Preimage], intermediate_state_after_accumulation: ServicesState, post_state_timeslot: TimeslotState) -> ServicesAfterPreimagesOutput async

GP-0.7.2-eq:12.38 (δ') | Final state transition function after processing Preimages for the state's services.

Parameters:

Name	Type	Description	Default
extrinsic_preimages	List[Preimage]	GP-0.7.2-eq:4.18 (bold_E_P)	required
intermediate_state_after_accumulation	ServicesState	GP-0.7.2-eq:4.18 (δ‡)	required
post_state_timeslot	TimeslotState	GP-0.7.2-eq:4.18 (τ')	required

Returns:

Type	Description
ServicesAfterPreimagesOutput	Output containing: Intermediate state after processing Preimages of ServicesState (δ†)

Source code in pyjamaz/state/components.py

@log_execution_time
async def state_transition_after_preimages(
        self,
        extrinsic_preimages: List[Preimage],
        intermediate_state_after_accumulation: ServicesState,
        post_state_timeslot: TimeslotState
) -> ServicesAfterPreimagesOutput:
    """
    GP-0.7.2-eq:12.38 (δ') | Final state transition function after processing Preimages for the state's
    services.

    Parameters
    ----------
    extrinsic_preimages: List[Preimage]
        GP-0.7.2-eq:4.18 (bold_E_P)
    intermediate_state_after_accumulation: ServicesState
        GP-0.7.2-eq:4.18 (δ‡)
    post_state_timeslot: TimeslotState
        GP-0.7.2-eq:4.18 (τ')

    Returns
    -------
    ServicesAfterPreimagesOutput
        Output containing: Intermediate state after processing Preimages of ServicesState (δ†)
    """

    # GP-0.7.2-eq:12.37
    for preimage in extrinsic_preimages:

        preimage_hash = blake2b_256_hash(preimage.blob)
        preimage_length = len(preimage.blob)

        pre_image_exists = intermediate_state_after_accumulation.preimage_exists(preimage.requester, preimage_hash)
        try:
            is_newly_requested = intermediate_state_after_accumulation.retrieve_preimage_availability(
                preimage.requester, preimage_hash, preimage_length
            ) == []
        except StateKeyNoResult:
            is_newly_requested = False

        # check if preimage does not already exist and is newly requested
        if not pre_image_exists and is_newly_requested:

            # Store preimage
            intermediate_state_after_accumulation.store_preimage(
                service_account_id=preimage.requester,
                preimage_blob=preimage.blob,
                save_to_tx=True
            )

            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(topic=MESSAGE_TYPES.PREIMAGE, data=[preimage.requester, preimage_hash, preimage.blob])
                )

            # Update availability information
            intermediate_state_after_accumulation.store_preimage_availability(
                service_account_id=preimage.requester,
                preimage_hash=preimage_hash,
                preimage_length=preimage_length,
                value=[post_state_timeslot.number],
                save_to_tx=True
            )

            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(
                        topic=MESSAGE_TYPES.PREIMAGE_AVAILABILITY,
                        data=[preimage.requester, preimage_hash, preimage_length, [post_state_timeslot.number]]
                    )
                )

    return ServicesAfterPreimagesOutput(
        post_state=intermediate_state_after_accumulation
    )

state_transition_accumulation(accumulatable_work_reports: List[WorkReport], pre_state_privileged_services: PrivilegedServicesState, pre_state_services: ServicesState, pre_state_validator_queue: ValidatorQueueState, pre_state_authorizer_queues: AuthorizerQueuesState, post_state_timeslot: TimeslotState, post_state_entropy: EntropyState) -> ServicesAfterAccumulationOutput async

GP-0.7.2-eq:12.27 (δ†) | State transition function for the state's services.

Parameters:

Name	Type	Description	Default
accumulatable_work_reports	List[WorkReport]	GP-0.7.2-eq:4.16 (R*)	required
pre_state_services	ServicesState	GP-0.7.2-eq:4.16 (δ)	required
pre_state_privileged_services	PrivilegedServicesState	GP-0.7.2-eq:4.16 (χ)	required
pre_state_validator_queue	ValidatorQueueState	GP-0.7.2-eq:4.16 (ι)	required
pre_state_authorizer_queues	AuthorizerQueuesState	GP-0.7.2-eq:4.16 (𝜙)	required

Returns:

Type	Description
ServicesAfterAccumulationOutput	Output containing: intermediate state of ServicesState (δ†) and BeefyCommitmentMap (C).

Source code in pyjamaz/state/components.py

@log_execution_time
async def state_transition_accumulation(
        self,
        accumulatable_work_reports: List[WorkReport],
        pre_state_privileged_services: PrivilegedServicesState,
        pre_state_services: ServicesState,
        pre_state_validator_queue: ValidatorQueueState,
        pre_state_authorizer_queues: AuthorizerQueuesState,
        post_state_timeslot: TimeslotState,
        post_state_entropy: EntropyState,
) -> ServicesAfterAccumulationOutput:
    """
    GP-0.7.2-eq:12.27 (δ†) | State transition function for the state's services.

    Parameters
    ----------
    accumulatable_work_reports: List[WorkReport]
        GP-0.7.2-eq:4.16 (R*)
    pre_state_services: ServicesState
        GP-0.7.2-eq:4.16 (δ)
    pre_state_privileged_services: PrivilegedServicesState
        GP-0.7.2-eq:4.16 (χ)
    pre_state_validator_queue: ValidatorQueueState
        GP-0.7.2-eq:4.16 (ι)
    pre_state_authorizer_queues: AuthorizerQueuesState
        GP-0.7.2-eq:4.16 (𝜙)

    Returns
    -------
    ServicesAfterAccumulationOutput
        Output containing: intermediate state of ServicesState (δ†) and BeefyCommitmentMap (C).
    """

    services = deepcopy(pre_state_services)
    services.set_state_storage(self.app_context.state_storage)
    services.pending_changes = PendingChanges()

    accumulation_state = AccumulationStateComponents(
        services=services,
        validator_queue=deepcopy(pre_state_validator_queue),
        authorizer_queues=deepcopy(pre_state_authorizer_queues),
        privileged_services=deepcopy(pre_state_privileged_services)
    )

    # GP-0.7.2-eq:12.18
    gas_limit = max(
        gp_const.GAS_TOTAL, gp_const.GAS_ACCUMULATION * gp_const.CORE_COUNT + sum(
            pre_state_privileged_services.always_accumulators.values()
        )
    )

    DEBUG and logging.debug(f'ORDERED ACCUMULATION: W^*={[format_hash(w.package_spec.hash) for w in accumulatable_work_reports]}')

    # GP-0.7.2-eq:12.18
    output = await self.full_sequential_accumulation(
        gas_limit=gas_limit,
        deferred_transfers=[],
        work_reports=accumulatable_work_reports,
        accumulation_state=accumulation_state,
        auto_accumulate_services=pre_state_privileged_services.always_accumulators,
        post_state_timeslot=post_state_timeslot,
        post_state_entropy=post_state_entropy
    )

    # GP-0.7.2-eq:12.29
    self.block_context.set_accumulation_statistics(
        accumulation_gas_utilized=output.accumulation_gas_utilized,
        nr_work_results_accumulated=output.nr_work_results_accumulated,
    )

    # GP-0.7.2-eq:12.31 | Update last_accumulation_slot
    if self.block_context.accumulation_statistics is not None:
        for s in self.block_context.accumulation_statistics.keys():
            try:
                service_account = output.post_accumulation_state.services.retrieve_service_account(s)
                service_account.last_accumulation_slot = post_state_timeslot.number
                output.post_accumulation_state.services.store_service_account(s, service_account, save_to_tx=True)
            except StateKeyNoResult:
                pass

    # GP-0.6.0-eq:12.22
    return ServicesAfterAccumulationOutput(
        intermediate_state_after_accumulation=output.post_accumulation_state.services,
        post_state_privileged_services=output.post_accumulation_state.privileged_services,
        post_state_validator_queue=output.post_accumulation_state.validator_queue,
        post_state_authorizer_queues=output.post_accumulation_state.authorizer_queues,
        beefy_commitment_map=output.accumulation_commitment,
        nr_work_results_accumulated=output.nr_work_results_accumulated,
        accumulation_gas_utilized=output.accumulation_gas_utilized
    )

full_sequential_accumulation(gas_limit: int, deferred_transfers: List[DeferredTransfer], work_reports: List[WorkReport], accumulation_state: AccumulationStateComponents, auto_accumulate_services: Dict[int, int], post_state_timeslot: TimeslotState, post_state_entropy: EntropyState) -> FullAccumulationOutput async

GP-0.7.2-eq:12.18 ∆+ | full sequential accumulation function

Parameters:

Name	Type	Description	Default
gas_limit	int		required
deferred_transfers	List[DeferredTransfer]		required
work_reports	List[WorkReport]		required
accumulation_state	AccumulationStateComponents		required
auto_accumulate_services	Dict[int, int]		required
post_state_timeslot	TimeslotState		required
TODO			required

Returns:

Type	Description
FullAccumulationOutput

Source code in pyjamaz/state/components.py

async def full_sequential_accumulation(
        self,
        gas_limit: int,
        deferred_transfers: List[DeferredTransfer],
        work_reports: List[WorkReport],
        accumulation_state: AccumulationStateComponents,
        auto_accumulate_services: Dict[int, int],
        post_state_timeslot: TimeslotState,
        post_state_entropy: EntropyState
) -> FullAccumulationOutput:
    """
    GP-0.7.2-eq:12.18 ∆+ | full sequential accumulation function

    Parameters
    ----------
    gas_limit: int
    deferred_transfers: List[DeferredTransfer]
    work_reports: List[WorkReport]
    accumulation_state: AccumulationStateComponents
    auto_accumulate_services: Dict[int, int]
    post_state_timeslot: TimeslotState

    TODO how to deal with post_state_timeslot and post_state_entropy, not according to GP?

    Returns
    -------
    FullAccumulationOutput
    """

    gas_used = 0
    i = 0

    for i, work_report in enumerate(work_reports, start=1):
        gas_used += sum([r.accumulate_gas for r in work_report.results])
        if gas_used > gas_limit:
            i -= 1
            break

    n = len(deferred_transfers) + i + len(auto_accumulate_services)

    if n == 0:
        return FullAccumulationOutput(
            nr_work_results_accumulated=0,
            post_accumulation_state=accumulation_state,
            accumulation_commitment=BeefyCommitmentMap(),
            accumulation_gas_utilized={}
        )

    output = await self.parallel_accumulation(
        accumulation_state=accumulation_state,
        deferred_transfers=deferred_transfers,
        work_reports=work_reports[:i],
        auto_accumulate_services=auto_accumulate_services,
        post_state_timeslot=post_state_timeslot,
        post_state_entropy=post_state_entropy
    )

    gas_limit += sum([t.gas_limit for t in deferred_transfers])  # g*

    second_output = await self.full_sequential_accumulation(
        gas_limit=gas_limit - sum([u for u in output.accumulation_gas_utilized.values()]),
        deferred_transfers=output.deferred_transfers,
        work_reports=work_reports[i:],
        accumulation_state=output.accumulation_state,
        auto_accumulate_services={},
        post_state_timeslot=post_state_timeslot,
        post_state_entropy=post_state_entropy
    )

    output.accumulation_commitment.beefy_commitment_map.update(
        second_output.accumulation_commitment.beefy_commitment_map
        )

    # Update gas statistics
    output.accumulation_gas_utilized = sum_dict_values(
        output.accumulation_gas_utilized, second_output.accumulation_gas_utilized
    )

    return FullAccumulationOutput(
        nr_work_results_accumulated=i + second_output.nr_work_results_accumulated,
        post_accumulation_state=accumulation_state,
        accumulation_commitment=output.accumulation_commitment,
        accumulation_gas_utilized=output.accumulation_gas_utilized,
    )

parallel_accumulation(accumulation_state: AccumulationStateComponents, deferred_transfers: List[DeferredTransfer], work_reports: List[WorkReport], auto_accumulate_services: Dict[int, int], post_state_timeslot: TimeslotState, post_state_entropy: EntropyState) -> ParallelAccumulationOutput async

GP-0.7.2-eq:12.19 ∆* | parallel accumulation function

Parameters:

Name	Type	Description	Default
deferred_transfers	List[DeferredTransfer]		required
accumulation_state	AccumulationStateComponents		required
work_reports	List[WorkReport]		required
auto_accumulate_services	Dict[int, int]		required
post_state_timeslot	TimeslotState		required
post_state_entropy	EntropyState		required

Returns:

Type	Description
ParallelAccumulationOutput

Source code in pyjamaz/state/components.py

async def parallel_accumulation(
        self,
        accumulation_state: AccumulationStateComponents,
        deferred_transfers: List[DeferredTransfer],
        work_reports: List[WorkReport],
        auto_accumulate_services: Dict[int, int],
        post_state_timeslot: TimeslotState,
        post_state_entropy: EntropyState
) -> ParallelAccumulationOutput:
    """
    GP-0.7.2-eq:12.19 ∆* | parallel accumulation function

    Parameters
    ----------
    deferred_transfers: List[DeferredTransfer]
    accumulation_state: AccumulationStateComponents
    work_reports: List[WorkReport]
    auto_accumulate_services: Dict[int, int]
    post_state_timeslot: TimeslotState
    post_state_entropy: EntropyState

    Returns
    -------
    ParallelAccumulationOutput
    """
    # s (sorted!)
    service_ids = sorted(
        set(
            [r.service_id for w in work_reports for r in w.results] + list(auto_accumulate_services.keys()) +
            [t.receiver for t in deferred_transfers]
        )
    )

    # u
    accumulation_gas_utilized = {}
    # b
    beefy_commitment_map = BeefyCommitmentMap()

    DEBUG and logging.debug(f'Services to accumulate: {service_ids}')

    outputs = []

    pre_state_delegator = accumulation_state.privileged_services.delegator  # v
    pre_state_manager = accumulation_state.privileged_services.manager  # m
    pre_state_assigners = copy(accumulation_state.privileged_services.assigners)  # a
    pre_state_registrar = accumulation_state.privileged_services.registrar  # r

    manager_delegator = pre_state_delegator  # v*
    manager_assigners = copy(pre_state_assigners)  # a*
    manager_registrar = pre_state_registrar  # r*

    if USE_THREAD_POOL_ACCUMULATE:

        DEBUG and logging.debug(f'Using ThreadPool max_workers={THREAD_POOL_MAX_WORKERS}')

        with ThreadPoolExecutor(max_workers=THREAD_POOL_MAX_WORKERS) as tp:
            futs = {
                tp.submit(
                    self.single_step_accumulation,
                    accumulation_state=accumulation_state,
                    deferred_transfers=deferred_transfers,
                    post_state_timeslot=post_state_timeslot,
                    post_state_entropy=post_state_entropy,
                    work_reports=work_reports,
                    auto_accumulate_services=auto_accumulate_services,
                    service_id=service_id,
                ): service_id
                for service_id in service_ids
            }

            for fut in as_completed(futs):
                output = fut.result()
                service_id = futs[fut]
                outputs.append((service_id, output))

            # Sort output again on service ID (because of async processing)
            outputs.sort(key=lambda x: x[0])
    else:
        # Process services
        for service_id in service_ids:
            output = self.single_step_accumulation(
                accumulation_state=accumulation_state,
                deferred_transfers=deferred_transfers,
                post_state_timeslot=post_state_timeslot,
                post_state_entropy=post_state_entropy,
                work_reports=work_reports,
                auto_accumulate_services=auto_accumulate_services,
                service_id=service_id
            )

            outputs.append((service_id, output))

    deferred_transfers = []

    deleted_service_ids = [] # bold_m
    updated_service_ids = []

    for service_id, output in outputs:
        # Update gas usage (u)
        accumulation_gas_utilized[service_id] = output.gas_used

        # Update transfers (t')
        deferred_transfers += output.deferred_transfers

        # GP-0.7.2-eq:12.21 Process provided pre-images
        for s, i in output.preimages:
            try:
                availability = output.state_context.services.retrieve_preimage_availability(
                    s, blake2b_256_hash(i), len(i)
                    )
            except StateKeyNoResult:
                # TODO check this
                availability = None
            if availability == []:
                output.state_context.services.store_preimage_availability(
                    s, blake2b_256_hash(i), len(i), [post_state_timeslot.number]
                )
                output.state_context.services.store_preimage(s, i)

        if output.accumulation_output is not None:
            beefy_commitment_map.add_accumulation_output(service_id, output.accumulation_output)  # b

        if service_id == pre_state_manager:
            # Process privilege services (m', a*, v*, z')
            accumulation_state.privileged_services.manager = output.state_context.privileged_services.manager  # m'
            accumulation_state.privileged_services.always_accumulators = output.state_context.privileged_services.always_accumulators  # z'
            manager_assigners = output.state_context.privileged_services.assigners  # a*
            manager_delegator = output.state_context.privileged_services.delegator  # v*
            manager_registrar = output.state_context.privileged_services.registrar  # r*

        # Process assigners (a')
        for c in range(CORE_COUNT):
            if service_id == accumulation_state.privileged_services.assigners[c]:
                accumulation_state.privileged_services.assigners[c] = \
                output.state_context.privileged_services.assigners[c]

        # Process delegator (v')
        if service_id == accumulation_state.privileged_services.delegator:
            accumulation_state.privileged_services.delegator = output.state_context.privileged_services.delegator  # v'

        # Process registrar (r')
        if service_id == accumulation_state.privileged_services.registrar:
            accumulation_state.privileged_services.registrar = output.state_context.privileged_services.registrar  # r'

        # Process validator queue (i')
        if service_id == pre_state_delegator:
            accumulation_state.validator_queue = output.state_context.validator_queue

        # Process authorizer queue (q')
        for c in range(CORE_COUNT):
            if service_id == pre_state_assigners[c]:
                accumulation_state.authorizer_queues = output.state_context.authorizer_queues

        # Apply pending changes in services to global transaction (d')

        for (s_id, storage_hash), value in output.state_context.services.pending_changes.storage_items.items():
            if value is None:
                output.state_context.services.delete_storage_item(s_id, storage_hash, save_to_tx=True)
            else:
                output.state_context.services.store_storage_item(s_id, storage_hash, value, save_to_tx=True)

            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(topic=MESSAGE_TYPES.STORAGE_ITEM, data=[service_id, storage_hash, value])
                )

        for (s_id, preimage_hash), value in output.state_context.services.pending_changes.preimages.items():
            if value is None:
                output.state_context.services.delete_preimage(s_id, preimage_hash, save_to_tx=True)
            else:
                output.state_context.services.store_preimage(s_id, value, save_to_tx=True)

            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(topic=MESSAGE_TYPES.PREIMAGE, data=[service_id, preimage_hash, value])
                )

        for (s_id, preimage_hash,
             preimage_length), value in output.state_context.services.pending_changes.preimages_availability.items():
            if value is None:
                output.state_context.services.delete_preimage_availability(
                    s_id, preimage_hash, preimage_length, save_to_tx=True
                    )
            else:
                output.state_context.services.store_preimage_availability(
                    s_id, preimage_hash, preimage_length, value, save_to_tx=True
                    )

            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(
                        topic=MESSAGE_TYPES.PREIMAGE_AVAILABILITY,
                        data=[service_id, preimage_hash, preimage_length, value]
                    )
                )

        for s_id, service_account in output.state_context.services.pending_changes.service_accounts.items():

            if service_account is None:
                deleted_service_ids.append(s_id)
            else:
                updated_service_ids.append((s_id, service_account))

        # Apply pending_changes to accumulation_state
        accumulation_state.services.add_pending_changes(output.state_context.services.pending_changes)

    # Apply pending deleted services
    for s_id in deleted_service_ids:
        accumulation_state.services.delete_service_account(s_id, save_to_tx=True)
        if self.app_context.pubsub:
            await self.app_context.pubsub.publish(
                PubSubSignal(topic=MESSAGE_TYPES.SERVICE_ACCOUNT, data=[s_id, None])
            )

    # Apply pending service account changes
    for s_id, service_account in updated_service_ids:
        if s_id not in deleted_service_ids:
            accumulation_state.services.store_service_account(s_id, service_account, save_to_tx=True)

            if self.app_context.pubsub:
                await self.app_context.pubsub.publish(
                    PubSubSignal(topic=MESSAGE_TYPES.SERVICE_ACCOUNT, data=[s_id, service_account])
                )

    # Check if manager service modified a', v' and r' and then override
    for c in range(CORE_COUNT):
        if pre_state_assigners[c] != manager_assigners[c]:
            accumulation_state.privileged_services.assigners[c] = manager_assigners[c]

    if pre_state_delegator != manager_delegator:
        accumulation_state.privileged_services.delegator = manager_delegator

    if pre_state_registrar != manager_registrar:
        accumulation_state.privileged_services.registrar = manager_registrar

    return ParallelAccumulationOutput(
        accumulation_state=accumulation_state,
        deferred_transfers=deferred_transfers,
        accumulation_commitment=beefy_commitment_map,
        accumulation_gas_utilized=accumulation_gas_utilized
    )

single_step_accumulation(accumulation_state: AccumulationStateComponents, deferred_transfers: List[DeferredTransfer], post_state_timeslot: TimeslotState, post_state_entropy: EntropyState, work_reports: List[WorkReport], auto_accumulate_services: Dict[int, int], service_id: int) -> PvmAccumulateOutput staticmethod

GP-0.7.2-eq:12.24 ∆1 | single step accumulation function

Parameters:

Name	Type	Description	Default
accumulation_state	AccumulationStateComponents		required
deferred_transfers	List[DeferredTransfer]		required
post_state_timeslot	TimeslotState		required
post_state_entropy	EntropyState		required
work_reports	List[WorkReport]		required
auto_accumulate_services	Dict[int, int]		required
service_id	int		required

Returns:

Type	Description
PvmAccumulateOutput

Source code in pyjamaz/state/components.py

@staticmethod
def single_step_accumulation(
        accumulation_state: AccumulationStateComponents,
        deferred_transfers: List[DeferredTransfer],
        post_state_timeslot: TimeslotState,
        post_state_entropy: EntropyState,
        work_reports: List[WorkReport],
        auto_accumulate_services: Dict[int, int],
        service_id: int
) -> 'PvmAccumulateOutput':
    """
    GP-0.7.2-eq:12.24 ∆1 | single step accumulation function

    Parameters
    ----------
    accumulation_state: AccumulationStateComponents
    deferred_transfers: List[DeferredTransfer]
    post_state_timeslot: TimeslotState
    post_state_entropy: EntropyState
    work_reports: List[WorkReport]
    auto_accumulate_services: Dict[int, int]
    service_id: int

    Returns
    -------
    PvmAccumulateOutput
    """
    # g = substitute_if_nothing(auto_accumulate_services.get(service_id), 0)
    g: int = auto_accumulate_services.get(service_id, 0)

    i: List[AccumulationInput] = []

    # Add deferred transfers (i^T)
    for t in deferred_transfers:
        if t.receiver == service_id:
            g += t.gas_limit

            i.append(AccumulationInput(deferred_transfer=t))

    # Add accumulation operands (i^U)
    for w in work_reports:
        for r in w.results:
            if r.service_id == service_id:
                g += r.accumulate_gas

                i.append(
                    AccumulationInput(
                        accumulation_operand=AccumulationOperand(
                            work_report_hash=w.package_spec.hash,
                            work_report_exports_root=w.package_spec.exports_root,
                            work_report_authorizer_hash=w.authorizer_hash,
                            work_report_auth_output=w.auth_output,
                            work_result_payload_hash=r.payload_hash,
                            work_result_gas_limit=r.accumulate_gas,
                            work_exec_result=r.result,
                        )
                    )
                )

    state_context = deepcopy(accumulation_state)
    state_context.services.pending_changes = PendingChanges()

    return pvm_invoke_accumulate(
        state_context=state_context,
        timeslot=post_state_timeslot.number,
        service_id=service_id,
        gas_limit=g,
        accumulation_inputs=i,
        post_entropy=post_state_entropy
    )

store_state(state: ServicesState, transaction: Optional[Transaction] = None) async

State for services are stored per service account

Parameters:

Name	Type	Description	Default
state	ServicesState		required
transaction	Optional[Transaction]		None

Source code in pyjamaz/state/components.py

async def store_state(self, state: ServicesState, transaction: Optional[Transaction] = None):
    """
    State for services are stored per service account

    Parameters
    ----------
    state
    transaction

    Returns
    -------

    """
    pass