dkgnode

type ABCIApp struct {
	types.BaseApplication
	// contains filtered or unexported fields
}

type ABCIMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	LastCreatedIndex() (keyIndex uint)
	LastUnassignedIndex() (keyIndex uint)
	RetrieveKeyMapping(keyIndex big.Int) (keyDetails KeyAssignmentPublic, err error)
	GetIndexesFromVerifierID(verifier, veriferID string) (keyIndexes []big.Int, err error)
}

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

type ABCIService struct {
	ABCIApp *ABCIApp
	// contains filtered or unexported fields
}

type ABCITransaction struct {
	Type    string      `json:"type"`
	Payload interface{} `json:"payload"`
}

type AssignmentBFTTx struct {
	Verifier   string
	VerifierID string
}

type BFTRPC struct {
	client.Client
}

type BFTRPCWSQueryHandler struct {
	idmutex.Mutex
	QueryMap   map[string]chan []byte
	QueryCount map[string]int
}

type BFTRPCWSStatus int

type BFTTxWrapper interface {
	//Create byte type and attach nonce
	PrepareBFTTx() ([]byte, error)
	//Decode byte type
	DecodeBFTTx([]byte) error
	GetSerializedBody() []byte
}

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

type BftWorkerUpdates struct {
	Type    string
	Payload interface{}
}

type CacheMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	TokenCommitExists(verifier string, tokenCommitment string) (exists bool)
	RecordTokenCommit(verifier string, tokenCommitment string)
}

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

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

type CacheSuite struct {
	CacheInstance *cache.Cache
	TokenCaches   map[string]*cache.Cache
}

type CommitmentRequestHandler struct {
	TimeNow func() time.Time
	// contains filtered or unexported fields
}

type CommitmentRequestParams struct {
	MessagePrefix      string `json:"messageprefix"`
	TokenCommitment    string `json:"tokencommitment"`
	TempPubX           string `json:"temppubx"`
	TempPubY           string `json:"temppuby"`
	VerifierIdentifier string `json:"verifieridentifier"`
}

type CommitmentRequestResult struct {
	Signature string `json:"signature"`
	Data      string `json:"data"`
	NodePubX  string `json:"nodepubx"`
	NodePubY  string `json:"nodepuby"`
}

type CommitmentRequestResultData struct {
	MessagePrefix      string `json:"messageprefix"`
	TokenCommitment    string `json:"tokencommitment"`
	TempPubX           string `json:"temppubx"`
	TempPubY           string `json:"temppuby"`
	VerifierIdentifier string `json:"verifieridentifier"`
	TimeSigned         string `json:"timesigned"`
}

