idutil

type BadTLFNameError struct {
	Name      string
	NameToLog string
}

type Clock interface {
	// Now returns the current time.
	Now() time.Time
}

type CurrentSessionGetter interface {
	// GetCurrentSession gets the current session info.
	GetCurrentSession(ctx context.Context) (SessionInfo, error)
}

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

type Identifier interface {
	// Identify resolves an assertion (which could also be a
	// username) to a UserInfo struct, spawning tracker popups if
	// necessary.  The reason string is displayed on any tracker
	// popups spawned.
	//
	// If the caller knows that the assertion needs to be identifiable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `Identify` might block on a network call.
	Identify(ctx context.Context, assertion, reason string,
		offline keybase1.OfflineAvailability) (
		kbname.NormalizedUsername, keybase1.UserOrTeamID, error)
	// IdentifyImplicitTeam identifies (and creates if necessary) the
	// given implicit team.
	//
	// If the caller knows that the team needs to be identifiable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `IdentifyImplicitTeam` might block on a
	// network call.
	IdentifyImplicitTeam(
		ctx context.Context, assertions, suffix string, tlfType tlf.Type,
		reason string, offline keybase1.OfflineAvailability) (
		ImplicitTeamInfo, error)
}

type ImplicitTeamInfo struct {
	Name  kbname.NormalizedUsername // The "display" name for the i-team.
	TID   keybase1.TeamID
	TlfID tlf.ID
}

type KBPKI interface {
	NormalizedUsernameGetter
	Resolver
	Identifier
	CurrentSessionGetter
}

type KeybaseService interface {
	MerkleRootGetter

	// Resolve, given an assertion, resolves it to a username/UID
	// pair. The username <-> UID mapping is trusted and
	// immutable, so it can be cached. If the assertion is just
	// the username or a UID assertion, then the resolution can
	// also be trusted. If the returned pair is equal to that of
	// the current session, then it can also be
	// trusted. Otherwise, Identify() needs to be called on the
	// assertion before the assertion -> (username, UID) mapping
	// can be trusted.
	//
	// If the caller knows that the assertion needs to be resolvable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `Resolve` might block on a network call.
	Resolve(ctx context.Context, assertion string,
		offline keybase1.OfflineAvailability) (
		kbname.NormalizedUsername, keybase1.UserOrTeamID, error)

	// Identify, given an assertion, returns a name and ID that
	// matches that assertion, or an error otherwise. The reason
	// string is displayed on any tracker popups spawned.
	//
	// If the caller knows that the assertion needs to be identifiable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `Identify` might block on a network call.
	Identify(ctx context.Context, assertion, reason string,
		offline keybase1.OfflineAvailability) (
		kbname.NormalizedUsername, keybase1.UserOrTeamID, error)

	// NormalizeSocialAssertion creates a SocialAssertion from its input and
	// normalizes it.  The service name will be lowercased.  If the service is
	// case-insensitive, then the username will also be lowercased.  Colon
	// assertions (twitter:user) will be transformed to the user@twitter
	// format.  Only registered services are allowed.
	NormalizeSocialAssertion(
		ctx context.Context, assertion string) (keybase1.SocialAssertion, error)

	// ResolveIdentifyImplicitTeam resolves, and optionally
	// identifies, an implicit team.  If the implicit team doesn't yet
	// exist, and doIdentifies is true, one is created.
	//
	// If the caller knows that the team needs to be resolvable while
	// offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `ResolveIdentifyImplicitTeam` might block
	// on a network call.
	ResolveIdentifyImplicitTeam(
		ctx context.Context, assertions, suffix string, tlfType tlf.Type,
		doIdentifies bool, reason string,
		offline keybase1.OfflineAvailability) (ImplicitTeamInfo, error)

	// ResolveImplicitTeamByID resolves an implicit team to a team
	// name, given a team ID.
	ResolveImplicitTeamByID(
		ctx context.Context, teamID keybase1.TeamID) (string, error)

	// CreateTeamTLF associates the given TLF ID with the team ID in
	// the team's sigchain.  If the team already has a TLF ID
	// associated with it, this overwrites it.
	CreateTeamTLF(
		ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) error

	// GetTeamSettings returns the KBFS settings for the given team.
	//
	// If the caller knows that the settings needs to be readable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `GetTeamSettings` might block on a
	// network call.
	GetTeamSettings(
		ctx context.Context, teamID keybase1.TeamID,
		offline keybase1.OfflineAvailability) (keybase1.KBFSTeamSettings, error)

	// LoadUserPlusKeys returns a UserInfo struct for a
	// user with the specified UID.
	// If you have the UID for a user and don't require Identify to
	// validate an assertion or the identity of a user, use this to
	// get UserInfo structs as it is much cheaper than Identify.
	//
	// pollForKID, if non empty, causes `PollForKID` field to be
	// populated, which causes the service to poll for the given
	// KID. This is useful during provisioning where the provisioner
	// needs to get the MD revision that the provisionee has set the
	// rekey bit on.
	//
	// If the caller knows that the user needs to be loadable while
	// offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `LoadUserPlusKeys` might block on a
	// network call.
	LoadUserPlusKeys(
		ctx context.Context, uid keybase1.UID, pollForKID keybase1.KID,
		offline keybase1.OfflineAvailability) (UserInfo, error)

	// LoadTeamPlusKeys returns a TeamInfo struct for a team with the
	// specified TeamID.  The caller can specify `desiredKeyGen` to
	// force a server check if that particular key gen isn't yet
	// known; it may be set to UnspecifiedKeyGen if no server check is
	// required.  The caller can specify `desiredUID` and
	// `desiredRole` to force a server check if that particular UID
	// isn't a member of the team yet according to local caches; it
	// may be set to "" if no server check is required.
	//
	// If the caller knows that the team needs to be loadable while
	// offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `LoadTeamPlusKeys` might block on a
	// network call.
	LoadTeamPlusKeys(ctx context.Context, tid keybase1.TeamID,
		tlfType tlf.Type, desiredKeyGen kbfsmd.KeyGen,
		desiredUser keybase1.UserVersion, desiredKey kbfscrypto.VerifyingKey,
		desiredRole keybase1.TeamRole, offline keybase1.OfflineAvailability) (
		TeamInfo, error)

	// CurrentSession returns a SessionInfo struct with all the
	// information for the current session, or an error otherwise.
	CurrentSession(ctx context.Context, sessionID int) (
		SessionInfo, error)
}

