matcher

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 17, 2018 License: MIT Imports: 27 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	RANK_KEY_FMT    = "rank:%d"
	SESSION_KEY_FMT = "session:%s"
	ACCOUNT_KEY_FMT = "account:%s"
	SUBKEY_KEY_FMT  = "subkey:%s"
)

Variables

This section is empty.

Functions

func AddTokenContext 

func AddTokenContext(next http.Handler) http.Handler

Unmarshal token from query parameter and put it in request context for later retrieval and authentication logic.

func Address 

func Address(message string, signature string) (string, error)

Return the hex address (pub key) of a signed message given the message and signature

func Compact 

func Compact(inputs ...interface{}) ([]byte, error)

func Hash 

func Hash(message string) []byte

func IToB 

func IToB(data interface{}) ([]byte, error)

Types

type Code 

type Code int
const (
	TERMINATE Code = -2 // unrecoverable fatal error
	ERROR     Code = -1

	MSG              Code = 0 // code for messages passed between players during gameplay
	INIT             Code = 1 // match found
	SIGNED_TIMESTAMP Code = 2
	MATCH_VERIFIED   Code = 3 // all players in match session have passed all validation tests
)
const (
	UNSUBSCRIBE Code = -100 // a internal PubSubManager message type
)

type InitMessage 

type InitMessage struct {
	Timestamp int64 `json:"timestamp"`
}

type MatchResponse 

type MatchResponse struct {
	Account common.Address // Owner of seed deck; this value is derived
	Rank    uint32         // calculated rank of player based on seed "deck"
	*Token
}

type Message 

type Message struct {
	*Meta   `json:"meta"`
	Payload string `json:"payload"`
}

Message send over the wire between players

func NewError 

func NewError(message string) Message

func NewTerminateMessage 

func NewTerminateMessage(message string) Message

type Meta 

type Meta struct {
	Index  uint8           `json:"index"` // index of player in game, i.e., player ID
	Code   Code            `json:"code"`  // message type
	SubKey *common.Address `json:"subkey"`
}

type PlayerInfo 

type PlayerInfo struct {
	Rank  uint32 `json:"rank"`  // Player rank as returned from Solidity pure function
	Index uint8  `json:"index"` // index in match session; arbitrarily set when match found and player joins a session
	*Token

	SeedHash     []byte            `json:"seedHash,string"` // Hash of seed as returned from Solidity pure function
	Account      *common.Address   `json:"account,string"`  // owner account of signed subkey (derived from Token); See Token
	TimestampSig *crypto.Signature `json:"timestampSig"`    // TimestampSig of session timestamp by this player
	Verified     bool              `json:"verified"`        // true if the player has proven their TimestampSig
}

type PubSubManager 

type PubSubManager struct {
	Channels map[string]chan *Message // subkey -> listening channel
	*SessionManager
}

func NewPubSubManager 

func NewPubSubManager(smgr *SessionManager) *PubSubManager

func (*PubSubManager) Publish 

func (mgr *PubSubManager) Publish(channel string, msg Message) error

func (*PubSubManager) Subscribe 

func (mgr *PubSubManager) Subscribe(key string, channel chan *Message)

func (*PubSubManager) Unsubscribe 

func (mgr *PubSubManager) Unsubscribe(key string)

type Service 

type Service struct {
	ArcClient *arcadeum.Client
	ENV       *config.ENVConfig
	Config    *config.MatcherConfig
	*SessionManager
	*PubSubManager
}

func NewService 

func NewService(
	env *config.ENVConfig,
	cfg *config.MatcherConfig,
	ethcfg *config.ETHConfig,
	arcconfig *config.ArcadeumConfig,
	rediscfg *config.RedisConfig) *Service

func (*Service) AddToMatchPool 

func (s *Service) AddToMatchPool(r *MatchResponse) error

func (*Service) Authenticate 

func (s *Service) Authenticate(token *Token) (*MatchResponse, error)

func (*Service) BeginVerifiedMatch 

func (srv *Service) BeginVerifiedMatch(sess *Session) error

Session has been verified so begin match and send message to each player

func (*Service) BuildMatchVerifiedMessageWithSignature 

func (srv *Service) BuildMatchVerifiedMessageWithSignature(s *Session) (*arcadeum.MatchVerifiedMessage, error)

func (*Service) BuildPlayerInfo 

func (s *Service) BuildPlayerInfo(p *MatchResponse) (*PlayerInfo, error)

func (*Service) Close 

func (s *Service) Close(message string, p ...*MatchResponse)

func (*Service) CreateSession 

func (s *Service) CreateSession(p *MatchResponse) (*Session, error)

func (*Service) FindMatch 

func (s *Service) FindMatch(token *Token)

func (*Service) HandleMatchResponses 

func (s *Service) HandleMatchResponses()

func (*Service) InitGame 

func (s *Service) InitGame(uid UUID, r *MatchResponse) error

func (*Service) Match 

func (s *Service) Match(rp *MatchResponse)

Invariant: rp has been authenticated

func (*Service) NewKeyedTransactor 

