2.2 Key Components

2.2.1 Observer:

The Observer is a service that monitors & records the state-changes of specific protocols in real-time. It is comprised of the following modules:

1. Watcher: Watches the network for signals (e.g. event emissions) by protocols that indicate a state-change has occured.

   It requires protocol-specific components ( adapter & parser ) in order to interface with the protocol at the network level.

   It is possible to have a 1 to 1 implementation of the watcher module for each protocol, or a single watcher module that can be configured to monitor multiple protocols via pluggable adapters & parsers.

2. State Transition Detector: Identifies and validates the state transitions signalled by the watcher module.

   The Detector is notified of the state-change by the watcher module. In response, it attemps to rebuild a representation of the state from data cached in the state buffer.

   The state buffer is a ring-buffer for efficient caching of new states and quick retrieval of old states.

   And then compares the current state with the previous state usung the protocol’s state comparator function: $$\Delta S(s,s’)\to \delta$$

   Where $\delta \ne 0$ indicates a state transition.

3. Record Generator: Creates cryptographic records of state transitions, defined as the tuple:

   $$R=(Scope,e,h,h’)$$

   Where:

   • $Scope$ is the unique identifier of the protocol instance
   • $e$ is the reference to the state transition event (i.e. the block number, transaction hash)
   • $h$ is the pre-state hash
   • $h’$ is the post-state hash
   • Where $h$ & $h’$ is computed by a state-hash function: $H(s,e)\to h$
   • $h\ne h’$

2.2.2 Categorization Engine:

The Categorization Engine is crucial to the ASP’s ability in supporting compliance mechanisms & allow end-users to generate “Associaiton Sets”.

The objective of the categorization is to correctly identify attributes or properties (expressed as categories) of the state-transition event which are relevant to the compliance requirements specified by the protocol (or other entities)

Visit the classification & categorization and feature extraction sections for more details on the categorization process.

The Categorization Engine executes a FIFO pipeline of feature-extraction, classification & categorization algorithms to categorise the state-transition event referenced by the record $R$.

The output is a 256-bit vector termed “category bitmap” or $B$, where each bit represents a specific category.

The Category Pipeline is the sequential execution of:

1. Feature Extractors: Analyzes records to extract relevant features for classification.

2. Classifiers: Categorizes records based on extracted feature sets.

3. Categorizers: Generates a 256-bit category bitmap to reflect the record’s category/s

2.2.3 On-Chain Instances:

1. Public Registry: Set of on-chain smart contracts for storing & querying ASP onchain data.

More details can be found in the public registry section.

The onchain public registry supports on-chain intergration with the ASP, allowing for the following:

• Generation of Association Sets whilst preserving end-user privacy.
• Direct integration with protocol contracts for compliance verification.
• Serve public input directly to onchain verifies during a transaction that requires compliance verification.

2. ZKP Verifier: OnChain component that verifies zero-knowledge proofs of compliance.

See Zero-Knowledge Proofs section for more details