type LocalUser struct {
	UserInfo
	Asserts []string
	// Index into UserInfo.CryptPublicKeys.
	CurrentCryptPublicKeyIndex int
	// Index into UserInfo.VerifyingKeys.
	CurrentVerifyingKeyIndex int
	// Unverified keys.
	UnverifiedKeys []keybase1.PublicKey
}

type MerkleRootGetter interface {
	// GetCurrentMerkleRoot returns the current root of the global
	// Keybase Merkle tree.
	GetCurrentMerkleRoot(ctx context.Context) (
		keybase1.MerkleRootV2, time.Time, error)
	// VerifyMerkleRoot checks that the specified merkle root
	// contains the given KBFS root; if not, it returns an error.
	VerifyMerkleRoot(
		ctx context.Context, root keybase1.MerkleRootV2,
		kbfsRoot keybase1.KBFSRoot) error
}

type NoCurrentSessionError struct {
}

type NoSigChainError struct {
	User kbname.NormalizedUsername
}

type NoSuchNameError struct {
	Name      string
	NameToLog string
}

type NoSuchTeamError struct {
	Input string
}

type NoSuchUserError struct {
	Input string
}

type NormalizedUsernameGetter interface {
	// GetNormalizedUsername returns the normalized username
	// corresponding to the given UID.
	//
	// If the caller knows that the assertion needs to be resolvable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `GetNormalizedUsername` might block on a
	// network call.
	GetNormalizedUsername(
		ctx context.Context, id keybase1.UserOrTeamID,
		offline keybase1.OfflineAvailability) (
		kbname.NormalizedUsername, error)
}

type OfflineStatusGetter interface {
	OfflineAvailabilityForPath(tlfPath string) keybase1.OfflineAvailability
	OfflineAvailabilityForID(tlfID tlf.ID) keybase1.OfflineAvailability
}