type Config struct {
	HttpServerPort string `json:"httpServerPort" env:"HTTP_SERVER_PORT"`

	// Used to manage the node whilst in live
	ManagementRPCPort string `json:"managementRPCPort" env:"MANAGEMENT_RPC_PORT"`
	UseManagementRPC  bool   `json:"useManagementRPC" env:"USE_MANAGEMENT_RPC"`

	// NOTE: This is what is used for registering on the Ethereum network.
	MainServerAddress          string `json:"mainServerAddress" env:"MAIN_SERVER_ADDRESS"`
	EthConnection              string `json:"ethconnection" env:"ETH_CONNECTION"`
	EthPrivateKey              string `json:"ethprivatekey" env:"ETH_PRIVATE_KEY"`
	BftURI                     string `json:"bfturi" env:"BFT_URI"`
	ABCIServer                 string `json:"abciserver" env:"ABCI_SERVER"`
	TMP2PListenAddress         string `json:"tmp2plistenaddress" env:"TM_P2P_LISTEN_ADDRESS"`
	P2PListenAddress           string `json:"p2plistenaddress" env:"P2P_LISTEN_ADDRESS"`
	NodeListAddress            string `json:"nodelistaddress" env:"NODE_LIST_ADDRESS"`
	NumberOfNodes              int    `json:"numberofnodes" env:"NUMBER_OF_NODES"`
	Threshold                  int    `json:"threshold" env:"THRESHOLD"`     // k
	NumMalNodes                int    `json:"nummalnodes" env:"NUMMALNODES"` // t
	KeyBuffer                  int    `json:"keybuffer" env:"KEY_BUFFER"`
	KeysPerEpoch               int    `json:"keysperepoch" env:"KEYS_PER_EPOCH"`
	KeyBufferTriggerPercentage int    `json:"keybuffertriggerpercentage" env:"KEY_BUFFER_TRIGGER_PERCENTAGE"`

	// KeyBufferTriggerPercentage int    `json:"keybuffertriggerpercetage" env:"KEY_BUFFER_TRIGGER_PERCENTAGE"` // percetage threshold of keys left to trigger buffering 90 - 20
	BasePath  string `json:"basepath" env:"BASE_PATH"`
	InitEpoch int    `json:"initepoch" env:"INIT_EPOCH"`

	ShouldRegister    bool   `json:"register" env:"REGISTER"`
	CPUProfileToFile  string `json:"cpuProfile" env:"CPU_PROFILE"`
	IsDebug           bool   `json:"debug" env:"DEBUG"`
	PprofPort         string `json:"pprofPort" env:"PPROF_PORT"`
	PprofEnabled      bool   `json:"pprofEnabled" env:"PPROF_ENABLED"`
	ProvidedIPAddress string `json:"ipAddress" env:"IP_ADDRESS"`
	LogLevel          string `json:"loglevel" env:"LOG_LEVEL"`

	ServeUsingTLS    bool   `json:"useTLS" env:"USE_TLS"`
	UseAutoCert      bool   `json:"useAutoCert" env:"USE_AUTO_CERT"`
	AutoCertCacheDir string `json:"autoCertCacheDir" env:"AUTO_CERT_CACHE_DIR"`
	PublicURL        string `json:"publicURL" env:"PUBLIC_URL"`
	ServerCert       string `json:"serverCert" env:"SERVER_CERT"`
	ServerKey        string `json:"serverKey" env:"SERVER_KEY"`
	EthPollFreq      int    `json:"ethPollFreq" env:"ETH_POLL_FREQ"`

	// IDs used for oauth verification.
	GoogleClientID    string `json:"googleClientID" env:"GOOGLE_CLIENT_ID"`
	FacebookAppID     string `json:"facebookAppID" env:"FACEBOOK_APP_ID"`
	FacebookAppSecret string `json:"facebookAppSecret" env:"FACEBOOK_APP_SECRET"`
	TwitchClientID    string `json:"twitchClientID" env:"TWITCH_CLIENT_ID"`
}

type ConnectionStatus int

type ContextKey string

type DBSuite struct {
	Instance TorusDB
}

type DKGKeygennofsmTransport struct {
	Prefix KeygenProtocolPrefix

	KeygenNode *keygennofsm.KeygenNode
	// contains filtered or unexported fields
}

type DKGPSSTransport struct {
	Prefix            PSSProtocolPrefix
	PSSNode           *pss.PSSNode
	MappingFrozen     MappingFrozen
	SendMiddleware    []Middleware
	ReceiveMiddleware []Middleware
	// contains filtered or unexported fields
}

type DatabaseMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	StoreCommitmentMatrix(keyIndex big.Int, c [][]common.Point) error
	StoreKEYGENSecret(keyIndex big.Int, secret keygen.KEYGENSecrets) error
	StoreCompletedShare(keyIndex big.Int, si big.Int, siprime big.Int) error
	StorePublicKeyToIndex(publicKey common.Point, keyIndex big.Int) error
	RetrieveCommitmentMatrix(keyIndex big.Int) (c [][]common.Point, err error)
	RetrievePublicKeyToIndex(publicKey common.Point) (keyIndex big.Int, err error)
	RetrieveIndexToPublicKey(keyIndex big.Int) (publicKey common.Point, err error)
	RetrieveCompletedShare(keyIndex big.Int) (Si big.Int, Siprime big.Int, err error)
	GetShareCount() (count int)
	GetKeygenStarted(keygenID string) (started bool)
	SetKeygenStarted(keygenID string, started bool) error
}

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

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

