session

type AddCandidateEvent ¶

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

func NewAddCandidateEvent(
	partyID *tss.PartyID,
	joinMsg types.JoinSessionMessage,
) *AddCandidateEvent

func (e *AddCandidateEvent) SigningSessionEvent()

type AddSigningPartEvent ¶

type AddSigningPartEvent struct {
	From        *tss.PartyID
	Data        []byte
	IsBroadcast bool
}

func NewAddSigningPartEvent(
	from *tss.PartyID,
	data []byte,
	isBroadcast bool,
) *AddSigningPartEvent

func (e *AddSigningPartEvent) SigningSessionEvent()

type CandidateWaitingForLeaderState ¶

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

CandidateWaitingForLeaderState is the state of a signing session where the non-leaders wait for the leader to start the signing party.

func NewCandidateWaitingForLeaderState() (*CandidateWaitingForLeaderState, error)

func (s *CandidateWaitingForLeaderState) SigningSessionState()

type DoneNonParticipantState ¶

type DoneNonParticipantState struct {
}

DoneNonParticipantState is the state when the peer is not a participant and thus has no signature.

func NewDoneNonParticipantState() *DoneNonParticipantState

func (s *DoneNonParticipantState) SigningSessionState()

type DoneState ¶

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

DoneState is the state when the signing session is done and a signature is output.

func NewDoneState(signature tss_common.SignatureData) *DoneState

func (s *DoneState) SigningSessionState()

type ErrorState ¶

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

ErrorState is the state when an error during signing occurs.

func NewErrorState(err *tss.Error) *ErrorState

func (s *ErrorState) SigningSessionState()

type LeaderWaitingForCandidatesState ¶

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

LeaderWaitingForCandidatesState is the state of a signing session where the leader is waiting for candidates to join.

func NewLeaderWaitingForCandidatesState() (*LeaderWaitingForCandidatesState, error)

func (s *LeaderWaitingForCandidatesState) SigningSessionState()

type PickingLeaderState ¶

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

PickingLeaderState is the state of a signing session where each peer is picking the leader.

func NewPickingLeaderState() *PickingLeaderState

func (s *PickingLeaderState) SigningSessionState()

type SessionIDToTxHash ¶

type SessionIDToTxHash map[string]eth_common.Hash

SessionIDToTxHash maps session ID -> tx_hash, to get a session from session ID instead of tx_hash

type SessionStore ¶

type SessionStore struct {
	Signing *SigningSessionStore
}

func NewSessionStore() *SessionStore

type SessionTransport ¶

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

SessionTransport is a transport for a specific session.

func (mt *SessionTransport) Receive() chan mp_tss.ReceivedPartyState

func (mt *SessionTransport) Send(
	ctx context.Context,
	data []byte,
	routing *tss.MessageRouting,
	isResharing bool,
) error

type SigningSession ¶

type SigningSession struct {
	TxHash    eth_common.Hash
	MsgToSign *big.Int
	// contains filtered or unexported fields
}

SigningSession is a session for signing a message, consisting of all of the states that are required to do so for 1 transaction.

func NewSigningSession(
	ctx context.Context,
	sessionStore *SigningSessionStore,
	broadcaster broadcast.Broadcaster,
	txHash eth_common.Hash,
	msgToSign *big.Int,
	threshold int,
	currentPeerID peer.ID,
	peerIDs peer.IDSlice,
	currentPartyID *tss.PartyID,
	partyIDStore *mp_tss.PartyIDStore,
	key keygen.LocalPartySaveData,
) (*SigningSession, <-chan SigningSessionResult, error)

func (s *SigningSession) Update(event SigningSessionEvent) error

func (s *SigningSession) UpdateAddCandidateEvent(
	ev *AddCandidateEvent,
) error

func (s *SigningSession) UpdateAddSigningPartEvent(
	ev *AddSigningPartEvent,
) error

func (s *SigningSession) UpdateStartSignerEvent(
	ev *StartSignerEvent,
) error

type SigningSessionEvent ¶

type SigningSessionEvent interface {
	SigningSessionEvent()
}

SigningSessionEvent is implemented by all events that are part of a signing session.

type SigningSessionResult ¶

type SigningSessionResult struct {
	Signature *tss_common.SignatureData
	Err       *tss.Error
}

SigningSessionResult is the result of a signing session.

func NewSigningSessionResult(
	signature *tss_common.SignatureData,
	err *tss.Error,
) SigningSessionResult

func (res *SigningSessionResult) HasSignature() bool

type SigningSessionState ¶

type SigningSessionState interface {
	SigningSessionState()
}

SigningSessionState is the state of a signing session.

type SigningSessionStore ¶

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

SigningSessionStore keeps track of signing sessions.

func NewSigningSessionStore() *SigningSessionStore

func (s *SigningSessionStore) GetSessionFromID(
	sessID types.AggregateSigningSessionID,
) (*SigningSession, bool)

func (s *SigningSessionStore) GetSessionFromTxHash(txHash eth_common.Hash) (*SigningSession, bool)

func (s *SigningSessionStore) NewSession(
	ctx context.Context,
	broadcaster broadcast.Broadcaster,
	txHash eth_common.Hash,
	msgToSign *big.Int,
	threshold int,
	currentPeerID peer.ID,
	peerIDs peer.IDSlice,
	currentPartyID *tss.PartyID,
	partyIDStore *mp_tss.PartyIDStore,
	key keygen.LocalPartySaveData,
) (*SigningSession, <-chan SigningSessionResult, error)

func (s *SigningSessionStore) SetSessionID(txHash eth_common.Hash, sessID types.AggregateSigningSessionID)

type SigningState ¶

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

SigningState is the state of a signing session where all participants are signing.

func NewSigningState(transport mp_tss.Transporter) *SigningState

func (s *SigningState) SigningSessionState()

type StartSignerEvent ¶

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

func NewStartSignerEvent(
	tssParams *tss.Parameters,
	transport mp_tss.Transporter,
	participants []peer.ID,
) *StartSignerEvent

func (e *StartSignerEvent) SigningSessionEvent()

type TssSessions ¶

type TssSessions map[eth_common.Hash]*SigningSession

TssSessions maps a transaction hash to signing session