github.com/baptiste-b-pegasys/quorum/v22@v22.4.2/core/multiple_psm.go (about)

     1  package core
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  
     7  	"github.com/ethereum/go-ethereum/common"
     8  	"github.com/ethereum/go-ethereum/core/mps"
     9  	"github.com/ethereum/go-ethereum/core/privatecache"
    10  	"github.com/ethereum/go-ethereum/core/rawdb"
    11  	"github.com/ethereum/go-ethereum/core/state"
    12  	"github.com/ethereum/go-ethereum/core/types"
    13  	"github.com/ethereum/go-ethereum/ethdb"
    14  	"github.com/ethereum/go-ethereum/rpc"
    15  	"github.com/ethereum/go-ethereum/trie"
    16  )
    17  
    18  type MultiplePrivateStateManager struct {
    19  	// Low level persistent database to store final content in
    20  	db                     ethdb.Database
    21  	privateStatesTrieCache state.Database
    22  	privateCacheProvider   privatecache.Provider
    23  
    24  	residentGroupByKey map[string]*mps.PrivateStateMetadata
    25  	privacyGroupById   map[types.PrivateStateIdentifier]*mps.PrivateStateMetadata
    26  }
    27  
    28  func newMultiplePrivateStateManager(db ethdb.Database, privateCacheProvider privatecache.Provider, residentGroupByKey map[string]*mps.PrivateStateMetadata, privacyGroupById map[types.PrivateStateIdentifier]*mps.PrivateStateMetadata) (*MultiplePrivateStateManager, error) {
    29  	return &MultiplePrivateStateManager{
    30  		db:                     db,
    31  		privateStatesTrieCache: privateCacheProvider.GetCacheWithConfig(),
    32  		privateCacheProvider:   privateCacheProvider,
    33  		residentGroupByKey:     residentGroupByKey,
    34  		privacyGroupById:       privacyGroupById,
    35  	}, nil
    36  }
    37  
    38  func (m *MultiplePrivateStateManager) StateRepository(blockHash common.Hash) (mps.PrivateStateRepository, error) {
    39  	privateStatesTrieRoot := rawdb.GetPrivateStatesTrieRoot(m.db, blockHash)
    40  	return mps.NewMultiplePrivateStateRepository(m.db, m.privateStatesTrieCache, privateStatesTrieRoot, m.privateCacheProvider)
    41  }
    42  
    43  func (m *MultiplePrivateStateManager) ResolveForManagedParty(managedParty string) (*mps.PrivateStateMetadata, error) {
    44  	psm, found := m.residentGroupByKey[managedParty]
    45  	if !found {
    46  		return nil, fmt.Errorf("unable to find private state metadata for managed party %s", managedParty)
    47  	}
    48  	return psm, nil
    49  }
    50  
    51  func (m *MultiplePrivateStateManager) ResolveForUserContext(ctx context.Context) (*mps.PrivateStateMetadata, error) {
    52  	psi, ok := rpc.PrivateStateIdentifierFromContext(ctx)
    53  	if !ok {
    54  		psi = types.DefaultPrivateStateIdentifier
    55  	}
    56  	psm, found := m.privacyGroupById[psi]
    57  	if !found {
    58  		return nil, fmt.Errorf("unable to find private state for context psi %s", psi)
    59  	}
    60  	return psm, nil
    61  }
    62  
    63  func (m *MultiplePrivateStateManager) PSIs() []types.PrivateStateIdentifier {
    64  	psis := make([]types.PrivateStateIdentifier, 0, len(m.privacyGroupById))
    65  	for psi := range m.privacyGroupById {
    66  		psis = append(psis, psi)
    67  	}
    68  	return psis
    69  }
    70  
    71  func (m *MultiplePrivateStateManager) NotIncludeAny(psm *mps.PrivateStateMetadata, managedParties ...string) bool {
    72  	return psm.NotIncludeAny(managedParties...)
    73  }
    74  
    75  func (m *MultiplePrivateStateManager) CheckAt(root common.Hash) error {
    76  	_, err := state.New(rawdb.GetPrivateStatesTrieRoot(m.db, root), m.privateStatesTrieCache, nil)
    77  	return err
    78  }
    79  
    80  func (m *MultiplePrivateStateManager) TrieDB() *trie.Database {
    81  	return m.privateStatesTrieCache.TrieDB()
    82  }