type DefaultBFTTxWrapper struct {
	BFTTx     []byte       `json:"bft_tx,omitempty"`
	Nonce     uint32       `json:"nonce,omitempty"`
	PubKey    common.Point `json:"pub_key,omitempty"`
	MsgType   byte         `json:"msg_type,omitempty"`
	Signature []byte       `json:"signature,omitempty"`
}

type ECDSASig struct {
	Raw []byte
	R   [32]byte
	S   [32]byte
	V   uint8
}

type ECDSASignature struct {
	Raw  []byte
	Hash [32]byte
	R    [32]byte
	S    [32]byte
	V    uint8
}

type EthEpochParams struct {
	EpochID int
	N       int
	T       int
	K       int
}

type EthNodeDetails struct {
	DeclaredIp         string
	Position           big.Int
	TmP2PListenAddress string
	P2pListenAddress   string
}

type EthereumMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	GetCurrentEpoch() (epoch int)
	GetPreviousEpoch() (epoch int)
	GetNextEpoch() (epoch int)
	GetEpochInfo(epoch int) (epochInfo epochInfo, err error)
	GetCurve() (curve elliptic.Curve)
	GetSelfIndex() (index int)
	GetSelfPrivateKey() (privKey big.Int)
	GetSelfPublicKey() (pubKey common.Point)
	GetSelfAddress() (address ethCommon.Address)
	SetSelfIndex(int)
	SelfSignData(data []byte) (rawSig []byte)

	GetCurrentNodeIndexes() (nodeIndexes []big.Int)
	// GetCompleteNodeList - retrieves node references from ethereum. its a blocking func and only returns the nodeList once allNodes have been registered and are connected
	// TODO: Factor out NodeRefernce
	GetCompleteNodeList(epoch int) []NodeReference
	GetNodeList(epoch int) []NodeReference
	GetNodeDetailsByAddress(address ethCommon.Address) NodeReference
	GetNodeDetailsByEpochAndIndex(epoch int, index int) NodeReference
	GetPeerIDFromIndex(index big.Int) (id peer.ID)
	GetNodeIndexFromPubKey(ptPk common.Point) (index big.Int)
	GetECPubKFromIndex(index big.Int) (pubKey common.Point)
	GetPSSReceivingStatus(epoch int) (isPSSReceiving bool)
	AwaitNodesConnected(epoch int)
	GetPSSStatus(oldEpoch int, newEpoch int) (pssStatus int, err error)
	VerifyDataWithNodelist(pk common.Point, sig []byte, data []byte) (err error)
	VerifyDataWithEpoch(pk common.Point, sig []byte, data []byte, epoch int) (err error)
}

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

type EthereumService struct {
	idmutex.Mutex
	// contains filtered or unexported fields
}

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

type KeyAssignItem struct {
	KeyIndex string  `json:"key_index"`
	PubKeyX  big.Int `json:"pub_key_X"`
	PubKeyY  big.Int `json:"pub_key_Y"`
	Address  string  `json:"address"`
}

type KeyAssignParams struct {
	Verifier   string `json:"verifier"`
	VerifierID string `json:"verifier_id"`
}

type KeyAssignResult struct {
	Keys []KeyAssignItem `json:"keys"`
}

type KeyAssignment struct {
	KeyAssignmentPublic
	Share big.Int // Or Si
}

type KeyAssignmentPublic struct {
	Index     big.Int
	PublicKey common.Point
	Threshold int
	Verifiers map[string][]string // Verifier => VerifierID
}

type KeyGenUpdates struct {
	Type    string
	Payload interface{}
}

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

type KeyLookupParams struct {
	PubKeyX big.Int `json:"pub_key_X"`
	PubKeyY big.Int `json:"pub_key_Y"`
}