func (s *Service) NewKeyedTransactor() *bind.TransactOpts

func (*Service) OnMessage 

func (s *Service) OnMessage(msg *Message) error

func (*Service) OnWithdrawalStarted 

func (s *Service) OnWithdrawalStarted(event *arcadeum.ArcadeumWithdrawalStarted)

Event handler when we have detected when a user has decided to withdraw money from their account

func (*Service) PrivKey 

func (srv *Service) PrivKey() *ecdsa.PrivateKey

func (*Service) PublishToSubKey 

func (s *Service) PublishToSubKey(subKey *common.Address, message Message) error

func (*Service) Reconnect 

func (s *Service) Reconnect(token *Token) (bool, error)

func (*Service) RemoveFromWaitingPool 

func (s *Service) RemoveFromWaitingPool(resps ...*MatchResponse)

func (*Service) RequestTimestampProof 

func (s *Service) RequestTimestampProof(sess *Session) error

func (*Service) SendTimestampProof 

func (s *Service) SendTimestampProof(p *PlayerInfo, timestamp int64) error

func (*Service) Sign 

func (srv *Service) Sign(inputs ...interface{}) ([]byte, error)

func (*Service) SignElliptic 

func (srv *Service) SignElliptic(inputs ...interface{}) (r, s *big.Int, err error)

func (*Service) SubscribeToSubKey 

func (s *Service) SubscribeToSubKey(subkey *common.Address, messages chan *Message)

Subscribed to published messages for this player

func (*Service) VerifyTimestamp 

func (s *Service) VerifyTimestamp(req *arcadeum.VerifyTimestampRequest, player *PlayerInfo) (bool, error)

type Session 

type Session struct {
	ID        UUID              `json:"id,string"`
	GameID    uint32            `json:"gameID"`
	Player1   *PlayerInfo       `json:"player1"`
	Player2   *PlayerInfo       `json:"player2"`
	Timestamp int64             `json:"timestamp"` // Game start in Unix time
	Signature *crypto.Signature `json:"signature"` // Matcher's session signature
}

Represents a matched game session

func (*Session) FindOpponent 

func (s *Session) FindOpponent(subKey *common.Address) *PlayerInfo

func (*Session) FindPlayerByAccount 

func (s *Session) FindPlayerByAccount(account common.Address) (*PlayerInfo, error)

func (*Session) FindPlayerBySubKey 

func (s *Session) FindPlayerBySubKey(subKey *common.Address) *PlayerInfo

func (*Session) IsEmpty 

func (s *Session) IsEmpty() bool

func (*Session) IsVerified 

func (s *Session) IsVerified() bool

func (*Session) IsWaiting 

func (s *Session) IsWaiting() bool

func (*Session) Rank 

func (s *Session) Rank() uint32

func (*Session) UUID 

func (s *Session) UUID() string

type SessionManager 

type SessionManager struct {
	SessionPool map[UUID]*Session // map session UUID -> in-game session
	RedisClient *redis.Client
}

func NewSessionManager 

func NewSessionManager(rediscfg *config.RedisConfig) *SessionManager

func (*SessionManager) AddToMatchPool 

func (mgr *SessionManager) AddToMatchPool(sess *Session) error

func (*SessionManager) GetSessionByAccount 

func (mgr *SessionManager) GetSessionByAccount(key *common.Address) (*Session, error)

func (*SessionManager) GetSessionByID 

func (mgr *SessionManager) GetSessionByID(uid UUID) (*Session, error)

func (*SessionManager) GetSessionBySubKey 

func (mgr *SessionManager) GetSessionBySubKey(key *common.Address) (*Session, error)

func (*SessionManager) ReaddToMatchPool 

func (mgr *SessionManager) ReaddToMatchPool(rank uint32, uid UUID) error

func (*SessionManager) TakeRandomSessionByRank 

func (mgr *SessionManager) TakeRandomSessionByRank(rank uint32) (UUID, error)

Find a similarly ranked player to play, pseudo-randomly chosen. Returns the UUID of the game session. This method will remove the waiting session from the wait pool. If a session is not found and there are no errors, an empty UUID is returned.

func (*SessionManager) UpdateSession 

func (mgr *SessionManager) UpdateSession(sess *Session) error

type Status 

type Status int
const (
	Unknown      Status = 0
	Waiting      Status = 1
	Moving       Status = 2
	Won          Status = 3
	Lost         Status = 4
	Disqualified Status = 5
)

type Token 

type Token struct {
	GameID          uint32            `json:"gameID"`        // globally unique game ID
	SubKey          *common.Address   `json:"subkey,string"` // public address of account owner of subkey; effectively the Match ID
	SubKeySignature *crypto.Signature `json:"signature"`     // Signed signature of SubKey to prove SubKey ownership
	Seed            []byte            `json:"seed,string"`   // game "deck"; unmarshalled base64; never share with opponents!
}

Request token. This token is returned as a base64 string by a client requesting to play a game.

func Context 

func Context(r *http.Request) *Token

type UUID 

type UUID string

func (UUID) IsEmpty 

func (u UUID) IsEmpty() bool

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.