validator

Documentation

Index

• Constants
• type ECDSASignature
• type Engine
• type FabSimValidator
  • func NewFabSimValidator(logger logrus.FieldLogger) *FabSimValidator
  • func (vlt *FabSimValidator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)
• type FabV14Validator
  • func NewFabV14Validator(logger logrus.FieldLogger) *FabV14Validator
  • func (vlt *FabV14Validator) EvaluateSignedData(signedData []*protoutil.SignedData, ...) (bool, uint64, error)
  • func (vlt *FabV14Validator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)
• type HappyValidator
  • func (h *HappyValidator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)
• type Ledger
• type ValidationEngine
  • func NewValidationEngine(ledger Ledger, instances *sync.Map, logger logrus.FieldLogger, gasLimit uint64) *ValidationEngine
  • func (ve *ValidationEngine) Validate(address, from string, proof, payload []byte, validators string) (bool, uint64, error)
• type Validator
• type ValidatorPool
  • func NewValidationPool(size int) *ValidatorPool
  • func (pool *ValidatorPool) Add(validator Validator)
  • func (pool *ValidatorPool) GetValidator() Validator
  • func (pool *ValidatorPool) SetValidator(vlt Validator)
• type ValidatorPools
  • func NewValidationPools() *ValidatorPools
  • func (p *ValidatorPools) GetPool(address string) (*ValidatorPool, bool)
  • func (p *ValidatorPools) SetPool(address string, pool *ValidatorPool)
• type WasmValidator
  • func NewWasmValidator(code []byte, logger logrus.FieldLogger, gasLimit uint64) *WasmValidator
  • func (vlt *WasmValidator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)

Constants

const (
	FabricRuleAddr    = "0x00000000000000000000000000000000000000a0"
	SimFabricRuleAddr = "0x00000000000000000000000000000000000000a1"
	HappyRuleAddr     = "0x00000000000000000000000000000000000000a2"
)

Types

type ECDSASignature

type ECDSASignature struct {
	R, S *big.Int
}

type Engine

type Engine interface {
	Validate(address, from string, proof, payload []byte, validators string) (bool, uint64, error)
}

Engine runs for validation

type FabSimValidator

type FabSimValidator struct {
	// contains filtered or unexported fields
}

Validator is the instance that can use wasm to verify transaction validity

func NewFabSimValidator

func NewFabSimValidator(logger logrus.FieldLogger) *FabSimValidator

New a validator instance

func (*FabSimValidator) Verify

func (vlt *FabSimValidator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)

Verify will check whether the transaction info is valid

type FabV14Validator

type FabV14Validator struct {
	// contains filtered or unexported fields
}

Validator is the instance that can use wasm to verify transaction validity

func NewFabV14Validator

func NewFabV14Validator(logger logrus.FieldLogger) *FabV14Validator

New a validator instance

func (*FabV14Validator) EvaluateSignedData

func (vlt *FabV14Validator) EvaluateSignedData(signedData []*protoutil.SignedData, identityDeserializer mspi.IdentityDeserializer, policy policies.Policy) (bool, uint64, error)

func (*FabV14Validator) Verify

func (vlt *FabV14Validator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)

Verify will check whether the transaction info is valid

type HappyValidator

type HappyValidator struct {
}

func (*HappyValidator) Verify

func (h *HappyValidator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)

type Ledger

type Ledger interface {
	// GetCode
	GetCode(*types.Address) []byte
}

type ValidationEngine

type ValidationEngine struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

Validator is the instance that can use wasm to verify transaction validity

func NewValidationEngine

func NewValidationEngine(ledger Ledger, instances *sync.Map, logger logrus.FieldLogger, gasLimit uint64) *ValidationEngine

New a validator instance

func (*ValidationEngine) Validate

func (ve *ValidationEngine) Validate(address, from string, proof, payload []byte, validators string) (bool, uint64, error)

Verify will check whether the transaction info is valid

type Validator

type Validator interface {
	Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)
}

Validator chooses specific method to verify transaction

type ValidatorPool

type ValidatorPool struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewValidationPool

func NewValidationPool(size int) *ValidatorPool

func (*ValidatorPool) Add

func (pool *ValidatorPool) Add(validator Validator)

func (*ValidatorPool) GetValidator

func (pool *ValidatorPool) GetValidator() Validator

func (*ValidatorPool) SetValidator

func (pool *ValidatorPool) SetValidator(vlt Validator)

type ValidatorPools

type ValidatorPools struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewValidationPools

func NewValidationPools() *ValidatorPools

func (*ValidatorPools) GetPool

func (p *ValidatorPools) GetPool(address string) (*ValidatorPool, bool)

func (*ValidatorPools) SetPool

func (p *ValidatorPools) SetPool(address string, pool *ValidatorPool)

type WasmValidator

type WasmValidator struct {
	// contains filtered or unexported fields
}

Validator is the instance that can use wasm to verify transaction validity

func NewWasmValidator

func NewWasmValidator(code []byte, logger logrus.FieldLogger, gasLimit uint64) *WasmValidator

New a validator instance

func (*WasmValidator) Verify

func (vlt *WasmValidator) Verify(from string, proof, payload []byte, validators string) (bool, uint64, error)

Verify will check whether the transaction info is valid