type KeyLookupResult struct {
	KeyAssignmentPublic
}

type KeygenDecision struct {
	DKGID            string   `json:"dkgid"`
	Decided          bool     `json:"decided"`
	DecidedKeygenIDs []string `json:"decidedkeygenids"`
}

type KeygenProtocolPrefix string

type KeygenPubKey struct {
	DKGID     string       `json:"dkgid"`
	Decided   bool         `json:"decided"`
	GSHSprime common.Point `json:"gshsprime"`
	GS        common.Point `json:"gs"`
}

type KeygennofsmMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	ReceiveMessage(keygenMessage keygennofsm.KeygenMessage) error
	ReceiveBFTMessage(keygenMessage keygennofsm.KeygenMessage) error
}

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

type KeygennofsmService struct {
	idmutex.Mutex

	KeygenNode *keygennofsm.KeygenNode
	// contains filtered or unexported fields
}

type MapFreeze struct {
	Frozen         bool
	ProposedFreeze map[hexstring]bool
}

type MapThaw struct {
	Thawed       bool
	ProposedThaw map[mappingHash]map[hexstring]bool
}

type MappingFreezeMsg struct {
	NodeDetails       pss.NodeDetails
	Epoch             int
	PSSProtocolPrefix PSSProtocolPrefix
	Signature         []byte
}

type MappingFrozen struct {
	idmutex.Mutex
	SendCount    map[pss.NodeDetailsID]int
	Mappings     map[mappingHash]TransferState
	MappingCount map[mappingHash]int
}

type MappingFrozenMsg struct {
	NodeDetails       pss.NodeDetails
	Epoch             int
	PSSProtocolPrefix PSSProtocolPrefix
	TransferState     TransferState
	Signature         []byte
}

type MappingThawMsg struct {
	NodeDetails          pss.NodeDetails
	Epoch                int
	PSSProtocolPrefix    PSSProtocolPrefix
	DecidedTransferState TransferState
	Signature            []byte
}

type MessageSource int

type MethodRequest struct {
	Caller  string
	Service string
	Method  string
	ID      string
	Data    []interface{}
}

type MethodResponse struct {
	Request MethodRequest
	Error   error
	Data    interface{}
}

type Middleware func(pss.PSSMessage) (modifiedMessage pss.PSSMessage, end bool, err error)

type NodeListUpdates struct {
	Type    string
	Payload interface{}
}

type NodeReference struct {
	Address         *ethCommon.Address
	Index           *big.Int
	PeerID          peer.ID
	PublicKey       *ecdsa.PublicKey
	TMP2PConnection string
	P2PConnection   string
}

type NodeRegister struct {
	AllConnected bool
	PSSReceiving bool
	PSSSending   bool
	NodeList     []*NodeReference
}

type NodeSignature struct {
	Signature   string `json:"signature"`
	Data        string `json:"data"`
	NodePubKeyX string `json:"nodepubx"`
	NodePubKeyY string `json:"nodepuby"`
}

type P2PBasicMsg struct {
	// shared between all requests
	Timestamp  big.Int `json:"timestamp,omitempty"`  // unix time
	Id         string  `json:"id,omitempty"`         // allows requesters to use request data when processing a response
	Gossip     bool    `json:"gossip,omitempty"`     // true to have receiver peer gossip the message to neighbors
	NodeId     string  `json:"nodeId,omitempty"`     // id of node that created the message (not the peer that may have sent it). =base58(multihash(nodePubKey))
	NodePubKey []byte  `json:"nodePubKey,omitempty"` // Authoring node Secp256k1 public key (32bytes)
	Sign       []byte  `json:"sign,omitempty"`       // signature of message data + method specific data by message authoring node.
	MsgType    string  `json:"msgtype,omitempty"`    // identifyng message type
	Payload    []byte  `json:"payload"`              // payload data to be unmarshalled
}