type Resolver interface {
	// Resolve, given an assertion, resolves it to a username/UID
	// pair. The username <-> UID mapping is trusted and
	// immutable, so it can be cached. If the assertion is just
	// the username or a UID assertion, then the resolution can
	// also be trusted. If the returned pair is equal to that of
	// the current session, then it can also be
	// trusted. Otherwise, Identify() needs to be called on the
	// assertion before the assertion -> (username, UserOrTeamID) mapping
	// can be trusted.
	//
	//
	// If the caller knows that the assertion needs to be resolvable
	// while offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `Resolve` might block on a network call.
	//
	// TODO: some of the above assumptions on cacheability aren't
	// right for subteams, which can change their name, so this may
	// need updating.
	Resolve(ctx context.Context, assertion string,
		offline keybase1.OfflineAvailability) (
		kbname.NormalizedUsername, keybase1.UserOrTeamID, error)

	// ResolveImplicitTeam resolves the given implicit team.
	//
	// If the caller knows that the team needs to be resolvable while
	// offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `ResolveImplicitTeam` might block on a
	// network call.
	ResolveImplicitTeam(
		ctx context.Context, assertions, suffix string, tlfType tlf.Type,
		offline keybase1.OfflineAvailability) (ImplicitTeamInfo, error)

	// ResolveImplicitTeamByID resolves the given implicit team, given
	// a team ID.
	//
	// If the caller knows that the team needs to be resolvable while
	// offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `ResolveImplicitTeamByID` might block on
	// a network call.
	ResolveImplicitTeamByID(
		ctx context.Context, teamID keybase1.TeamID, tlfType tlf.Type,
		offline keybase1.OfflineAvailability) (ImplicitTeamInfo, error)
	// ResolveTeamTLFID returns the TLF ID associated with a given
	// team ID, or tlf.NullID if no ID is yet associated with that
	// team.
	//
	// If the caller knows that the ID needs to be resolved while
	// offline, they should pass in
	// `keybase1.OfflineAvailability_BEST_EFFORT` as the `offline`
	// parameter.  Otherwise `ResolveTeamTLFID` might block on a
	// network call.
	ResolveTeamTLFID(
		ctx context.Context, teamID keybase1.TeamID,
		offline keybase1.OfflineAvailability) (tlf.ID, error)

	// NormalizeSocialAssertion creates a SocialAssertion from its input and
	// normalizes it.  The service name will be lowercased.  If the service is
	// case-insensitive, then the username will also be lowercased.  Colon
	// assertions (twitter:user) will be transformed to the user@twitter
	// format.  Only registered services are allowed.
	NormalizeSocialAssertion(
		ctx context.Context, assertion string) (keybase1.SocialAssertion, error)
}

type RevokedKeyInfo struct {
	// Fields are exported so they can be copied by the codec.
	Time       keybase1.Time
	MerkleRoot keybase1.MerkleRootV2
	// contains filtered or unexported fields
}

type SessionInfo struct {
	Name           kbname.NormalizedUsername
	UID            keybase1.UID
	CryptPublicKey kbfscrypto.CryptPublicKey
	VerifyingKey   kbfscrypto.VerifyingKey
}

type TeamInfo struct {
	// Maybe this should be bare string?  The service doesn't give us
	// a nice type, unfortunately.  Also note that for implicit teams,
	// this is an auto-generated name that shouldn't be shown to
	// users.
	Name         kbname.NormalizedUsername
	TID          keybase1.TeamID
	CryptKeys    map[kbfsmd.KeyGen]kbfscrypto.TLFCryptKey
	LatestKeyGen kbfsmd.KeyGen
	RootID       keybase1.TeamID // for subteams only

	Writers map[keybase1.UID]bool
	Readers map[keybase1.UID]bool

	// Last writers map a KID to the last time the writer associated
	// with that KID trasitioned from writer to non-writer.
	LastWriters map[kbfscrypto.VerifyingKey]keybase1.MerkleRootV2
}

type TlfNameNotCanonical struct {
	Name, NameToTry string
}

type UserInfo struct {
	Name            kbname.NormalizedUsername
	UID             keybase1.UID
	VerifyingKeys   []kbfscrypto.VerifyingKey
	CryptPublicKeys []kbfscrypto.CryptPublicKey
	KIDNames        map[keybase1.KID]string
	EldestSeqno     keybase1.Seqno

	// Revoked keys, and the time at which they were revoked.
	RevokedVerifyingKeys   map[kbfscrypto.VerifyingKey]RevokedKeyInfo
	RevokedCryptPublicKeys map[kbfscrypto.CryptPublicKey]RevokedKeyInfo
}