sig3

type AppkeyDerivationVersion int

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

type ChainLocation struct {
	TeamID    TeamID    `codec:"i"`
	Seqno     Seqno     `codec:"s"`
	ChainType ChainType `codec:"t"`
}

type ChainType = keybase1.SeqType

type ClientInfo struct {
	Desc    string `codec:"d"`
	Version string `codec:"v"`
}

type EncryptionParameters struct {
	KID     KID    `codec:"k"`
	Nonce   []byte `codec:"n"`
	Version int    `codec:"v"`
}

type Entropy []byte

type ExportJSON struct {
	Inner string `json:"i,omitempty"`
	Outer string `json:"o,omitempty"`
	Sig   string `json:"s,omitempty"`
}

type Generic interface {
	Signer() *Signer
	Prev() *LinkID
	Seqno() Seqno
	Outer() OuterLink
	Inner() *InnerLink
	// contains filtered or unexported methods
}

type IgnoreIfUnsupported bool

type InnerLink struct {
	Body        interface{} `codec:"b"`           // The actual body, which varies based on the type in the outer link
	Ctime       TimeSec     `codec:"c"`           // Seconds since 1970 UTC.
	Entropy     Entropy     `codec:"e"`           // entropy for hiding the value of the inner link
	ClientInfo  *ClientInfo `codec:"i,omitempty"` // Optional client type making sig
	MerkleRoot  MerkleRoot  `codec:"m"`           // Optional snapshot of merkle root at time of sig
	ParentChain Tail        `codec:"p"`           // grab of the most-recent chain tail of the corresponding parent chain
	Signer      Signer      `codec:"s"`           // Info on the signer, including UID, KID and eldest
	Team        *Team       `codec:"t"`           // for teams, and null otherwise
}

type KID = keybase1.BinaryKID

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

type LinkFromFuture struct {
	Base
}

type LinkID [32]byte

type LinkType int

type MerkleRoot struct {
	Ctime TimeSec `codec:"c"`
	Hash  []byte  `codec:"h"` // HashMeta of the MerkleRoot
	Seqno Seqno   `codec:"s"`
}

type OuterLink struct {
	Version             SigVersion          `codec:"version"` // should be 3
	Seqno               Seqno               `codec:"seqno"`
	Prev                *LinkID             `codec:"prev"`
	InnerLinkID         LinkID              `codec:"curr"` // hash of the msgpack of the InnerLink
	LinkType            LinkType            `codec:"type"` // hash of the msgpack of the previous OuterLink
	ChainType           ChainType           `codec:"chaintype"`
	IgnoreIfUnsupported IgnoreIfUnsupported `codec:"ignore_if_unsupported"`
	// New field for V3; if this link is encrypted, specify the format, nonce and PUK
	EncryptionParameters *EncryptionParameters `codec:"encryption_parameters"`
	// contains filtered or unexported fields
}

type PTKType = keybase1.PTKType

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

type PerTeamKey struct {
	AppkeyDerivationVersion AppkeyDerivationVersion            `codec:"a"`
	SeedCheck               keybase1.PerTeamSeedCheckPostImage `codec:"c"` // SHA256(f(i)); see teams.avdl for f(i) definition
	EncryptionKID           KID                                `codec:"e"`
	Generation              PerTeamKeyGeneration               `codec:"g"`
	ReverseSig              *Sig                               `codec:"r"` // Can be null if we are checking sigs
	SigningKID              KID                                `codec:"s"`
	PTKType                 PTKType                            `codec:"t"`
}

type PerTeamKeyGeneration = keybase1.PerTeamKeyGeneration

type RotateKey struct {
	Base
}

type RotateKeyBody struct {
	PTKs []PerTeamKey `codec:"k"`
}

type Seqno = keybase1.Seqno

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

type Sig [64]byte

type Sig3Bundle struct {
	Inner *InnerLink `json:"i,omitempty"`
	Outer OuterLink  `json:"o"`
	Sig   *Sig       `json:"s,omitempty"`
}

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

type SigVersion int

type Signer struct {
	EldestSeqno keybase1.Seqno `codec:"e"`
	KID         KID            `codec:"k"`
	UID         UID            `codec:"u"`
}

type Tail struct {
	Hash      LinkID    `codec:"h" json:"link_id"` // hash of the outer link
	Seqno     Seqno     `codec:"s" json:"seqno"`
	ChainType ChainType `codec:"t" json:"chain_type"`
}

type Team struct {
	Admin      *ChainLocation `codec:"a,omitempty"` // If working as an implicit admin, where that permission comes from
	TeamID     TeamID         `codec:"i"`
	IsImplicit bool           `codec:"m"`
	IsPublic   bool           `codec:"p"`
}

type TeamID [16]byte

type Time = keybase1.Time

type TimeSec int64

type UID [16]byte