type P2PBasicMsgDeprecated struct {
	// shared between all requests
	Timestamp  int64  `json:"timestamp,omitempty"`  // unix time
	Id         string `json:"id,omitempty"`         // allows requesters to use request data when processing a response
	Gossip     bool   `json:"gossip,omitempty"`     // true to have receiver peer gossip the message to neighbors
	NodeId     string `json:"nodeId,omitempty"`     // id of node that created the message (not the peer that may have sent it). =base58(multihash(nodePubKey))
	NodePubKey []byte `json:"nodePubKey,omitempty"` // Authoring node Secp256k1 public key (32bytes)
	Sign       []byte `json:"sign,omitempty"`       // signature of message data + method specific data by message authoring node.
	MsgType    string `json:"msgtype,omitempty"`    // identifyng message type
	Payload    []byte `json:"payload"`              // payload data to be unmarshalled
}

type P2PMessage interface {
	GetTimestamp() big.Int
	GetId() string
	GetGossip() bool
	GetNodeId() string
	GetNodePubKey() []byte
	GetSign() []byte
	SetSign(sig []byte)
	GetMsgType() string
	GetPayload() []byte
	GetSerializedBody() []byte
}

type P2PMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	ID() peer.ID
	SetStreamHandler(protoName string, handler func(StreamMessage)) (err error)
	RemoveStreamHandler(protoName string) (err error)
	AuthenticateMessage(p2pMsg P2PMessage) (err error)
	AuthenticateMessageInEpoch(p2pMsg P2PMessage, epoch int) (err error)
	NewP2PMessage(messageId string, gossip bool, payload []byte, msgType string) (newMsg P2PBasicMsg)
	SignP2PMessage(message P2PMessage) (signature []byte, err error)
	SendP2PMessage(id peer.ID, p protocol.ID, msg P2PMessage) error
	ConnectToP2PNode(nodeP2PConnection string, nodePeerID peer.ID) error
	GetHostAddress() (hostAddress ma.Multiaddr)
}

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

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

type P2PSuite struct {
	host.Host
	HostAddress ma.Multiaddr
	PingProto   *PingProtocol
}

type PSSDecision struct {
	SharingID     string   `json:"sharingid"`
	Decided       bool     `json:"decided"`
	DecidedPSSIDs []string `json:"decidedpssids"`
}

type PSSMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	PSSInstanceExists(protocolPrefix PSSProtocolPrefix) (exists bool)
	GetPSSProtocolPrefix(oldEpoch int, newEpoch int) (pssProtocolPrefix PSSProtocolPrefix)
	ReceiveBFTMessage(protocolPrefix PSSProtocolPrefix, pssMessage pss.PSSMessage) error
	GetFreezeState() (freezeState int)
	SetFreezeState(freezeState int)
	GetEndIndex() (endIndex int)
	SetEndIndex(endIndex int)
	GetNewNodesN(protocolPrefix PSSProtocolPrefix) (newN int)
	GetNewNodesK(protocolPrefix PSSProtocolPrefix) (newK int)
	GetNewNodesT(protocolPrefix PSSProtocolPrefix) (newT int)
	GetOldNodesN(protocolPrefix PSSProtocolPrefix) (oldN int)
	GetOldNodesK(protocolPrefix PSSProtocolPrefix) (oldK int)
	GetOldNodesT(protocolPrefix PSSProtocolPrefix) (oldT int)
	NewPSSNode(pssStartData PSSStartData, isDealer bool, isPlayer bool) error
	ProposeFreeze(protocolPrefix PSSProtocolPrefix) error
	UpdateShareStore(protocolPrefix PSSProtocolPrefix, keygenID pss.KeygenID, sharing pss.SharingData)
	SendPSSMessageToNode(protocolPrefix PSSProtocolPrefix, pssNodeDetails pss.NodeDetails, pssMessage pss.PSSMessage) error
	IncrementCounter(counterName string)
}

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

type PSSProtocolPrefix string

type PSSService struct {
	PSSNodeInstances map[PSSProtocolPrefix]*pss.PSSNode
	// contains filtered or unexported fields
}

