github.com/Unheilbar/quorum@v1.0.0/extension/privacyExtension/state_set_utilities.go (about)

     1  package privacyExtension
     2  
     3  import (
     4  	"math/big"
     5  
     6  	"github.com/ethereum/go-ethereum/common"
     7  	"github.com/ethereum/go-ethereum/core/state"
     8  	"github.com/ethereum/go-ethereum/core/types"
     9  	extension "github.com/ethereum/go-ethereum/extension/extensionContracts"
    10  	"github.com/ethereum/go-ethereum/log"
    11  	"github.com/ethereum/go-ethereum/private"
    12  	"github.com/ethereum/go-ethereum/private/engine"
    13  )
    14  
    15  func setState(privateState *state.StateDB, accounts map[string]extension.AccountWithMetadata, privacyMetaData *state.PrivacyMetadata, managedParties []string) bool {
    16  	log.Debug("Extension: set private state explicitly from state dump")
    17  	for key, value := range accounts {
    18  		stateDump := value.State
    19  
    20  		contractAddress := common.HexToAddress(key)
    21  
    22  		privateState.CreateAccount(contractAddress)
    23  		newBalance, errBalanceSet := new(big.Int).SetString(stateDump.Balance, 10)
    24  		if !errBalanceSet {
    25  			log.Error("could not set address balance", "address", key, "balance", stateDump.Balance)
    26  			return false
    27  		}
    28  		privateState.SetBalance(contractAddress, newBalance)
    29  		privateState.SetNonce(contractAddress, stateDump.Nonce)
    30  		privateState.SetCode(contractAddress, common.Hex2Bytes(stateDump.Code))
    31  		for keyStore, valueStore := range stateDump.Storage {
    32  			privateState.SetState(contractAddress, keyStore, common.HexToHash(valueStore))
    33  		}
    34  		if privacyMetaData.PrivacyFlag != engine.PrivacyFlagStandardPrivate {
    35  			privateState.SetPrivacyMetadata(contractAddress, privacyMetaData)
    36  		}
    37  		if managedParties != nil {
    38  			privateState.SetManagedParties(contractAddress, managedParties)
    39  		}
    40  	}
    41  	return true
    42  }
    43  
    44  // updates the privacy metadata
    45  func setPrivacyMetadata(privateState *state.StateDB, address common.Address, hash string) {
    46  	privacyMetaData, err := privateState.GetPrivacyMetadata(address)
    47  	if err != nil || privacyMetaData.PrivacyFlag.IsStandardPrivate() {
    48  		return
    49  	}
    50  
    51  	ptmHash, err := common.Base64ToEncryptedPayloadHash(hash)
    52  	if err != nil {
    53  		log.Error("setting privacy metadata failed", "err", err)
    54  		return
    55  	}
    56  	pm := state.NewStatePrivacyMetadata(ptmHash, privacyMetaData.PrivacyFlag)
    57  	privateState.SetPrivacyMetadata(address, pm)
    58  }
    59  
    60  func setManagedParties(ptm private.PrivateTransactionManager, privateState *state.StateDB, address common.Address, hash string) {
    61  	existingManagedParties, err := privateState.GetManagedParties(address)
    62  	if err != nil {
    63  		return
    64  	}
    65  
    66  	ptmHash, err := common.Base64ToEncryptedPayloadHash(hash)
    67  	if err != nil {
    68  		log.Error("setting privacy metadata failed", "err", err)
    69  		return
    70  	}
    71  
    72  	_, managedParties, _, _, _ := ptm.Receive(ptmHash)
    73  	newManagedParties := common.AppendSkipDuplicates(existingManagedParties, managedParties...)
    74  	privateState.SetManagedParties(address, newManagedParties)
    75  }
    76  
    77  func logContainsExtensionTopic(receivedLog *types.Log) bool {
    78  	if len(receivedLog.Topics) != 1 {
    79  		return false
    80  	}
    81  	return receivedLog.Topics[0].String() == extension.StateSharedTopicHash
    82  }
    83  
    84  // validateAccountsExist checks that all the accounts in the expected list are
    85  // present in the state map, and that no  other accounts exist in the state map
    86  // that are unexpected
    87  func validateAccountsExist(expectedAccounts []common.Address, actualAccounts map[string]extension.AccountWithMetadata) bool {
    88  	if len(expectedAccounts) != len(actualAccounts) {
    89  		return false
    90  	}
    91  	for _, account := range expectedAccounts {
    92  		_, exists := actualAccounts[account.String()]
    93  		if !exists {
    94  			return false
    95  		}
    96  	}
    97  	return true
    98  }