type PSSStartData struct {
	Message   string
	OldEpoch  int
	OldEpochN int
	OldEpochK int
	OldEpochT int
	NewEpoch  int
	NewEpochN int
	NewEpochK int
	NewEpochT int
	NodeRefs  []*NodeReference
}

type PSSSuite struct {
	idmutex.Mutex
	Version          string
	FreezeState      int
	EndIndex         uint
	PSSNodeInstances map[PSSProtocolPrefix]*pss.PSSNode
}

type PSSUpdate struct {
	MessageSource MessageSource
	NodeDetails   *NodeReference
	PSSMessage    pss.PSSMessage
}

type PSSWorkerUpdate struct {
	Type    string
	Payload interface{}
}

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

type PatchMappingParams struct {
	PSSProtocolPrefix PSSProtocolPrefix `json:"pss_protocol_prefix"`
	TransferState     TransferState     `json:"transfer_state"`
}

type PatchMappingResult struct {
}

type Ping struct {
	Message string
}

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

type PingParams struct {
	Message string `json:"message"`
}

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

type PingResult struct {
	Message string `json:"message"`
}

type SerializedNodeReference struct {
	Address         [20]byte
	Index           big.Int
	PeerID          string
	PublicKey       common.Point
	TMP2PConnection string
	P2PConnection   string
}

type ServerMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)
}

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

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

type Service interface {
	Start() error
	Stop() error
	IsRunning() bool
	SetServiceCore(ServiceCore)
	String() string
}

type ServiceCore interface {
	Name() string
	OnStart() error
	OnStop() error
	Call(method string, args ...interface{}) (result interface{}, err error)
	SetBaseService(*BaseService)
}

type ServiceLibrary interface {
	SetOwner(owner string)
	GetOwner() (owner string)
	GetEventBus() eventbus.Bus
	SetEventBus(eventbus.Bus)
	TelemetryMethods() TelemetryMethods
	EthereumMethods() EthereumMethods
	ABCIMethods() ABCIMethods
	TendermintMethods() TendermintMethods
	ServerMethods() ServerMethods
	P2PMethods() P2PMethods
	// KeygenMethods() KeygenMethods
	KeygennofsmMethods() KeygennofsmMethods
	PSSMethods() PSSMethods
	DatabaseMethods() DatabaseMethods
	VerifierMethods() VerifierMethods
	CacheMethods() CacheMethods
}

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

type ServiceRegistry struct {
	Services map[string]*BaseService
	// contains filtered or unexported fields
}

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

type ShareCountParams struct {
}

type ShareCountResult struct {
	Count int `json:"count"`
}

type ShareLog struct {
	Timestamp          time.Time
	LogNumber          int
	ShareIndex         int
	UnsigncryptedShare []byte
}

type ShareRequestHandler struct {
	TimeNow func() time.Time
	// contains filtered or unexported fields
}

type ShareRequestItem struct {
	IDToken            string          `json:"idtoken"`
	NodeSignatures     []NodeSignature `json:"nodesignatures"`
	VerifierIdentifier string          `json:"verifieridentifier"`
}

type ShareRequestParams struct {
	Item []bijson.RawMessage `json:"item"`
}

type ShareRequestResult struct {
	Keys []KeyAssignment `json:"keys"`
}

type State struct {
	// Epoch                    uint                             `json:"epoch"`
	Height                   int64                            `json:"height"`
	AppHash                  []byte                           `json:"app_hash"`
	LastUnassignedIndex      uint                             `json:"last_unassigned_index"`
	LastUnassignedTorusIndex uint                             `json:"last_unassigned_torus_index"`
	LastCreatedIndex         uint                             `json:"last_created_index"`
	KeyMapping               map[string]KeyAssignmentPublic   `json:"key_mapping"`           // KeyIndex => KeyAssignmentPublic
	VerifierToKeyIndex       map[string](map[string]TorusID)  `json:"verifier_to_key_index"` // Verifier => VerifierID => KeyIndex
	BlockTime                time.Time                        `json:"-"`                     //  updated every start of block
	PSSDecisions             map[string]PSSDecision           `json:"pss_decisions"`
	KeygenDecisions          map[string]KeygenDecision        `json:"keygen_decisions"`
	KeygenPubKeys            map[string]KeygenPubKey          `json:"keygen_pubkeys"`
	Frozen                   bool                             `json:"frozen"`
	Thawed                   bool                             `json:"thawed"`
	MapFreezes               map[PSSProtocolPrefix]*MapFreeze `json:"map_freezes"`
	MapThaws                 map[PSSProtocolPrefix]*MapThaw   `json:"map_thaws"`
}

type StreamMessage struct {
	Protocol string
	Message  P2PBasicMsg
}

type TelemetryMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)
}

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

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

type TendermintMethodResponse struct {
	Error     error
	ByteSlice []byte
}

type TendermintMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	GetNodeKey() (nodeKey tmp2p.NodeKey)
	GetStatus() (status BFTRPCWSStatus)

	Broadcast(tx interface{}) (txHash common.Hash, err error)
	RegisterQuery(query string, count int) (respChannel chan []byte, err error)
	DeregisterQuery(query string) (err error)
}

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

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

type TorusDB interface {
	StorePublicKeyToKeyIndex(publicKey common.Point, keyIndex big.Int) error
	StoreCompletedShare(keyIndex big.Int, si big.Int, siprime big.Int, publicKey common.Point) error

	RetrieveCommitmentMatrix(keyIndex big.Int) ([][]common.Point, error)
	RetrieveCompletedShare(keyIndex big.Int) (Si *big.Int, Siprime *big.Int, PublicKey *common.Point, err error)
	RetrievePublicKeyToKeyIndex(publicKey common.Point) (*big.Int, error)

	keygen.AVSSKeygenStorage

	GetKeygenStarted(keygenID string) bool
	SetKeygenStarted(keygenID string, started bool) error

	// Some Stats
	GetShareCount() int
}

type TorusID struct {
	Index      int
	KeyIndexes []big.Int
}

type TransferState struct {
	LastUnassignedIndex      uint                            `json:"last_unassigned_index"`
	LastUnassignedTorusIndex uint                            `json:"last_unassigned_torus_index"`
	LastCreatedIndex         uint                            `json:"last_created_index"`
	KeyMapping               map[string]KeyAssignmentPublic  `json:"key_mapping"`           // KeyIndex => KeyAssignmentPublic
	VerifierToKeyIndex       map[string](map[string]TorusID) `json:"verifier_to_key_index"` // Verifier => VerifierID => KeyIndex
	PubKeyMappings           map[string]common.Point         `json:"pubkey_mapping"`
}

type TransportMessage struct {
	Sender common.Point
	Data   []byte
	Sig    []byte
}

type ValidatedNodeSignature struct {
	NodeSignature
	NodeIndex big.Int
}

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

type VerifierLookupItem struct {
	KeyIndex string  `json:"key_index"`
	PubKeyX  big.Int `json:"pub_key_X"`
	PubKeyY  big.Int `json:"pub_key_Y"`
	Address  string  `json:"address"`
}

type VerifierLookupParams struct {
	Verifier   string `json:"verifier"`
	VerifierID string `json:"verifier_id"`
}

type VerifierLookupResult struct {
	Keys []VerifierLookupItem `json:"keys"`
}

type VerifierMethods interface {
	SetOwner(owner string)
	GetOwner() (owner string)

	Verify(rawMessage *bijson.RawMessage) (valid bool, verifierID string, timeIssued time.Time, err error)
	CleanToken(verifierIdentifier string, idtoken string) (cleanedToken string, err error)
	// Lookup(verifierIdentifier string) (verifier auth.Verifier, err error) // TODO: no pointers on eventBus message data
	ListVerifiers() (verifiers []string)
}

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

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

type WhitelistMonitorUpdates struct {
	Type    string
	Payload interface{}
}