Reorganize folder structure to hopefully make imports easier

go.mod

@@ -1,3 +1,3 @@
-module samhofi.us/x/keybase/v2
+module samhofi.us/x/keybase
 
 go 1.13

types/keybase1/notify_ctl.go

@@ -1,70 +0,0 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/notify_ctl.avdl
-
-package keybase1
-
-type NotificationChannels struct {
-	Session          bool `codec:"session" json:"session"`
-	Users            bool `codec:"users" json:"users"`
-	Kbfs             bool `codec:"kbfs" json:"kbfs"`
-	Kbfsdesktop      bool `codec:"kbfsdesktop" json:"kbfsdesktop"`
-	Kbfslegacy       bool `codec:"kbfslegacy" json:"kbfslegacy"`
-	Kbfssubscription bool `codec:"kbfssubscription" json:"kbfssubscription"`
-	Tracking         bool `codec:"tracking" json:"tracking"`
-	Favorites        bool `codec:"favorites" json:"favorites"`
-	Paperkeys        bool `codec:"paperkeys" json:"paperkeys"`
-	Keyfamily        bool `codec:"keyfamily" json:"keyfamily"`
-	Service          bool `codec:"service" json:"service"`
-	App              bool `codec:"app" json:"app"`
-	Chat             bool `codec:"chat" json:"chat"`
-	PGP              bool `codec:"pgp" json:"pgp"`
-	Kbfsrequest      bool `codec:"kbfsrequest" json:"kbfsrequest"`
-	Badges           bool `codec:"badges" json:"badges"`
-	Reachability     bool `codec:"reachability" json:"reachability"`
-	Team             bool `codec:"team" json:"team"`
-	Ephemeral        bool `codec:"ephemeral" json:"ephemeral"`
-	Teambot          bool `codec:"teambot" json:"teambot"`
-	Chatkbfsedits    bool `codec:"chatkbfsedits" json:"chatkbfsedits"`
-	Chatdev          bool `codec:"chatdev" json:"chatdev"`
-	Deviceclone      bool `codec:"deviceclone" json:"deviceclone"`
-	Chatattachments  bool `codec:"chatattachments" json:"chatattachments"`
-	Wallet           bool `codec:"wallet" json:"wallet"`
-	Audit            bool `codec:"audit" json:"audit"`
-	Runtimestats     bool `codec:"runtimestats" json:"runtimestats"`
-	FeaturedBots     bool `codec:"featuredBots" json:"featuredBots"`
-	Saltpack         bool `codec:"saltpack" json:"saltpack"`
-}
-
-func (o NotificationChannels) DeepCopy() NotificationChannels {
-	return NotificationChannels{
-		Session:          o.Session,
-		Users:            o.Users,
-		Kbfs:             o.Kbfs,
-		Kbfsdesktop:      o.Kbfsdesktop,
-		Kbfslegacy:       o.Kbfslegacy,
-		Kbfssubscription: o.Kbfssubscription,
-		Tracking:         o.Tracking,
-		Favorites:        o.Favorites,
-		Paperkeys:        o.Paperkeys,
-		Keyfamily:        o.Keyfamily,
-		Service:          o.Service,
-		App:              o.App,
-		Chat:             o.Chat,
-		PGP:              o.PGP,
-		Kbfsrequest:      o.Kbfsrequest,
-		Badges:           o.Badges,
-		Reachability:     o.Reachability,
-		Team:             o.Team,
-		Ephemeral:        o.Ephemeral,
-		Teambot:          o.Teambot,
-		Chatkbfsedits:    o.Chatkbfsedits,
-		Chatdev:          o.Chatdev,
-		Deviceclone:      o.Deviceclone,
-		Chatattachments:  o.Chatattachments,
-		Wallet:           o.Wallet,
-		Audit:            o.Audit,
-		Runtimestats:     o.Runtimestats,
-		FeaturedBots:     o.FeaturedBots,
-		Saltpack:         o.Saltpack,
-	}
-}

types/keybase1/teamsearch.go

@@ -1,62 +0,0 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/teamsearch.avdl
-
-package keybase1
-
-type TeamSearchItem struct {
-	Id           TeamID   `codec:"id" json:"id"`
-	Name         string   `codec:"name" json:"name"`
-	Description  *string  `codec:"description,omitempty" json:"description,omitempty"`
-	MemberCount  int      `codec:"memberCount" json:"memberCount"`
-	LastActive   Time     `codec:"lastActive" json:"lastActive"`
-	InTeam       bool     `codec:"inTeam" json:"inTeam"`
-	PublicAdmins []string `codec:"publicAdmins" json:"publicAdmins"`
-}
-
-func (o TeamSearchItem) DeepCopy() TeamSearchItem {
-	return TeamSearchItem{
-		Id:   o.Id.DeepCopy(),
-		Name: o.Name,
-		Description: (func(x *string) *string {
-			if x == nil {
-				return nil
-			}
-			tmp := (*x)
-			return &tmp
-		})(o.Description),
-		MemberCount: o.MemberCount,
-		LastActive:  o.LastActive.DeepCopy(),
-		InTeam:      o.InTeam,
-		PublicAdmins: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.PublicAdmins),
-	}
-}
-
-type TeamSearchRes struct {
-	Results []TeamSearchItem `codec:"results" json:"results"`
-}
-
-func (o TeamSearchRes) DeepCopy() TeamSearchRes {
-	return TeamSearchRes{
-		Results: (func(x []TeamSearchItem) []TeamSearchItem {
-			if x == nil {
-				return nil
-			}
-			ret := make([]TeamSearchItem, len(x))
-			for i, v := range x {
-				vCopy := v.DeepCopy()
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Results),
-	}
-}

v1/chat.go

@@ -0,0 +1,556 @@
+package keybase
+
+import (
+	"bufio"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// Returns a string representation of a message id suitable for use in a
+// pagination struct
+func getID(id uint) string {
+	var b []byte
+	switch {
+	case id < 128:
+		// 7-bit int
+		b = make([]byte, 1)
+		b = []byte{byte(id)}
+
+	case id <= 255:
+		// uint8
+		b = make([]byte, 2)
+		b = []byte{204, byte(id)}
+
+	case id > 255 && id <= 65535:
+		// uint16
+		b = make([]byte, 2)
+		binary.BigEndian.PutUint16(b, uint16(id))
+		b = append([]byte{205}, b...)
+
+	case id > 65535 && id <= 4294967295:
+		// uint32
+		b = make([]byte, 4)
+		binary.BigEndian.PutUint32(b, uint32(id))
+		b = append([]byte{206}, b...)
+	}
+	return base64.StdEncoding.EncodeToString(b)
+}
+
+// Creates a string of a json-encoded channel to pass to keybase chat api-listen --filter-channel
+func createFilterString(channel Channel) string {
+	if channel.Name == "" {
+		return ""
+	}
+	jsonBytes, _ := json.Marshal(channel)
+	return string(jsonBytes)
+}
+
+// Creates a string of json-encoded channels to pass to keybase chat api-listen --filter-channels
+func createFiltersString(channels []Channel) string {
+	if len(channels) == 0 {
+		return ""
+	}
+	jsonBytes, _ := json.Marshal(channels)
+	return string(jsonBytes)
+}
+
+// Run `keybase chat api-listen` to get new messages coming into keybase and send them into the channel
+func getNewMessages(k *Keybase, c chan<- ChatAPI, execOptions []string) {
+	execString := []string{"chat", "api-listen"}
+	if len(execOptions) > 0 {
+		execString = append(execString, execOptions...)
+	}
+	for {
+		execCmd := exec.Command(k.Path, execString...)
+		stdOut, _ := execCmd.StdoutPipe()
+		execCmd.Start()
+		scanner := bufio.NewScanner(stdOut)
+		go func(scanner *bufio.Scanner, c chan<- ChatAPI) {
+			for scanner.Scan() {
+				var jsonData ChatAPI
+				json.Unmarshal([]byte(scanner.Text()), &jsonData)
+				if jsonData.ErrorRaw != nil {
+					var errorListen = string(*jsonData.ErrorRaw)
+					jsonData.ErrorListen = &errorListen
+				}
+				c <- jsonData
+			}
+		}(scanner, c)
+		execCmd.Wait()
+	}
+}
+
+// Run runs `keybase chat api-listen`, and passes incoming messages to the message handler func
+func (k *Keybase) Run(handler func(ChatAPI), options ...RunOptions) {
+	var heartbeatFreq int64
+	var channelCapacity = 100
+
+	runOptions := make([]string, 0)
+	if len(options) > 0 {
+		if options[0].Capacity > 0 {
+			channelCapacity = options[0].Capacity
+		}
+		if options[0].Heartbeat > 0 {
+			heartbeatFreq = options[0].Heartbeat
+		}
+		if options[0].Local {
+			runOptions = append(runOptions, "--local")
+		}
+		if options[0].HideExploding {
+			runOptions = append(runOptions, "--hide-exploding")
+		}
+		if options[0].Dev {
+			runOptions = append(runOptions, "--dev")
+		}
+		if len(options[0].FilterChannels) > 0 {
+			runOptions = append(runOptions, "--filter-channels")
+			runOptions = append(runOptions, createFiltersString(options[0].FilterChannels))
+
+		}
+		if options[0].FilterChannel.Name != "" {
+			runOptions = append(runOptions, "--filter-channel")
+			runOptions = append(runOptions, createFilterString(options[0].FilterChannel))
+		}
+	}
+	c := make(chan ChatAPI, channelCapacity)
+	defer close(c)
+	if heartbeatFreq > 0 {
+		go heartbeat(c, time.Duration(heartbeatFreq)*time.Minute)
+	}
+	go getNewMessages(k, c, runOptions)
+	for {
+		go handler(<-c)
+	}
+}
+
+// heartbeat sends a message through the channel with a message type of `heartbeat`
+func heartbeat(c chan<- ChatAPI, freq time.Duration) {
+	m := ChatAPI{
+		Type: "heartbeat",
+	}
+	count := 0
+	for {
+		time.Sleep(freq)
+		m.Msg.ID = count
+		c <- m
+		count++
+	}
+}
+
+// chatAPIOut sends JSON requests to the chat API and returns its response.
+func chatAPIOut(k *Keybase, c ChatAPI) (ChatAPI, error) {
+	jsonBytes, _ := json.Marshal(c)
+
+	cmdOut, err := k.Exec("chat", "api", "-m", string(jsonBytes))
+	if err != nil {
+		return ChatAPI{}, err
+	}
+
+	var r ChatAPI
+	if err := json.Unmarshal(cmdOut, &r); err != nil {
+		return ChatAPI{}, err
+	}
+	if r.ErrorRaw != nil {
+		var errorRead Error
+		json.Unmarshal([]byte(*r.ErrorRaw), &errorRead)
+		r.ErrorRead = &errorRead
+		return r, errors.New(r.ErrorRead.Message)
+	}
+
+	return r, nil
+}
+
+// Send sends a chat message
+func (c Chat) Send(message ...string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Message: &mesg{},
+	}
+
+	m.Method = "send"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Message.Body = strings.Join(message, " ")
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// SendEphemeral sends an exploding chat message, with specified duration
+func (c Chat) SendEphemeral(duration time.Duration, message ...string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Message: &mesg{},
+	}
+	m.Params.Options.ExplodingLifetime.Duration = duration
+	m.Method = "send"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Message.Body = strings.Join(message, " ")
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Reply sends a reply to a chat message
+func (c Chat) Reply(replyTo int, message ...string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Message: &mesg{},
+	}
+
+	m.Method = "send"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.ReplyTo = replyTo
+	m.Params.Options.Message.Body = strings.Join(message, " ")
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Edit edits a previously sent chat message
+func (c Chat) Edit(messageID int, message ...string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Message: &mesg{},
+	}
+	m.Method = "edit"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Message.Body = strings.Join(message, " ")
+	m.Params.Options.MessageID = messageID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// React sends a reaction to a message.
+func (c Chat) React(messageID int, reaction string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Message: &mesg{},
+	}
+	m.Method = "reaction"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Message.Body = reaction
+	m.Params.Options.MessageID = messageID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Delete deletes a chat message
+func (c Chat) Delete(messageID int) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "delete"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.MessageID = messageID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// ChatList returns a list of all conversations.
+// You can pass a Channel to use as a filter here, but you'll probably want to
+// leave the TopicName empty.
+func (k *Keybase) ChatList(opts ...Channel) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+
+	if len(opts) > 0 {
+		m.Params.Options.Name = opts[0].Name
+		m.Params.Options.Public = opts[0].Public
+		m.Params.Options.MembersType = opts[0].MembersType
+		m.Params.Options.TopicType = opts[0].TopicType
+		m.Params.Options.TopicName = opts[0].TopicName
+	}
+	m.Method = "list"
+
+	r, err := chatAPIOut(k, m)
+	return r, err
+}
+
+// ReadMessage fetches the chat message with the specified message id from a conversation.
+func (c Chat) ReadMessage(messageID int) (*ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Pagination: &pagination{},
+	}
+
+	m.Method = "read"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Pagination.Num = 1
+
+	m.Params.Options.Pagination.Previous = getID(uint(messageID - 1))
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return &r, err
+	}
+	r.keybase = *c.keybase
+	return &r, nil
+}
+
+// Read fetches chat messages from a conversation. By default, 10 messages will
+// be fetched at a time. However, if count is passed, then that is the number of
+// messages that will be fetched.
+func (c Chat) Read(count ...int) (*ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Pagination: &pagination{},
+	}
+
+	m.Method = "read"
+	m.Params.Options.Channel = &c.Channel
+	if len(count) == 0 {
+		m.Params.Options.Pagination.Num = 10
+	} else {
+		m.Params.Options.Pagination.Num = count[0]
+	}
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return &r, err
+	}
+	r.keybase = *c.keybase
+	return &r, nil
+}
+
+// Next fetches the next page of chat messages that were fetched with Read. By
+// default, Next will fetch the same amount of messages that were originally
+// fetched with Read. However, if count is passed, then that is the number of
+// messages that will be fetched.
+func (c *ChatAPI) Next(count ...int) (*ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Pagination: &pagination{},
+	}
+
+	m.Method = "read"
+	m.Params.Options.Channel = &c.Result.Messages[0].Msg.Channel
+	if len(count) == 0 {
+		m.Params.Options.Pagination.Num = c.Result.Pagination.Num
+	} else {
+		m.Params.Options.Pagination.Num = count[0]
+	}
+	m.Params.Options.Pagination.Next = c.Result.Pagination.Next
+
+	result, err := chatAPIOut(&c.keybase, m)
+	if err != nil {
+		return &result, err
+	}
+	k := c.keybase
+	*c = result
+	c.keybase = k
+	return c, nil
+}
+
+// Previous fetches the previous page of chat messages that were fetched with Read.
+// By default, Previous will fetch the same amount of messages that were
+// originally fetched with Read. However, if count is passed, then that is the
+// number of messages that will be fetched.
+func (c *ChatAPI) Previous(count ...int) (*ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Params.Options = options{
+		Pagination: &pagination{},
+	}
+
+	m.Method = "read"
+	m.Params.Options.Channel = &c.Result.Messages[0].Msg.Channel
+	if len(count) == 0 {
+		m.Params.Options.Pagination.Num = c.Result.Pagination.Num
+	} else {
+		m.Params.Options.Pagination.Num = count[0]
+	}
+	m.Params.Options.Pagination.Previous = c.Result.Pagination.Previous
+
+	result, err := chatAPIOut(&c.keybase, m)
+	if err != nil {
+		return &result, err
+	}
+	k := c.keybase
+	*c = result
+	c.keybase = k
+	return c, nil
+}
+
+// Upload attaches a file to a conversation
+// The filepath must be an absolute path
+func (c Chat) Upload(title string, filepath string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "attach"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Filename = filepath
+	m.Params.Options.Title = title
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Download downloads a file from a conversation
+func (c Chat) Download(messageID int, filepath string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "download"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.Output = filepath
+	m.Params.Options.MessageID = messageID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// LoadFlip returns the results of a flip
+// If the flip is still in progress, this can be expected to change if called again
+func (c Chat) LoadFlip(messageID int, conversationID string, flipConversationID string, gameID string) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "loadflip"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.MsgID = messageID
+	m.Params.Options.ConversationID = conversationID
+	m.Params.Options.FlipConversationID = flipConversationID
+	m.Params.Options.GameID = gameID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Pin pins a message to a channel
+func (c Chat) Pin(messageID int) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "pin"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.MessageID = messageID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Unpin clears any pinned messages from a channel
+func (c Chat) Unpin() (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "unpin"
+	m.Params.Options.Channel = &c.Channel
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Mark marks a conversation as read up to a specified message
+func (c Chat) Mark(messageID int) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "mark"
+	m.Params.Options.Channel = &c.Channel
+	m.Params.Options.MessageID = messageID
+
+	r, err := chatAPIOut(c.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// ClearCommands clears bot advertisements
+func (k *Keybase) ClearCommands() (ChatAPI, error) {
+	m := ChatAPI{}
+	m.Method = "clearcommands"
+
+	r, err := chatAPIOut(k, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// AdvertiseCommands sets up bot command advertisements
+// This method allows you to set up multiple different types of advertisements at once.
+// Use this method if you have commands whose visibility differs from each other.
+func (k *Keybase) AdvertiseCommands(advertisements []BotAdvertisement) (ChatAPI, error) {
+	m := ChatAPI{
+		Params: &params{},
+	}
+	m.Method = "advertisecommands"
+	m.Params.Options.BotAdvertisements = advertisements
+
+	r, err := chatAPIOut(k, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// AdvertiseCommand sets up bot command advertisements
+// This method allows you to set up one type of advertisement.
+// Use this method if you have commands whose visibility should all be the same.
+func (k *Keybase) AdvertiseCommand(advertisement BotAdvertisement) (ChatAPI, error) {
+	return k.AdvertiseCommands([]BotAdvertisement{
+		advertisement,
+	})
+}

v1/docs.go

@@ -0,0 +1,66 @@
+/*
+The keybase package implements an interface for interacting with the Keybase Chat, Team, and Wallet APIs
+
+I've tried to follow Keybase's JSON API as closely as possible, so if you're stuck on anything, or wondering
+why things are organized in a certain way, it's most likely due to that. It may be helpful to look at the
+Keybase JSON API docs by running some of the following commands in your terminal:
+    // Chat API
+    keybase chat api -h
+
+    // Chat Message Stream
+    keybase chat api-listen -h
+
+    // Team API
+    keybase team api -h
+
+    // Wallet API
+    keybase wallet api -h
+
+The git repo for this code is hosted on Keybase. You can contact me directly (https://keybase.io/dxb),
+or join the mkbot team (https://keybase.io/team/mkbot) if you need assistance, or if you'd like to contribute.
+
+Basic Example
+
+Here's a quick example of a bot that will attach a reaction with the sender's device name to every message sent
+in @mkbot#test1:
+
+    package main
+
+    import (
+    	"fmt"
+
+    	"samhofi.us/x/keybase"
+    )
+
+    var k = keybase.NewKeybase()
+
+    func main() {
+    	channel := keybase.Channel{
+    		Name:        "mkbot",
+    		TopicName:   "test1",
+    		MembersType: keybase.TEAM,
+    	}
+    	opts := keybase.RunOptions{
+    		FilterChannel: channel,
+    	}
+    	fmt.Println("Running...")
+    	k.Run(handler, opts)
+    }
+
+    func handler(m keybase.ChatAPI) {
+	if m.ErrorListen != nil {
+		fmt.Printf("Error: %s\n", *m.ErrorListen)
+		return
+	}
+
+    	msgType := m.Msg.Content.Type
+    	msgID := m.Msg.ID
+    	deviceName := m.Msg.Sender.DeviceName
+
+    	if msgType == "text" {
+    		chat := k.NewChat(m.Msg.Channel)
+    		chat.React(msgID, deviceName)
+    	}
+    }
+*/
+package keybase

v1/docs_test.go

@@ -0,0 +1,20 @@
+package keybase
+
+func ExampleKeybase_AdvertiseCommand() {
+	var k = NewKeybase()
+
+	// Clear out any previously advertised commands
+	k.ClearCommands()
+
+	// Create BotAdvertisement
+	c := BotAdvertisement{
+		Type: "public",
+		BotCommands: []BotCommand{
+			NewBotCommand("help", "Get help using this bot", "!help <command>"),
+			NewBotCommand("hello", "Say hello", "!hello"),
+		},
+	}
+
+	// Send advertisement
+	k.AdvertiseCommand(c)
+}

v1/keybase.go

@@ -0,0 +1,160 @@
+package keybase
+
+import (
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// Possible MemberTypes
+const (
+	TEAM string = "team"
+	USER string = "impteamnative"
+)
+
+// Possible TopicTypes
+const (
+	DEV  string = "dev"
+	CHAT string = "chat"
+)
+
+// NewKeybase returns a new Keybase. Optionally, you can pass a string containing the path to the Keybase executable as the first argument.
+func NewKeybase(path ...string) *Keybase {
+	k := &Keybase{}
+	if len(path) < 1 {
+		k.Path = "keybase"
+	} else {
+		k.Path = path[0]
+	}
+
+	s := k.status()
+	k.Version = k.version()
+	k.LoggedIn = s.LoggedIn
+	if k.LoggedIn {
+		k.Username = s.Username
+		k.Device = s.Device.Name
+	}
+	return k
+}
+
+// NewBotCommand returns a new BotCommand instance
+func NewBotCommand(name, description, usage string, extendedDescription ...BotCommandExtendedDescription) BotCommand {
+	result := BotCommand{
+		Name:        name,
+		Description: description,
+		Usage:       usage,
+	}
+
+	if len(extendedDescription) > 0 {
+		result.ExtendedDescription = &extendedDescription[0]
+	}
+
+	return result
+}
+
+// NewBotCommandExtendedDescription
+func NewBotCommandExtendedDescription(title, desktopBody, mobileBody string) BotCommandExtendedDescription {
+	return BotCommandExtendedDescription{
+		Title:       title,
+		DesktopBody: desktopBody,
+		MobileBody:  mobileBody,
+	}
+}
+
+// Exec executes the given Keybase command
+func (k *Keybase) Exec(command ...string) ([]byte, error) {
+	out, err := exec.Command(k.Path, command...).Output()
+	if err != nil {
+		return []byte{}, err
+	}
+	return out, nil
+}
+
+// NewChat returns a new Chat instance
+func (k *Keybase) NewChat(channel Channel) Chat {
+	return Chat{
+		keybase: k,
+		Channel: channel,
+	}
+}
+
+// NewTeam returns a new Team instance
+func (k *Keybase) NewTeam(name string) Team {
+	return Team{
+		keybase: k,
+		Name:    name,
+	}
+}
+
+// NewKV returns a new KV instance
+func (k *Keybase) NewKV(team string) KV {
+	return KV{
+		keybase: k,
+		Team:    team,
+	}
+}
+
+// NewWallet returns a new Wallet instance
+func (k *Keybase) NewWallet() Wallet {
+	return Wallet{
+		keybase: k,
+	}
+}
+
+// status returns the results of the `keybase status` command, which includes
+// information about the client, and the currently logged-in Keybase user.
+func (k *Keybase) status() status {
+	cmdOut, err := k.Exec("status", "-j")
+	if err != nil {
+		return status{}
+	}
+
+	var s status
+	json.Unmarshal(cmdOut, &s)
+
+	return s
+}
+
+// version returns the version string of the client.
+func (k *Keybase) version() string {
+	cmdOut, err := k.Exec("version", "-S", "-f", "s")
+	if err != nil {
+		return ""
+	}
+
+	return string(cmdOut)
+}
+
+// UserLookup pulls information about users.
+// The following fields are currently returned: basics, profile, proofs_summary, devices -- See https://keybase.io/docs/api/1.0/call/user/lookup for more info.
+func (k *Keybase) UserLookup(users ...string) (UserAPI, error) {
+	var fields = []string{"basics", "profile", "proofs_summary", "devices"}
+
+	cmdOut, err := k.Exec("apicall", "--arg", fmt.Sprintf("usernames=%s", strings.Join(users, ",")), "--arg", fmt.Sprintf("fields=%s", strings.Join(fields, ",")), "user/lookup")
+	if err != nil {
+		return UserAPI{}, err
+	}
+
+	var r UserAPI
+	if err := json.Unmarshal(cmdOut, &r); err != nil {
+		return UserAPI{}, err
+	}
+
+	return r, nil
+}
+
+// UserCard pulls the information that is typically displayed when you open a user's profile.
+func (k *Keybase) UserCard(user string) (UserCardAPI, error) {
+	cmdOut, err := k.Exec("apicall", "--arg", "username="+user, "user/card")
+	if err != nil {
+		return UserCardAPI{}, err
+	}
+
+	var r UserCardAPI
+	if err := json.Unmarshal(cmdOut, &r); err != nil {
+		return UserCardAPI{}, err
+	}
+
+	return r, nil
+}

v1/kvstore.go

@@ -0,0 +1,137 @@
+package keybase
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+// kvAPIOut sends a JSON request to the kvstore API and returns its response.
+func kvAPIOut(k *Keybase, kv KVAPI) (KVAPI, error) {
+	jsonBytes, _ := json.Marshal(kv)
+
+	cmdOut, err := k.Exec("kvstore", "api", "-m", string(jsonBytes))
+	if err != nil {
+		return KVAPI{}, err
+	}
+
+	var r KVAPI
+	if err := json.Unmarshal(cmdOut, &r); err != nil {
+		return KVAPI{}, err
+	}
+
+	if r.Error != nil {
+		return KVAPI{}, errors.New(r.Error.Message)
+	}
+
+	return r, nil
+}
+
+// Namespaces returns all namespaces for a team
+func (kv KV) Namespaces() (KVAPI, error) {
+	m := KVAPI{
+		Params: &kvParams{},
+	}
+	m.Params.Options = kvOptions{
+		Team: kv.Team,
+	}
+
+	m.Method = "list"
+
+	r, err := kvAPIOut(kv.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Keys returns all non-deleted keys for a namespace
+func (kv KV) Keys(namespace string) (KVAPI, error) {
+	m := KVAPI{
+		Params: &kvParams{},
+	}
+	m.Params.Options = kvOptions{
+		Team:      kv.Team,
+		Namespace: namespace,
+	}
+
+	m.Method = "list"
+
+	r, err := kvAPIOut(kv.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Get returns an entry
+func (kv KV) Get(namespace string, key string, revision ...uint) (KVAPI, error) {
+	m := KVAPI{
+		Params: &kvParams{},
+	}
+	m.Params.Options = kvOptions{
+		Team:      kv.Team,
+		Namespace: namespace,
+		EntryKey:  key,
+	}
+
+	if len(revision) > 0 {
+		m.Params.Options.Revision = revision[0]
+	}
+
+	m.Method = "get"
+
+	r, err := kvAPIOut(kv.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Put adds an entry
+func (kv KV) Put(namespace string, key string, value string, revision ...uint) (KVAPI, error) {
+	m := KVAPI{
+		Params: &kvParams{},
+	}
+	m.Params.Options = kvOptions{
+		Team:       kv.Team,
+		Namespace:  namespace,
+		EntryKey:   key,
+		EntryValue: value,
+	}
+
+	if len(revision) > 0 {
+		m.Params.Options.Revision = revision[0]
+	}
+
+	m.Method = "put"
+
+	r, err := kvAPIOut(kv.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+// Delete removes an entry
+func (kv KV) Delete(namespace string, key string, revision ...uint) (KVAPI, error) {
+	m := KVAPI{
+		Params: &kvParams{},
+	}
+	m.Params.Options = kvOptions{
+		Team:      kv.Team,
+		Namespace: namespace,
+		EntryKey:  key,
+	}
+
+	if len(revision) > 0 {
+		m.Params.Options.Revision = revision[0]
+	}
+
+	m.Method = "del"
+
+	r, err := kvAPIOut(kv.keybase, m)
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}

v1/types.go

@@ -0,0 +1,926 @@
+package keybase
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// RunOptions holds a set of options to be passed to Run
+type RunOptions struct {
+	Capacity       int       // Channel capacity for the buffered channel that holds messages. Defaults to 100 if not set
+	Heartbeat      int64     // Send a heartbeat through the channel every X minutes (0 = off)
+	Local          bool      // Subscribe to local messages
+	HideExploding  bool      // Ignore exploding messages
+	Dev            bool      // Subscribe to dev channel messages
+	Wallet         bool      // Subscribe to wallet events
+	FilterChannel  Channel   // Only subscribe to messages from specified channel
+	FilterChannels []Channel // Only subscribe to messages from specified channels
+}
+
+// ChatAPI holds information about a message received by the `keybase chat api-listen` command
+type ChatAPI struct {
+	Type         string           `json:"type,omitempty"`
+	Source       string           `json:"source,omitempty"`
+	Msg          *msg             `json:"msg,omitempty"`
+	Method       string           `json:"method,omitempty"`
+	Params       *params          `json:"params,omitempty"`
+	Message      string           `json:"message,omitempty"`
+	ID           int              `json:"id,omitempty"`
+	Ratelimits   []rateLimits     `json:"ratelimits,omitempty"`
+	Notification *notification    `json:"notification,omitempty"`
+	Result       *result          `json:"result,omitempty"`
+	Pagination   *pagination      `json:"pagination,omitempty"`
+	ErrorRaw     *json.RawMessage `json:"error,omitempty"` // Raw JSON string containing any errors returned
+	ErrorRead    *Error           `json:"-"`               // Errors returned by any outgoing chat functions such as Read(), Edit(), etc
+	ErrorListen  *string          `json:"-"`               // Errors returned by the api-listen command (used in the Run() function)
+	keybase      Keybase          // Some methods will need this, so I'm passing it but keeping it unexported
+}
+
+type sender struct {
+	UID        string `json:"uid"`
+	Username   string `json:"username"`
+	DeviceID   string `json:"device_id"`
+	DeviceName string `json:"device_name"`
+}
+
+type addedtoteam struct {
+	Team    string   `json:"team"`
+	Adder   string   `json:"adder"`
+	Addee   string   `json:"addee"`
+	Owners  []string `json:"owners"`
+	Admins  []string `json:"admins"`
+	Writers []string `json:"writers"`
+	Readers []string `json:"readers"`
+}
+
+type bulkaddtoconv struct {
+	Usernames []string `json:"usernames"`
+}
+
+type commits struct {
+	CommitHash  string `json:"commitHash"`
+	Message     string `json:"message"`
+	AuthorName  string `json:"authorName"`
+	AuthorEmail string `json:"authorEmail"`
+	Ctime       int    `json:"ctime"`
+}
+
+type refs struct {
+	RefName              string    `json:"refName"`
+	Commits              []commits `json:"commits"`
+	MoreCommitsAvailable bool      `json:"moreCommitsAvailable"`
+	IsDelete             bool      `json:"isDelete"`
+}
+
+type gitpush struct {
+	Team             string `json:"team"`
+	Pusher           string `json:"pusher"`
+	RepoName         string `json:"repoName"`
+	RepoID           string `json:"repoID"`
+	Refs             []refs `json:"refs"`
+	PushType         int    `json:"pushType"`
+	PreviousRepoName string `json:"previousRepoName"`
+}
+
+type system struct {
+	SystemType    int           `json:"systemType"`
+	Addedtoteam   addedtoteam   `json:"addedtoteam"`
+	Bulkaddtoconv bulkaddtoconv `json:"bulkaddtoconv"`
+	Gitpush       gitpush       `json:"gitpush"`
+}
+
+type paymentsResult struct {
+	ResultTyp int    `json:"resultTyp"`
+	Sent      string `json:"sent"`
+}
+
+type payments struct {
+	Username    string         `json:"username"`
+	PaymentText string         `json:"paymentText"`
+	Result      paymentsResult `json:"result"`
+}
+
+type userMentions struct {
+	Text string `json:"text"`
+	UID  string `json:"uid"`
+}
+
+type teamMentions struct {
+	Name    string `json:"name"`
+	Channel string `json:"channel"`
+}
+
+type reaction struct {
+	M int    `json:"m"`
+	B string `json:"b"`
+}
+
+type delete struct {
+	MessageIDs []int `json:"messageIDs"`
+}
+
+type edit struct {
+	MessageID    int            `json:"messageID"`
+	Body         string         `json:"body"`
+	Payments     []payments     `json:"payments"`
+	UserMentions []userMentions `json:"userMentions"`
+	TeamMentions []teamMentions `json:"teamMentions"`
+}
+
+type text struct {
+	Body         string         `json:"body"`
+	Payments     []payments     `json:"payments"`
+	ReplyTo      int            `json:"replyTo"`
+	ReplyToUID   string         `json:"replyToUID"`
+	UserMentions []userMentions `json:"userMentions"`
+	TeamMentions []teamMentions `json:"teamMentions"`
+}
+
+type flip struct {
+	Text         string      `json:"text"`
+	GameID       string      `json:"game_id"`
+	FlipConvID   string      `json:"flip_conv_id"`
+	UserMentions interface{} `json:"user_mentions"`
+	TeamMentions interface{} `json:"team_mentions"`
+}
+
+type image struct {
+	Width  int `json:"width"`
+	Height int `json:"height"`
+}
+
+type metadata struct {
+	AssetType int   `json:"assetType"`
+	Image     image `json:"image"`
+}
+
+type preview struct {
+	Filename  string   `json:"filename"`
+	Region    string   `json:"region"`
+	Endpoint  string   `json:"endpoint"`
+	Bucket    string   `json:"bucket"`
+	Path      string   `json:"path"`
+	Size      int      `json:"size"`
+	MimeType  string   `json:"mimeType"`
+	EncHash   string   `json:"encHash"`
+	Key       string   `json:"key"`
+	VerifyKey string   `json:"verifyKey"`
+	Title     string   `json:"title"`
+	Nonce     string   `json:"nonce"`
+	Metadata  metadata `json:"metadata"`
+	Tag       int      `json:"tag"`
+}
+
+type previews struct {
+	Filename  string   `json:"filename"`
+	Region    string   `json:"region"`
+	Endpoint  string   `json:"endpoint"`
+	Bucket    string   `json:"bucket"`
+	Path      string   `json:"path"`
+	Size      int      `json:"size"`
+	MimeType  string   `json:"mimeType"`
+	EncHash   string   `json:"encHash"`
+	Key       string   `json:"key"`
+	VerifyKey string   `json:"verifyKey"`
+	Title     string   `json:"title"`
+	Nonce     string   `json:"nonce"`
+	Metadata  metadata `json:"metadata"`
+	Tag       int      `json:"tag"`
+}
+
+type object struct {
+	Filename  string   `json:"filename"`
+	Region    string   `json:"region"`
+	Endpoint  string   `json:"endpoint"`
+	Bucket    string   `json:"bucket"`
+	Path      string   `json:"path"`
+	Size      int      `json:"size"`
+	MimeType  string   `json:"mimeType"`
+	EncHash   string   `json:"encHash"`
+	Key       string   `json:"key"`
+	VerifyKey string   `json:"verifyKey"`
+	Title     string   `json:"title"`
+	Nonce     string   `json:"nonce"`
+	Metadata  metadata `json:"metadata"`
+	Tag       int      `json:"tag"`
+}
+
+type attachment struct {
+	Object   object     `json:"object"`
+	Preview  preview    `json:"preview"`
+	Previews []previews `json:"previews"`
+	Metadata metadata   `json:"metadata"`
+	Uploaded bool       `json:"uploaded"`
+}
+
+type content struct {
+	Type           string         `json:"type"`
+	Attachment     attachment     `json:"attachment"`
+	Delete         delete         `json:"delete"`
+	Edit           edit           `json:"edit"`
+	Reaction       reaction       `json:"reaction"`
+	System         system         `json:"system"`
+	Text           text           `json:"text"`
+	SendPayment    SendPayment    `json:"send_payment"`
+	RequestPayment RequestPayment `json:"request_payment"`
+	Flip           flip           `json:"flip"`
+}
+
+type msg struct {
+	ID                 int      `json:"id"`
+	ConversationID     string   `json:"conversation_id"`
+	Channel            Channel  `json:"channel"`
+	Sender             sender   `json:"sender"`
+	SentAt             int      `json:"sent_at"`
+	SentAtMs           int64    `json:"sent_at_ms"`
+	Content            content  `json:"content"`
+	Unread             bool     `json:"unread"`
+	AtMentionUsernames []string `json:"at_mention_usernames"`
+	IsEphemeral        bool     `json:"is_ephemeral"`
+	Etime              int64    `json:"etime"`
+	HasPairwiseMacs    bool     `json:"has_pairwise_macs"`
+	ChannelMention     string   `json:"channel_mention"`
+}
+
+type summary struct {
+	ID                  string      `json:"id"`
+	TxID                string      `json:"txID"`
+	Time                int64       `json:"time"`
+	StatusSimplified    int         `json:"statusSimplified"`
+	StatusDescription   string      `json:"statusDescription"`
+	StatusDetail        string      `json:"statusDetail"`
+	ShowCancel          bool        `json:"showCancel"`
+	AmountDescription   string      `json:"amountDescription"`
+	Delta               int         `json:"delta"`
+	Worth               string      `json:"worth"`
+	WorthAtSendTime     string      `json:"worthAtSendTime"`
+	IssuerDescription   string      `json:"issuerDescription"`
+	FromType            int         `json:"fromType"`
+	ToType              int         `json:"toType"`
+	AssetCode           string      `json:"assetCode"`
+	FromAccountID       string      `json:"fromAccountID"`
+	FromAccountName     string      `json:"fromAccountName"`
+	FromUsername        string      `json:"fromUsername"`
+	ToAccountID         string      `json:"toAccountID"`
+	ToAccountName       string      `json:"toAccountName"`
+	ToUsername          string      `json:"toUsername"`
+	ToAssertion         string      `json:"toAssertion"`
+	OriginalToAssertion string      `json:"originalToAssertion"`
+	Note                string      `json:"note"`
+	NoteErr             string      `json:"noteErr"`
+	SourceAmountMax     string      `json:"sourceAmountMax"`
+	SourceAmountActual  string      `json:"sourceAmountActual"`
+	SourceAsset         sourceAsset `json:"sourceAsset"`
+	SourceConvRate      string      `json:"sourceConvRate"`
+	IsAdvanced          bool        `json:"isAdvanced"`
+	SummaryAdvanced     string      `json:"summaryAdvanced"`
+	Operations          interface{} `json:"operations"`
+	Unread              bool        `json:"unread"`
+	BatchID             string      `json:"batchID"`
+	FromAirdrop         bool        `json:"fromAirdrop"`
+	IsInflation         bool        `json:"isInflation"`
+}
+
+type details struct {
+	PublicNote            string      `json:"publicNote"`
+	PublicNoteType        string      `json:"publicNoteType"`
+	ExternalTxURL         string      `json:"externalTxURL"`
+	FeeChargedDescription string      `json:"feeChargedDescription"`
+	PathIntermediate      interface{} `json:"pathIntermediate"`
+}
+
+type notification struct {
+	Summary summary `json:"summary"`
+	Details details `json:"details"`
+}
+
+// Channel holds information about a conversation
+type Channel struct {
+	Name        string `json:"name,omitempty"`
+	Public      bool   `json:"public,omitempty"`
+	MembersType string `json:"members_type,omitempty"`
+	TopicType   string `json:"topic_type,omitempty"`
+	TopicName   string `json:"topic_name,omitempty"`
+}
+
+type BotCommand struct {
+	Name                string                         `json:"name"`
+	Description         string                         `json:"description"`
+	Usage               string                         `json:"usage"`
+	ExtendedDescription *BotCommandExtendedDescription `json:"extended_description,omitempty"`
+}
+
+type BotCommandExtendedDescription struct {
+	Title       string `json:"title"`
+	DesktopBody string `json:"desktop_body"`
+	MobileBody  string `json:"mobile_body"`
+}
+
+type BotAdvertisement struct {
+	Type        string       `json:"type"`                // "public", "teamconvs", "teammembers"
+	TeamName    string       `json:"team_name,omitempty"` // required if Type is not "public"
+	BotCommands []BotCommand `json:"commands"`
+}
+
+type mesg struct {
+	Body string `json:"body"`
+}
+
+type duration struct {
+	time.Duration
+}
+
+func (d *duration) UnmarshalJSON(b []byte) (err error) {
+	d.Duration, err = time.ParseDuration(strings.Trim(string(b), `"`))
+	return
+}
+
+func (d *duration) MarshalJSON() (b []byte, err error) {
+	return []byte(fmt.Sprintf(`"%s"`, d.String())), nil
+}
+
+type options struct {
+	Channel            *Channel           `json:"channel,omitempty"`
+	MessageID          int                `json:"message_id,omitempty"`
+	Message            *mesg              `json:"message,omitempty"`
+	Pagination         *pagination        `json:"pagination,omitempty"`
+	Filename           string             `json:"filename,omitempty,omitempty"`
+	Title              string             `json:"title,omitempty,omitempty"`
+	Output             string             `json:"output,omitempty,omitempty"`
+	ConversationID     string             `json:"conversation_id,omitempty"`
+	FlipConversationID string             `json:"flip_conversation_id,omitempty"`
+	MsgID              int                `json:"msg_id,omitempty"`
+	ReplyTo            int                `json:"reply_to,omitempty"`
+	GameID             string             `json:"game_id,omitempty"`
+	Alias              string             `json:"alias,omitempty"`
+	BotAdvertisements  []BotAdvertisement `json:"advertisements,omitempty"`
+	ExplodingLifetime  duration           `json:"exploding_lifetime,omitempty"`
+
+	Name        string `json:"name,omitempty"`
+	Public      bool   `json:"public,omitempty"`
+	MembersType string `json:"members_type,omitempty"`
+	TopicType   string `json:"topic_type,omitempty"`
+	TopicName   string `json:"topic_name,omitempty"`
+}
+
+type params struct {
+	Options options `json:"options"`
+}
+
+type pagination struct {
+	Next           string `json:"next"`
+	Previous       string `json:"previous"`
+	Num            int    `json:"num"`
+	Last           bool   `json:"last,omitempty"`
+	ForceFirstPage bool   `json:"forceFirstPage,omitempty"`
+}
+
+type participants struct {
+	UID        string `json:"uid"`
+	DeviceID   string `json:"deviceID"`
+	Username   string `json:"username"`
+	DeviceName string `json:"deviceName"`
+	Commitment string `json:"commitment"`
+	Reveal     string `json:"reveal"`
+}
+
+type dupreg struct {
+	User   string `json:"user"`
+	Device string `json:"device"`
+}
+
+type errorInfo struct {
+	Typ    int    `json:"typ"`
+	Dupreg dupreg `json:"dupreg"`
+}
+
+type resultInfo struct {
+	Typ  int  `json:"typ"`
+	Coin bool `json:"coin"`
+}
+
+type flipStatus struct {
+	GameID                  string         `json:"gameID"`
+	Phase                   int            `json:"phase"`
+	ProgressText            string         `json:"progressText"`
+	ResultText              string         `json:"resultText"`
+	CommitmentVisualization string         `json:"commitmentVisualization"`
+	RevealVisualization     string         `json:"revealVisualization"`
+	Participants            []participants `json:"participants"`
+	ResultInfo              *resultInfo    `json:"resultInfo"`
+	ErrorInfo               *errorInfo     `json:"errorInfo"`
+}
+
+type result struct {
+	Messages         []messages     `json:"messages,omitempty"`
+	Pagination       pagination     `json:"pagination"`
+	Message          string         `json:"message"`
+	ID               int            `json:"id"`
+	Ratelimits       []rateLimits   `json:"ratelimits"`
+	Conversations    []conversation `json:"conversations,omitempty"`
+	Offline          bool           `json:"offline,omitempty"`
+	Status           flipStatus     `json:"status,omitempty"`
+	IdentifyFailures interface{}    `json:"identifyFailures,omitempty"`
+}
+
+type messages struct {
+	Msg msg `json:"msg,omitempty"`
+}
+
+type rateLimits struct {
+	Tank     string `json:"tank,omitempty"`
+	Capacity int    `json:"capacity,omitempty"`
+	Reset    int    `json:"reset,omitempty"`
+	Gas      int    `json:"gas,omitempty"`
+}
+
+type conversation struct {
+	ID           string  `json:"id"`
+	Channel      Channel `json:"channel"`
+	Unread       bool    `json:"unread"`
+	ActiveAt     int     `json:"active_at"`
+	ActiveAtMs   int64   `json:"active_at_ms"`
+	MemberStatus string  `json:"member_status"`
+}
+
+type SendPayment struct {
+	PaymentID string `json:"paymentID"`
+}
+
+type RequestPayment struct {
+	RequestID string `json:"requestID"`
+	Note      string `json:"note"`
+}
+
+// WalletAPI holds data for sending to API
+type WalletAPI struct {
+	Method string   `json:"method,omitempty"`
+	Params *wParams `json:"params,omitempty"`
+	Result *wResult `json:"result,omitempty"`
+	Error  *Error   `json:"error"`
+}
+
+type wOptions struct {
+	Name      string `json:"name"`
+	Txid      string `json:"txid"`
+	Recipient string `json:"recipient"`
+	Amount    string `json:"amount"`
+	Currency  string `json:"currency"`
+	Message   string `json:"message"`
+}
+
+type wParams struct {
+	Options wOptions `json:"options"`
+}
+
+type asset struct {
+	Type           string `json:"type"`
+	Code           string `json:"code"`
+	Issuer         string `json:"issuer"`
+	VerifiedDomain string `json:"verifiedDomain"`
+	IssuerName     string `json:"issuerName"`
+	Desc           string `json:"desc"`
+	InfoURL        string `json:"infoUrl"`
+}
+
+type sourceAsset struct {
+	Type           string `json:"type"`
+	Code           string `json:"code"`
+	Issuer         string `json:"issuer"`
+	VerifiedDomain string `json:"verifiedDomain"`
+	IssuerName     string `json:"issuerName"`
+	Desc           string `json:"desc"`
+	InfoURL        string `json:"infoUrl"`
+	InfoURLText    string `json:"infoUrlText"`
+}
+
+type balance struct {
+	Asset  asset  `json:"asset"`
+	Amount string `json:"amount"`
+	Limit  string `json:"limit"`
+}
+
+type exchangeRate struct {
+	Currency string `json:"currency"`
+	Rate     string `json:"rate"`
+}
+
+type wResult struct {
+	AccountID          string       `json:"accountID"`
+	IsPrimary          bool         `json:"isPrimary"`
+	Name               string       `json:"name"`
+	Balance            []balance    `json:"balance"`
+	ExchangeRate       exchangeRate `json:"exchangeRate"`
+	AccountMode        int          `json:"accountMode"`
+	TxID               string       `json:"txID"`
+	Time               int64        `json:"time"`
+	Status             string       `json:"status"`
+	StatusDetail       string       `json:"statusDetail"`
+	Amount             string       `json:"amount"`
+	Asset              asset        `json:"asset"`
+	DisplayAmount      string       `json:"displayAmount"`
+	DisplayCurrency    string       `json:"displayCurrency"`
+	SourceAmountMax    string       `json:"sourceAmountMax"`
+	SourceAmountActual string       `json:"sourceAmountActual"`
+	SourceAsset        sourceAsset  `json:"sourceAsset"`
+	FromStellar        string       `json:"fromStellar"`
+	ToStellar          string       `json:"toStellar"`
+	FromUsername       string       `json:"fromUsername"`
+	ToUsername         string       `json:"toUsername"`
+	Note               string       `json:"note"`
+	NoteErr            string       `json:"noteErr"`
+	Unread             bool         `json:"unread"`
+	Username           string       `json:"username"`
+}
+
+// TeamAPI holds information sent and received to/from the team api
+type TeamAPI struct {
+	Method string   `json:"method,omitempty"`
+	Params *tParams `json:"params,omitempty"`
+	Result *tResult `json:"result,omitempty"`
+	Error  *Error   `json:"error"`
+}
+
+type emails struct {
+	Email string `json:"email"`
+	Role  string `json:"role"`
+}
+
+type usernames struct {
+	Username string `json:"username"`
+	Role     string `json:"role"`
+}
+
+type user struct {
+	UID      string `json:"uid"`
+	Username string `json:"username"`
+}
+
+type uv struct {
+	UID         string `json:"uid"`
+	EldestSeqno int    `json:"eldestSeqno"`
+}
+
+type member struct {
+	Uv       uv     `json:"uv"`
+	Username string `json:"username"`
+	FullName string `json:"fullName"`
+	NeedsPUK bool   `json:"needsPUK"`
+	Status   int    `json:"status"`
+}
+
+type members struct {
+	Owners  []member `json:"owners"`
+	Admins  []member `json:"admins"`
+	Writers []member `json:"writers"`
+	Readers []member `json:"readers"`
+}
+
+type annotatedActiveInvites struct {
+}
+
+type settings struct {
+	Open   bool `json:"open"`
+	JoinAs int  `json:"joinAs"`
+}
+
+type showcase struct {
+	IsShowcased       bool `json:"is_showcased"`
+	AnyMemberShowcase bool `json:"any_member_showcase"`
+}
+
+type tOptions struct {
+	Team      string      `json:"team"`
+	Emails    []emails    `json:"emails"`
+	Usernames []usernames `json:"usernames"`
+	Username  string      `json:"username"`
+}
+
+type tParams struct {
+	Options tOptions `json:"options"`
+}
+
+type Error struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+type tResult struct {
+	ChatSent               bool                   `json:"chatSent"`
+	CreatorAdded           bool                   `json:"creatorAdded"`
+	Invited                bool                   `json:"invited"`
+	User                   user                   `json:"user"`
+	EmailSent              bool                   `json:"emailSent"`
+	ChatSending            bool                   `json:"chatSending"`
+	Members                members                `json:"members"`
+	KeyGeneration          int                    `json:"keyGeneration"`
+	AnnotatedActiveInvites annotatedActiveInvites `json:"annotatedActiveInvites"`
+	Settings               settings               `json:"settings"`
+	Showcase               showcase               `json:"showcase"`
+	Teams                  []teamInfo             `json:"teams"`
+}
+
+type implicit struct {
+	Role     int    `json:"role"`
+	Ancestor string `json:"ancestor"`
+}
+
+type teamInfo struct {
+	UID                     string   `json:"uid"`
+	TeamID                  string   `json:"team_id"`
+	Username                string   `json:"username"`
+	FullName                string   `json:"full_name"`
+	FqName                  string   `json:"fq_name"`
+	IsImplicitTeam          bool     `json:"is_implicit_team"`
+	ImplicitTeamDisplayName string   `json:"implicit_team_display_name"`
+	IsOpenTeam              bool     `json:"is_open_team"`
+	Role                    int      `json:"role"`
+	NeedsPUK                bool     `json:"needsPUK"`
+	MemberCount             int      `json:"member_count"`
+	MemberEldestSeqno       int      `json:"member_eldest_seqno"`
+	AllowProfilePromote     bool     `json:"allow_profile_promote"`
+	IsMemberShowcased       bool     `json:"is_member_showcased"`
+	Status                  int      `json:"status"`
+	Implicit                implicit `json:"implicit,omitempty"`
+}
+
+// KVAPI holds information sent and received to/from the kvstore api
+type KVAPI struct {
+	Method  string    `json:"method,omitempty"`
+	Params  *kvParams `json:"params,omitempty"`
+	Result  *kvResult `json:"result,omitempty"`
+	Error   *Error    `json:"error"`
+	keybase Keybase
+}
+
+type kvOptions struct {
+	Team       string `json:"team,omitempty"`
+	Namespace  string `json:"namespace,omitempty"`
+	EntryKey   string `json:"entryKey,omitempty"`
+	Revision   uint   `json:"revision,omitempty"`
+	EntryValue string `json:"entryValue,omitempty"`
+}
+
+type kvParams struct {
+	Options kvOptions `json:"options,omitempty"`
+}
+
+type entryKey struct {
+	EntryKey string `json:"entryKey"`
+	Revision uint   `json:"revision"`
+}
+
+type kvResult struct {
+	TeamName   string     `json:"teamName"`
+	Namespaces []string   `json:"namespaces"`
+	EntryKeys  []entryKey `json:"entryKeys"`
+	EntryKey   string     `json:"entryKey"`
+	EntryValue string     `json:"entryValue"`
+	Revision   uint       `json:"revision"`
+}
+
+// UserAPI holds information received from the user/lookup api
+type UserAPI struct {
+	Status uStatus `json:"status"`
+	Them   []them  `json:"them"`
+}
+
+type uStatus struct {
+	Code int    `json:"code"`
+	Name string `json:"name"`
+}
+
+type basics struct {
+	Ctime                int    `json:"ctime"`
+	EldestSeqno          int    `json:"eldest_seqno"`
+	IDVersion            int    `json:"id_version"`
+	LastIDChange         int    `json:"last_id_change"`
+	Mtime                int    `json:"mtime"`
+	PassphraseGeneration int    `json:"passphrase_generation"`
+	RandomPw             bool   `json:"random_pw"`
+	Salt                 string `json:"salt"`
+	Status               int    `json:"status"`
+	TrackVersion         int    `json:"track_version"`
+	Username             string `json:"username"`
+	UsernameCased        string `json:"username_cased"`
+}
+
+type profile struct {
+	Bio      string `json:"bio"`
+	FullName string `json:"full_name"`
+	Location string `json:"location"`
+	Mtime    int    `json:"mtime"`
+}
+
+type proof struct {
+	HumanURL          string `json:"human_url"`
+	Nametag           string `json:"nametag"`
+	PresentationGroup string `json:"presentation_group"`
+	PresentationTag   string `json:"presentation_tag"`
+	ProofID           string `json:"proof_id"`
+	ProofType         string `json:"proof_type"`
+	ProofURL          string `json:"proof_url"`
+	ServiceURL        string `json:"service_url"`
+	SigID             string `json:"sig_id"`
+	State             int    `json:"state"`
+}
+
+type proofsSummary struct {
+	All    []proof `json:"all"`
+	HasWeb bool    `json:"has_web"`
+}
+
+type key struct {
+	KeyRole int    `json:"key_role"`
+	Kid     string `json:"kid"`
+	SigID   string `json:"sig_id"`
+}
+
+type uDevice struct {
+	Ctime  int    `json:"ctime"`
+	Keys   []key  `json:"keys"`
+	Mtime  int    `json:"mtime"`
+	Name   string `json:"name"`
+	Status int    `json:"status"`
+	Type   string `json:"type"`
+}
+
+type them struct {
+	Basics        basics             `json:"basics,omitempty"`
+	ID            string             `json:"id"`
+	Profile       profile            `json:"profile,omitempty"`
+	ProofsSummary proofsSummary      `json:"proofs_summary"`
+	Devices       map[string]uDevice `json:"devices,omitempty"`
+}
+
+// UserCardAPI holds information received from the user/card api
+type UserCardAPI struct {
+	AirdropRegistered bool           `json:"airdrop_registered"`
+	Blocked           bool           `json:"blocked"`
+	FollowSummary     followSummary  `json:"follow_summary"`
+	Profile           cardProfile    `json:"profile"`
+	Status            uStatus        `json:"status"`
+	TeamShowcase      []teamShowcase `json:"team_showcase"`
+	TheyFollowYou     bool           `json:"they_follow_you"`
+	UserBlocks        userBlocks     `json:"user_blocks"`
+	YouFollowThem     bool           `json:"you_follow_them"`
+}
+
+type followSummary struct {
+	Followers int `json:"followers"`
+	Following int `json:"following"`
+}
+
+type cardProfile struct {
+	Bio                    string    `json:"bio"`
+	Comment                string    `json:"comment"`
+	CrimeAll               int       `json:"crime_all"`
+	CrimeChat              int       `json:"crime_chat"`
+	CrimeFollow            int       `json:"crime_follow"`
+	CrimeIllegal           int       `json:"crime_illegal"`
+	CrimeLegacyAll         int       `json:"crime_legacy_all"`
+	CrimeLegacyPorn        int       `json:"crime_legacy_porn"`
+	CrimeLegacyStellar     int       `json:"crime_legacy_stellar"`
+	CrimePorn              int       `json:"crime_porn"`
+	CrimeSmurfing          int       `json:"crime_smurfing"`
+	CrimeSpacedrop         int       `json:"crime_spacedrop"`
+	CrimeStellarDust       int       `json:"crime_stellar_dust"`
+	CrimeStellarPaymentReq int       `json:"crime_stellar_payment_req"`
+	CrimeTeam              int       `json:"crime_team"`
+	Ctime                  time.Time `json:"ctime"`
+	FullName               string    `json:"full_name"`
+	IsAdmin                int       `json:"is_admin"`
+	Location               string    `json:"location"`
+	Mtime                  time.Time `json:"mtime"`
+	Reporter               string    `json:"reporter"`
+	Status                 int       `json:"status"`
+	Twitter                string    `json:"twitter"`
+	UID                    string    `json:"uid"`
+	Website                string    `json:"website"`
+}
+
+type teamShowcase struct {
+	Description     string   `json:"description"`
+	FqName          string   `json:"fq_name"`
+	NumMembers      int      `json:"num_members"`
+	Open            bool     `json:"open"`
+	PublicAdmins    []string `json:"public_admins"`
+	Role            int      `json:"role"`
+	TeamID          string   `json:"team_id"`
+	TeamIsShowcased bool     `json:"team_is_showcased"`
+}
+
+type userBlocks struct {
+	Chat   bool      `json:"chat"`
+	Ctime  time.Time `json:"ctime"`
+	Follow bool      `json:"follow"`
+	Mtime  time.Time `json:"mtime"`
+}
+
+// Keybase holds basic information about the local Keybase executable
+type Keybase struct {
+	Path     string
+	Username string
+	LoggedIn bool
+	Version  string
+	Device   string
+}
+
+// Chat holds basic information about a specific conversation
+type Chat struct {
+	keybase *Keybase
+	Channel Channel
+}
+
+type chat interface {
+	Delete(messageID int) (ChatAPI, error)
+	Edit(messageID int, message ...string) (ChatAPI, error)
+	React(messageID int, reaction string) (ChatAPI, error)
+	Send(message ...string) (ChatAPI, error)
+	Reply(replyTo int, message ...string) (ChatAPI, error)
+	Upload(title string, filepath string) (ChatAPI, error)
+	Download(messageID int, filepath string) (ChatAPI, error)
+	LoadFlip(messageID int, conversationID string, flipConversationID string, gameID string) (ChatAPI, error)
+	Pin(messageID int) (ChatAPI, error)
+	Unpin() (ChatAPI, error)
+	Mark(messageID int) (ChatAPI, error)
+}
+
+type chatAPI interface {
+	Next(count ...int) (*ChatAPI, error)
+	Previous(count ...int) (*ChatAPI, error)
+}
+
+// Team holds basic information about a team
+type Team struct {
+	keybase *Keybase
+	Name    string
+}
+
+type team interface {
+	AddAdmins(users ...string) (TeamAPI, error)
+	AddOwners(users ...string) (TeamAPI, error)
+	AddReaders(users ...string) (TeamAPI, error)
+	AddUser(user, role string) (TeamAPI, error)
+	AddWriters(users ...string) (TeamAPI, error)
+	CreateSubteam(name string) (TeamAPI, error)
+	MemberList() (TeamAPI, error)
+}
+
+// Wallet holds basic information about a wallet
+type Wallet struct {
+	keybase *Keybase
+}
+
+type wallet interface {
+	CancelRequest(requestID string) error
+	RequestPayment(user string, amount float64, memo ...string)
+	Send(recipient string, amount string, currency string, message ...string) (WalletAPI, error)
+	SendXLM(recipient string, amount string, message ...string) (WalletAPI, error)
+	StellarAddress(user string) (string, error)
+	TxDetail(txid string) (WalletAPI, error)
+}
+
+// KV holds basic information about a KVStore
+type KV struct {
+	keybase *Keybase
+	Team    string
+}
+
+type kvInterface interface {
+	Namespaces() (KVAPI, error)
+	Keys(namespace string) (KVAPI, error)
+	Get(namespace string, key string) (KVAPI, error)
+	Put(namespace string, key string, value string) (KVAPI, error)
+	Delete(namespace string, key string) (KVAPI, error)
+}
+
+type keybase interface {
+	AdvertiseCommand(advertisement BotAdvertisement) (ChatAPI, error)
+	AdvertiseCommands(advertisements []BotAdvertisement) (ChatAPI, error)
+	ChatList(opts ...Channel) (ChatAPI, error)
+	ClearCommands() (ChatAPI, error)
+	CreateTeam(name string) (TeamAPI, error)
+	NewChat(channel Channel) Chat
+	NewTeam(name string) Team
+	NewKV(team string) KV
+	NewWallet() Wallet
+	Run(handler func(ChatAPI), options ...RunOptions)
+	status() status
+	version() string
+	UserLookup(users ...string) (UserAPI, error)
+	ListUserMemberships(user string) (TeamAPI, error)
+	UserCard(user string) (UserCardAPI, error)
+}
+
+type status struct {
+	Username string `json:"Username"`
+	LoggedIn bool   `json:"LoggedIn"`
+	Device   device `json:"Device"`
+}
+
+type device struct {
+	Name string `json:"name"`
+}

v2/chat.go

@@ -5,12 +5,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os/exec"
 	"time"
 
-	"samhofi.us/x/keybase/types/chat1"
+	"samhofi.us/x/keybase/v2/types/chat1"
-	"samhofi.us/x/keybase/types/keybase1"
+	"samhofi.us/x/keybase/v2/types/stellar1"
-	"samhofi.us/x/keybase/types/stellar1"
 )
 
 // Creates a string of a json-encoded channel to pass to keybase chat api-listen --filter-channel
@@ -38,7 +36,15 @@ func getNewMessages(k *Keybase, subs *subscriptionChannels, execOptions []string
 		execString = append(execString, execOptions...)
 	}
 	for {
-		execCmd := exec.Command(k.Path, execString...)
+		cmd := make([]string, 0)
+
+		if k.HomePath != "" {
+			cmd = append(cmd, "--home", k.HomePath)
+		}
+
+		cmd = append(cmd, execString...)
+
+		execCmd := execCommand(k.ExePath, cmd...)
 		stdOut, _ := execCmd.StdoutPipe()
 		execCmd.Start()
 		scanner := bufio.NewScanner(stdOut)
@@ -701,9 +707,9 @@ func (k *Keybase) ClearCommands() error {
 }
 
 // ListMembers returns member information for a channel or conversation
-func (k *Keybase) ListMembers(options ListMembersOptions) (keybase1.TeamDetails, error) {
+func (k *Keybase) ListMembers(options ListMembersOptions) (chat1.ChatMembersDetails, error) {
 	type res struct {
-		Result keybase1.TeamDetails `json:"result"`
+		Result chat1.ChatMembersDetails `json:"result"`
 		Error  *Error                   `json:"error,omitempty"`
 	}
 
@@ -731,7 +737,7 @@ func (k *Keybase) ListMembers(options ListMembersOptions) (keybase1.TeamDetails,
 }
 
 // ListMembersOfChannel returns member information for a channel
-func (k *Keybase) ListMembersOfChannel(channel chat1.ChatChannel) (keybase1.TeamDetails, error) {
+func (k *Keybase) ListMembersOfChannel(channel chat1.ChatChannel) (chat1.ChatMembersDetails, error) {
 	opts := ListMembersOptions{
 		Channel: channel,
 	}
@@ -739,9 +745,43 @@ func (k *Keybase) ListMembersOfChannel(channel chat1.ChatChannel) (keybase1.Team
 }
 
 // ListMembersOfConversation returns member information for a conversation
-func (k *Keybase) ListMembersOfConversation(convID chat1.ConvIDStr) (keybase1.TeamDetails, error) {
+func (k *Keybase) ListMembersOfConversation(convID chat1.ConvIDStr) (chat1.ChatMembersDetails, error) {
 	opts := ListMembersOptions{
 		ConversationID: convID,
 	}
 	return k.ListMembers(opts)
 }
+
+// ListConvsOnName returns a list of all conversations for a chat1.ChatChannel
+func (k *Keybase) ListConvsOnName(channel chat1.ChatChannel) (*[]chat1.ConvSummary, error) {
+	type result struct {
+		Conversations []chat1.ConvSummary `json:"conversations"`
+	}
+
+	type res struct {
+		Result result `json:"result"`
+		Error  *Error `json:"error,omitempty"`
+	}
+
+	var r res
+
+	arg := newListConvsOnNameArg(channel)
+
+	jsonBytes, _ := json.Marshal(arg)
+
+	cmdOut, err := k.Exec("chat", "api", "-m", string(jsonBytes))
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(cmdOut, &r)
+	if err != nil {
+		return nil, err
+	}
+
+	if r.Error != nil {
+		return nil, fmt.Errorf("%v", r.Error.Message)
+	}
+
+	return &r.Result.Conversations, nil
+}

v2/chat_test.go

@@ -0,0 +1,135 @@
+package keybase
+
+import (
+	"os/exec"
+	"testing"
+
+	"samhofi.us/x/keybase/v2/types/chat1"
+)
+
+func TestListConvsOnName(t *testing.T) {
+	execCommand = createFakeExecCommand("listconvsonname")
+	defer func() { execCommand = exec.Command }()
+
+	channel := chat1.ChatChannel{
+		Name:        "mkbot",
+		MembersType: TEAM,
+	}
+	k := New()
+	res, err := k.ListConvsOnName(channel)
+	if err != nil {
+		t.Errorf("Expected nil error, got %#v", err)
+	}
+
+	channelcount := 10
+	if len(*res) != channelcount {
+		t.Errorf("Expected %d channels, got %d channels", channelcount, len(*res))
+	}
+}
+
+func TestSendMessageByChannel(t *testing.T) {
+	execCommand = createFakeExecCommand("send")
+	defer func() { execCommand = exec.Command }()
+
+	channel := chat1.ChatChannel{
+		Name:        "user1,user2",
+		MembersType: USER,
+	}
+	k := New()
+	res, err := k.SendMessageByChannel(channel, "Hello!")
+	if err != nil {
+		t.Errorf("Expected nil error, got %#v", err)
+	}
+
+	if expected := "message sent"; res.Message != expected {
+		t.Errorf(`res.Message: expected "%s", got "%v"`, expected, res.Message)
+	}
+
+	if expected := uint(894); uint(*res.MessageID) != expected {
+		t.Errorf(`res.MessageID: expected %d, got %d`, expected, uint(*res.MessageID))
+	}
+}
+
+func TestSendMessageByConvID(t *testing.T) {
+	execCommand = createFakeExecCommand("send")
+	defer func() { execCommand = exec.Command }()
+
+	k := New()
+	res, err := k.SendMessageByConvID(chat1.ConvIDStr("000049d2395435dff0c865c18832d9645eb69fd74a2814ef55310b294092ba6d"), "Hello!")
+	if err != nil {
+		t.Errorf("Expected nil error, got %#v", err)
+	}
+
+	if expected := "message sent"; res.Message != expected {
+		t.Errorf(`res.Message: expected "%s", got "%v"`, expected, res.Message)
+	}
+
+	if expected := uint(894); uint(*res.MessageID) != expected {
+		t.Errorf(`res.MessageID: expected %d, got %d`, expected, uint(*res.MessageID))
+	}
+}
+
+func TestCreateFilterString(t *testing.T) {
+	tables := []struct {
+		channel  chat1.ChatChannel
+		expected string
+	}{
+		{
+			chat1.ChatChannel{},
+			``,
+		},
+		{
+			chat1.ChatChannel{Name: "faketeam", MembersType: TEAM},
+			`{"name":"faketeam","members_type":"team"}`,
+		},
+		{
+			chat1.ChatChannel{Name: "user1,user2", MembersType: USER},
+			`{"name":"user1,user2","members_type":"impteamnative"}`,
+		},
+	}
+
+	for _, table := range tables {
+		if result := createFilterString(table.channel); result != table.expected {
+			t.Errorf(`Expected "%s", got "%s"`, table.expected, result)
+		}
+	}
+}
+
+func TestCreateFiltersString(t *testing.T) {
+	tables := []struct {
+		channel  []chat1.ChatChannel
+		expected string
+	}{
+		{
+			[]chat1.ChatChannel{},
+			``,
+		},
+		{
+			[]chat1.ChatChannel{
+				chat1.ChatChannel{Name: "faketeam1", MembersType: TEAM},
+				chat1.ChatChannel{Name: "faketeam2", MembersType: TEAM},
+			},
+			`[{"name":"faketeam1","members_type":"team"},{"name":"faketeam2","members_type":"team"}]`,
+		},
+		{
+			[]chat1.ChatChannel{
+				chat1.ChatChannel{Name: "user1,user2", MembersType: USER},
+				chat1.ChatChannel{Name: "user3,user4", MembersType: USER},
+			},
+			`[{"name":"user1,user2","members_type":"impteamnative"},{"name":"user3,user4","members_type":"impteamnative"}]`,
+		},
+		{
+			[]chat1.ChatChannel{
+				chat1.ChatChannel{Name: "user1,user2", MembersType: USER},
+				chat1.ChatChannel{Name: "faketeam1", MembersType: TEAM},
+			},
+			`[{"name":"user1,user2","members_type":"impteamnative"},{"name":"faketeam1","members_type":"team"}]`,
+		},
+	}
+
+	for _, table := range tables {
+		if result := createFiltersString(table.channel); result != table.expected {
+			t.Errorf(`Expected "%s", got "%s"`, table.expected, result)
+		}
+	}
+}

v2/docs_test.go

@@ -1,6 +1,6 @@
 package keybase
 
-import "samhofi.us/x/keybase/types/chat1"
+import "samhofi.us/x/keybase/v2/types/chat1"
 
 func ExampleKeybase_AdvertiseCommands() {
 	var k = NewKeybase()

v2/keybase.go

@@ -6,9 +6,12 @@ import (
 	"os/exec"
 	"strings"
 
-	"samhofi.us/x/keybase/types/chat1"
+	"samhofi.us/x/keybase/v2/types/chat1"
 )
 
+// Used for testing
+var execCommand = exec.Command
+
 // Possible MemberTypes
 const (
 	TEAM string = "team"
@@ -21,13 +24,33 @@ const (
 	CHAT string = "chat"
 )
 
+// New returns a new Keybase
+func New(opts ...KeybaseOpt) *Keybase {
+	k := &Keybase{ExePath: "keybase"}
+
+	for _, opt := range opts {
+		opt.apply(k)
+	}
+
+	s := k.status()
+	k.Version = k.version()
+	k.LoggedIn = s.LoggedIn
+	if k.LoggedIn {
+		k.Username = s.Username
+		k.Device = s.Device.Name
+	}
+
+	return k
+}
+
 // NewKeybase returns a new Keybase. Optionally, you can pass a string containing the path to the Keybase executable as the first argument.
+// This is deprecated and will be removed in a future update. Use New() instead.
 func NewKeybase(path ...string) *Keybase {
 	k := &Keybase{}
 	if len(path) < 1 {
-		k.Path = "keybase"
+		k.ExePath = "keybase"
 	} else {
-		k.Path = path[0]
+		k.ExePath = path[0]
 	}
 
 	s := k.status()
@@ -42,7 +65,15 @@ func NewKeybase(path ...string) *Keybase {
 
 // Exec executes the given Keybase command
 func (k *Keybase) Exec(command ...string) ([]byte, error) {
-	out, err := exec.Command(k.Path, command...).Output()
+	cmd := make([]string, 0)
+
+	if k.HomePath != "" {
+		cmd = append(cmd, "--home", k.HomePath)
+	}
+
+	cmd = append(cmd, command...)
+
+	out, err := execCommand(k.ExePath, cmd...).Output()
 	if err != nil {
 		return []byte{}, err
 	}

v2/keybase_test.go

@@ -0,0 +1,68 @@
+package keybase
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"testing"
+)
+
+func createFakeExecCommand(caller string) func(command string, args ...string) *exec.Cmd {
+	return func(command string, args ...string) *exec.Cmd {
+		cs := []string{"-test.run=ExecHelper", "--"}
+		cs = append(cs, args...)
+		cmd := exec.Command(os.Args[0], cs...)
+		cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1", "GO_WANT_HELPER_CALLER=" + caller}
+		return cmd
+	}
+}
+
+func TestNew(t *testing.T) {
+	execCommand = createFakeExecCommand("new")
+	defer func() { execCommand = exec.Command }()
+
+	k := New()
+
+	if expected := "keybase"; k.ExePath != expected {
+		t.Errorf(`k.ExePath: expected "%s", got "%s"`, expected, k.ExePath)
+	}
+	if expected := ""; k.HomePath != expected {
+		t.Errorf(`k.HomePath: expected "%s", got "%s"`, expected, k.HomePath)
+	}
+
+	k = New(
+		SetExePath("/path/to/exepath"),
+		SetHomePath("/path/to/homepath"),
+	)
+
+	if expected := "/path/to/exepath"; k.ExePath != expected {
+		t.Errorf(`k.ExePath: expected "%s", got "%s"`, expected, k.ExePath)
+	}
+	if expected := "/path/to/homepath"; k.HomePath != expected {
+		t.Errorf(`k.HomePath: expected "%s", got "%s"`, expected, k.HomePath)
+	}
+}
+
+func TestExecHelper(t *testing.T) {
+	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
+		return
+	}
+
+	var (
+		listconvsonname = `{"result":{"conversations":[{"id":"0000b9d9be8586029d4876af2192b94d6705603cf6859fc27c746de94befd45c","channel":{"name":"mkbot","members_type":"team","topic_type":"chat"},"is_default_conv":false,"unread":true,"active_at":1589468132,"active_at_ms":1589468132734,"member_status":"active","creator_info":{"ctime":1551848940888,"username":"dxb"}},{"id":"0000d2c4d915aa04c093a25b9496cd885ff510f4eeeacac5a7249f65d82ed0ad","channel":{"name":"mkbot","members_type":"team","topic_type":"chat"},"is_default_conv":false,"unread":false,"active_at":1589633805,"active_at_ms":1589633805970,"member_status":"active","creator_info":{"ctime":1551848919282,"username":"dxb"}},{"id":"0000e967261971be5aae47d1cfd7d77e695d4a2f90e2ee35236ef3472b2884d4","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"gameroom"},"is_default_conv":false,"unread":true,"active_at":1589468113,"active_at_ms":1589468113173,"member_status":"active","creator_info":{"ctime":1566244683161,"username":"dxb"}},{"id":"0000d5ae3da566307f6c9906881e5bd08dc9a0bf8c341b5769240026e367c478","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"general"},"is_default_conv":true,"unread":false,"active_at":1589348381,"active_at_ms":1589348381358,"member_status":"active","creator_info":{"ctime":1551840458201,"username":"dxb"}},{"id":"0000d7cf1e6f51d75f9a354c2cb7c3bd30415f184bbb9eba0c57aa50827b7663","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"test1"},"is_default_conv":false,"unread":true,"active_at":1589468203,"active_at_ms":1589468203686,"member_status":"active","creator_info":{"ctime":1551849049656,"username":"dxb"}},{"id":"0000d0cf70804671490e7f8f21c207a1ac6a8bc2ee05db804fb4531ab6c06f05","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"test2"},"is_default_conv":false,"unread":true,"active_at":1589468118,"active_at_ms":1589468118254,"member_status":"active","creator_info":{"ctime":1551849050007,"username":"dxb"}},{"id":"000044e620fef1e84b623350faff06ebef7a0cd7e403ba81a1b35d311976b9f6","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"test3"},"is_default_conv":false,"unread":true,"active_at":1589468117,"active_at_ms":1589468117094,"member_status":"active","creator_info":{"ctime":1551849050351,"username":"dxb"}},{"id":"0000a8dd5969f6bb414562278a5abf8f3bd80b39d7cdcf0d3df5045f05fbac77","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"test4"},"is_default_conv":false,"unread":true,"active_at":1589468197,"active_at_ms":1589468197735,"member_status":"active","creator_info":{"ctime":1551849050729,"username":"dxb"}},{"id":"00004380e20bf4d56cf5e80a7435d594e07ebe043da93468c93c9bf0080f9ef5","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"test5"},"is_default_conv":false,"unread":true,"active_at":1589468203,"active_at_ms":1589468203980,"member_status":"active","creator_info":{"ctime":1551849051084,"username":"dxb"}},{"id":"00003bd0aa429c33eee546f20efb76c9e0a9854b0ca18278300bcf6fc4c4fb93","channel":{"name":"mkbot","members_type":"team","topic_type":"chat","topic_name":"trivia"},"is_default_conv":false,"unread":false,"active_at":1589468113,"active_at_ms":1589468113074,"member_status":"active","creator_info":{"ctime":1580428008401,"username":"dxb"}}],"offline":false}}`
+		send            = `{"result":{"message":"message sent","id":894,"ratelimits":[{"tank":"chat","capacity":9000,"reset":155,"gas":8991}]}}`
+	)
+
+	var jsonOut string
+	switch os.Getenv("GO_WANT_HELPER_CALLER") {
+	case "listconvsonname":
+		jsonOut = listconvsonname
+	case "send":
+		jsonOut = send
+	default:
+		jsonOut = ""
+	}
+
+	fmt.Fprintf(os.Stdout, jsonOut)
+	os.Exit(0)
+}

v2/kvstore.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"samhofi.us/x/keybase/types/keybase1"
+	"samhofi.us/x/keybase/v2/types/keybase1"
 )
 
 // KVListNamespaces returns all namespaces for a team

v2/team.go

@@ -0,0 +1,189 @@
+package keybase
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+// teamAPIOut sends JSON requests to the team API and returns its response.
+func teamAPIOut(k *Keybase, t TeamAPI) (TeamAPI, error) {
+	jsonBytes, _ := json.Marshal(t)
+
+	cmdOut, err := k.Exec("team", "api", "-m", string(jsonBytes))
+	if err != nil {
+		return TeamAPI{}, err
+	}
+
+	var r TeamAPI
+	if err := json.Unmarshal(cmdOut, &r); err != nil {
+		return TeamAPI{}, err
+	}
+	if r.Error != nil {
+		return TeamAPI{}, errors.New(r.Error.Message)
+	}
+
+	return r, nil
+}
+
+// AddUser adds a member to a team by username
+func (t Team) AddUser(user, role string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "add-members"
+	m.Params.Options.Team = t.Name
+	m.Params.Options.Usernames = []usernames{
+		{
+			Username: user,
+			Role:     role,
+		},
+	}
+
+	r, err := teamAPIOut(t.keybase, m)
+	if err == nil && r.Error == nil {
+		r, err = t.MemberList()
+	}
+	return r, err
+}
+
+// RemoveUser removes a member from a team
+func (t Team) RemoveUser(user string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "remove-member"
+	m.Params.Options.Team = t.Name
+	m.Params.Options.Username = user
+
+	r, err := teamAPIOut(t.keybase, m)
+	return r, err
+}
+
+// AddReaders adds members to a team by username, and sets their roles to Reader
+func (t Team) AddReaders(users ...string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "add-members"
+	m.Params.Options.Team = t.Name
+	addUsers := []usernames{}
+	for _, u := range users {
+		addUsers = append(addUsers, usernames{Username: u, Role: "reader"})
+	}
+	m.Params.Options.Usernames = addUsers
+
+	r, err := teamAPIOut(t.keybase, m)
+	if err == nil && r.Error == nil {
+		r, err = t.MemberList()
+	}
+	return r, err
+}
+
+// AddWriters adds members to a team by username, and sets their roles to Writer
+func (t Team) AddWriters(users ...string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "add-members"
+	m.Params.Options.Team = t.Name
+	addUsers := []usernames{}
+	for _, u := range users {
+		addUsers = append(addUsers, usernames{Username: u, Role: "writer"})
+	}
+	m.Params.Options.Usernames = addUsers
+
+	r, err := teamAPIOut(t.keybase, m)
+	if err == nil && r.Error == nil {
+		r, err = t.MemberList()
+	}
+	return r, err
+}
+
+// AddAdmins adds members to a team by username, and sets their roles to Writer
+func (t Team) AddAdmins(users ...string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "add-members"
+	m.Params.Options.Team = t.Name
+	addUsers := []usernames{}
+	for _, u := range users {
+		addUsers = append(addUsers, usernames{Username: u, Role: "admin"})
+	}
+	m.Params.Options.Usernames = addUsers
+
+	r, err := teamAPIOut(t.keybase, m)
+	if err == nil && r.Error == nil {
+		r, err = t.MemberList()
+	}
+	return r, err
+}
+
+// AddOwners adds members to a team by username, and sets their roles to Writer
+func (t Team) AddOwners(users ...string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "add-members"
+	m.Params.Options.Team = t.Name
+	addUsers := []usernames{}
+	for _, u := range users {
+		addUsers = append(addUsers, usernames{Username: u, Role: "owner"})
+	}
+	m.Params.Options.Usernames = addUsers
+
+	r, err := teamAPIOut(t.keybase, m)
+	if err == nil && r.Error == nil {
+		r, err = t.MemberList()
+	}
+	return r, err
+}
+
+// MemberList returns a list of a team's members
+func (t Team) MemberList() (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "list-team-memberships"
+	m.Params.Options.Team = t.Name
+
+	r, err := teamAPIOut(t.keybase, m)
+	return r, err
+}
+
+// CreateSubteam creates a subteam
+func (t Team) CreateSubteam(name string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "create-team"
+	m.Params.Options.Team = fmt.Sprintf("%s.%s", t.Name, name)
+
+	r, err := teamAPIOut(t.keybase, m)
+	return r, err
+}
+
+// CreateTeam creates a new team
+func (k *Keybase) CreateTeam(name string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "create-team"
+	m.Params.Options.Team = name
+
+	r, err := teamAPIOut(k, m)
+	return r, err
+}
+
+// ListUserMemberships returns information about a given user's team memberships
+func (k *Keybase) ListUserMemberships(user string) (TeamAPI, error) {
+	m := TeamAPI{
+		Params: &tParams{},
+	}
+	m.Method = "list-user-memberships"
+	m.Params.Options.Username = user
+
+	r, err := teamAPIOut(k, m)
+	return r, err
+}

v2/types.go

@@ -6,8 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"samhofi.us/x/keybase/types/chat1"
+	"samhofi.us/x/keybase/v2/types/chat1"
-	"samhofi.us/x/keybase/types/stellar1"
+	"samhofi.us/x/keybase/v2/types/stellar1"
 )
 
 // RunOptions holds a set of options to be passed to Run
@@ -20,6 +20,37 @@ type RunOptions struct {
 	FilterChannels []chat1.ChatChannel // Only subscribe to messages from specified channels
 }
 
+// KeybaseOpt configures a Keybase
+type KeybaseOpt interface {
+	apply(kb *Keybase)
+}
+
+// SetExePath sets the path to the Keybase executable
+func SetExePath(path string) KeybaseOpt {
+	return setExePath{path}
+}
+
+type setExePath struct {
+	path string
+}
+
+func (o setExePath) apply(kb *Keybase) {
+	kb.ExePath = o.path
+}
+
+// SetHomePath sets the path to the Keybase home directory
+func SetHomePath(path string) KeybaseOpt {
+	return setHomePath{path}
+}
+
+type setHomePath struct {
+	path string
+}
+
+func (o setHomePath) apply(kb *Keybase) {
+	kb.HomePath = o.path
+}
+
 type subscriptionType struct {
 	Type string `json:"type"`
 }
@@ -83,6 +114,7 @@ type SendMessageOptions struct {
 	ReplyTo           *chat1.MessageID   `json:"reply_to,omitempty"`
 	ExplodingLifetime *ExplodingLifetime `json:"exploding_lifetime,omitempty"`
 	UnreadOnly        bool               `json:"unread_only,omitempty"`
+	NonBlock          bool               `json:"nonblock,omitempty"`
 }
 
 type sendMessageParams struct {
@@ -207,6 +239,24 @@ func newListMembersArg(options ListMembersOptions) listMembersArg {
 	}
 }
 
+type listConvsOnNameParams struct {
+	Options chat1.ChatChannel
+}
+
+type listConvsOnNameArg struct {
+	Method string
+	Params listConvsOnNameParams
+}
+
+func newListConvsOnNameArg(channel chat1.ChatChannel) listConvsOnNameArg {
+	return listConvsOnNameArg{
+		Method: "listconvsonname",
+		Params: listConvsOnNameParams{
+			Options: channel,
+		},
+	}
+}
+
 // KVOptions holds a set of options to be passed to the KV methods
 type KVOptions struct {
 	Team       *string `json:"team"`
@@ -954,7 +1004,8 @@ type userBlocks struct {
 
 // Keybase holds basic information about the local Keybase executable
 type Keybase struct {
-	Path     string
+	HomePath string
+	ExePath  string
 	Username string
 	LoggedIn bool
 	Version  string

v2/types/chat1/api.go

@@ -1,11 +1,11 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/api.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/api.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
 )
 
 type ConvIDStr string
@@ -139,9 +139,119 @@ func (o MsgFlipContent) DeepCopy() MsgFlipContent {
 	}
 }
 
+type EmojiContent struct {
+	Alias       string     `codec:"alias" json:"alias"`
+	IsCrossTeam bool       `codec:"isCrossTeam" json:"isCrossTeam"`
+	ConvID      *ConvIDStr `codec:"convID,omitempty" json:"convID,omitempty"`
+	MessageID   *MessageID `codec:"messageID,omitempty" json:"messageID,omitempty"`
+}
+
+func (o EmojiContent) DeepCopy() EmojiContent {
+	return EmojiContent{
+		Alias:       o.Alias,
+		IsCrossTeam: o.IsCrossTeam,
+		ConvID: (func(x *ConvIDStr) *ConvIDStr {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ConvID),
+		MessageID: (func(x *MessageID) *MessageID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.MessageID),
+	}
+}
+
+type MsgTextContent struct {
+	Body         string             `codec:"body" json:"body"`
+	Payments     []TextPayment      `codec:"payments" json:"payments"`
+	ReplyTo      *MessageID         `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
+	ReplyToUID   *string            `codec:"replyToUID,omitempty" json:"replyToUID,omitempty"`
+	UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"`
+	TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"`
+	LiveLocation *LiveLocation      `codec:"liveLocation,omitempty" json:"liveLocation,omitempty"`
+	Emojis       []EmojiContent     `codec:"emojis" json:"emojis"`
+}
+
+func (o MsgTextContent) DeepCopy() MsgTextContent {
+	return MsgTextContent{
+		Body: o.Body,
+		Payments: (func(x []TextPayment) []TextPayment {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TextPayment, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Payments),
+		ReplyTo: (func(x *MessageID) *MessageID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ReplyTo),
+		ReplyToUID: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ReplyToUID),
+		UserMentions: (func(x []KnownUserMention) []KnownUserMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]KnownUserMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.UserMentions),
+		TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]KnownTeamMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.TeamMentions),
+		LiveLocation: (func(x *LiveLocation) *LiveLocation {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.LiveLocation),
+		Emojis: (func(x []EmojiContent) []EmojiContent {
+			if x == nil {
+				return nil
+			}
+			ret := make([]EmojiContent, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
+	}
+}
+
 type MsgContent struct {
 	TypeName           string                       `codec:"typeName" json:"type"`
-	Text               *MessageText                 `codec:"text,omitempty" json:"text,omitempty"`
+	Text               *MsgTextContent              `codec:"text,omitempty" json:"text,omitempty"`
 	Attachment         *MessageAttachment           `codec:"attachment,omitempty" json:"attachment,omitempty"`
 	Edit               *MessageEdit                 `codec:"edit,omitempty" json:"edit,omitempty"`
 	Reaction           *MessageReaction             `codec:"reaction,omitempty" json:"reaction,omitempty"`
@@ -159,7 +269,7 @@ type MsgContent struct {
 func (o MsgContent) DeepCopy() MsgContent {
 	return MsgContent{
 		TypeName: o.TypeName,
-		Text: (func(x *MessageText) *MessageText {
+		Text: (func(x *MsgTextContent) *MsgTextContent {
 			if x == nil {
 				return nil
 			}
@@ -269,7 +379,7 @@ type MsgSummary struct {
 	IsEphemeral         bool                     `codec:"isEphemeral,omitempty" json:"is_ephemeral,omitempty"`
 	IsEphemeralExpired  bool                     `codec:"isEphemeralExpired,omitempty" json:"is_ephemeral_expired,omitempty"`
 	ETime               gregor1.Time             `codec:"eTime,omitempty" json:"e_time,omitempty"`
-	Reactions           *ReactionMap             `codec:"reactions,omitempty" json:"reactions,omitempty"`
+	Reactions           *UIReactionMap           `codec:"reactions,omitempty" json:"reactions,omitempty"`
 	HasPairwiseMacs     bool                     `codec:"hasPairwiseMacs,omitempty" json:"has_pairwise_macs,omitempty"`
 	AtMentionUsernames  []string                 `codec:"atMentionUsernames,omitempty" json:"at_mention_usernames,omitempty"`
 	ChannelMention      string                   `codec:"channelMention,omitempty" json:"channel_mention,omitempty"`
@@ -304,7 +414,7 @@ func (o MsgSummary) DeepCopy() MsgSummary {
 		IsEphemeral:        o.IsEphemeral,
 		IsEphemeralExpired: o.IsEphemeralExpired,
 		ETime:              o.ETime.DeepCopy(),
-		Reactions: (func(x *ReactionMap) *ReactionMap {
+		Reactions: (func(x *UIReactionMap) *UIReactionMap {
 			if x == nil {
 				return nil
 			}
@@ -832,6 +942,7 @@ type AdvertiseCommandAPIParam struct {
 	Typ      string                `codec:"typ" json:"type"`
 	Commands []UserBotCommandInput `codec:"commands" json:"commands"`
 	TeamName string                `codec:"teamName,omitempty" json:"team_name,omitempty"`
+	ConvID   ConvIDStr             `codec:"convID,omitempty" json:"conv_id,omitempty"`
 }
 
 func (o AdvertiseCommandAPIParam) DeepCopy() AdvertiseCommandAPIParam {
@@ -849,6 +960,7 @@ func (o AdvertiseCommandAPIParam) DeepCopy() AdvertiseCommandAPIParam {
 			return ret
 		})(o.Commands),
 		TeamName: o.TeamName,
+		ConvID:   o.ConvID.DeepCopy(),
 	}
 }
 
@@ -899,7 +1011,7 @@ func (o GetResetConvMembersRes) DeepCopy() GetResetConvMembersRes {
 type DeviceInfo struct {
 	DeviceID          keybase1.DeviceID     `codec:"deviceID" json:"id"`
 	DeviceDescription string                `codec:"deviceDescription" json:"description"`
-	DeviceType        string            `codec:"deviceType" json:"type"`
+	DeviceType        keybase1.DeviceTypeV2 `codec:"deviceType" json:"type"`
 	DeviceCtime       int64                 `codec:"deviceCtime" json:"ctime"`
 }
 
@@ -907,7 +1019,7 @@ func (o DeviceInfo) DeepCopy() DeviceInfo {
 	return DeviceInfo{
 		DeviceID:          o.DeviceID.DeepCopy(),
 		DeviceDescription: o.DeviceDescription,
-		DeviceType:        o.DeviceType,
+		DeviceType:        o.DeviceType.DeepCopy(),
 		DeviceCtime:       o.DeviceCtime,
 	}
 }

v2/types/chat1/blocking.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/blocking.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/blocking.avdl
 
 package chat1

v2/types/chat1/chat_ui.go

@@ -1,14 +1,15 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/chat_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/chat_ui.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
-	stellar1 "samhofi.us/x/keybase/types/stellar1"
 	"errors"
 	"fmt"
+
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
+	stellar1 "samhofi.us/x/keybase/v2/types/stellar1"
 )
 
 type UIPagination struct {
@@ -536,6 +537,7 @@ type InboxUIItem struct {
 	IsDefaultConv     bool                          `codec:"isDefaultConv" json:"isDefaultConv"`
 	Name              string                        `codec:"name" json:"name"`
 	Snippet           string                        `codec:"snippet" json:"snippet"`
+	SnippetDecorated  string                        `codec:"snippetDecorated" json:"snippetDecorated"`
 	SnippetDecoration SnippetDecoration             `codec:"snippetDecoration" json:"snippetDecoration"`
 	Channel           string                        `codec:"channel" json:"channel"`
 	Headline          string                        `codec:"headline" json:"headline"`
@@ -578,6 +580,7 @@ func (o InboxUIItem) DeepCopy() InboxUIItem {
 		IsDefaultConv:     o.IsDefaultConv,
 		Name:              o.Name,
 		Snippet:           o.Snippet,
+		SnippetDecorated:  o.SnippetDecorated,
 		SnippetDecoration: o.SnippetDecoration.DeepCopy(),
 		Channel:           o.Channel,
 		Headline:          o.Headline,
@@ -888,6 +891,50 @@ func (o UIMessageUnfurlInfo) DeepCopy() UIMessageUnfurlInfo {
 	}
 }
 
+type UIReactionDesc struct {
+	Decorated string              `codec:"decorated" json:"decorated"`
+	Users     map[string]Reaction `codec:"users" json:"users"`
+}
+
+func (o UIReactionDesc) DeepCopy() UIReactionDesc {
+	return UIReactionDesc{
+		Decorated: o.Decorated,
+		Users: (func(x map[string]Reaction) map[string]Reaction {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]Reaction, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Users),
+	}
+}
+
+type UIReactionMap struct {
+	Reactions map[string]UIReactionDesc `codec:"reactions" json:"reactions"`
+}
+
+func (o UIReactionMap) DeepCopy() UIReactionMap {
+	return UIReactionMap{
+		Reactions: (func(x map[string]UIReactionDesc) map[string]UIReactionDesc {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]UIReactionDesc, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Reactions),
+	}
+}
+
 type UIMessageValid struct {
 	MessageID             MessageID              `codec:"messageID" json:"messageID"`
 	Ctime                 gregor1.Time           `codec:"ctime" json:"ctime"`
@@ -897,7 +944,7 @@ type UIMessageValid struct {
 	BodySummary           string                 `codec:"bodySummary" json:"bodySummary"`
 	SenderUsername        string                 `codec:"senderUsername" json:"senderUsername"`
 	SenderDeviceName      string                 `codec:"senderDeviceName" json:"senderDeviceName"`
-	SenderDeviceType      string                 `codec:"senderDeviceType" json:"senderDeviceType"`
+	SenderDeviceType      keybase1.DeviceTypeV2  `codec:"senderDeviceType" json:"senderDeviceType"`
 	SenderUID             gregor1.UID            `codec:"senderUID" json:"senderUID"`
 	SenderDeviceID        gregor1.DeviceID       `codec:"senderDeviceID" json:"senderDeviceID"`
 	Superseded            bool                   `codec:"superseded" json:"superseded"`
@@ -910,7 +957,7 @@ type UIMessageValid struct {
 	IsEphemeralExpired    bool                   `codec:"isEphemeralExpired" json:"isEphemeralExpired"`
 	ExplodedBy            *string                `codec:"explodedBy,omitempty" json:"explodedBy,omitempty"`
 	Etime                 gregor1.Time           `codec:"etime" json:"etime"`
-	Reactions             ReactionMap            `codec:"reactions" json:"reactions"`
+	Reactions             UIReactionMap          `codec:"reactions" json:"reactions"`
 	HasPairwiseMacs       bool                   `codec:"hasPairwiseMacs" json:"hasPairwiseMacs"`
 	PaymentInfos          []UIPaymentInfo        `codec:"paymentInfos" json:"paymentInfos"`
 	RequestInfo           *UIRequestInfo         `codec:"requestInfo,omitempty" json:"requestInfo,omitempty"`
@@ -946,7 +993,7 @@ func (o UIMessageValid) DeepCopy() UIMessageValid {
 		BodySummary:      o.BodySummary,
 		SenderUsername:   o.SenderUsername,
 		SenderDeviceName: o.SenderDeviceName,
-		SenderDeviceType: o.SenderDeviceType,
+		SenderDeviceType: o.SenderDeviceType.DeepCopy(),
 		SenderUID:        o.SenderUID.DeepCopy(),
 		SenderDeviceID:   o.SenderDeviceID.DeepCopy(),
 		Superseded:       o.Superseded,
@@ -1067,6 +1114,7 @@ type UIMessageOutbox struct {
 	IsEphemeral       bool            `codec:"isEphemeral" json:"isEphemeral"`
 	FlipGameID        *FlipGameIDStr  `codec:"flipGameID,omitempty" json:"flipGameID,omitempty"`
 	ReplyTo           *UIMessage      `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
+	Supersedes        MessageID       `codec:"supersedes" json:"supersedes"`
 	Filename          string          `codec:"filename" json:"filename"`
 	Title             string          `codec:"title" json:"title"`
 	Preview           *MakePreviewRes `codec:"preview,omitempty" json:"preview,omitempty"`
@@ -1102,6 +1150,7 @@ func (o UIMessageOutbox) DeepCopy() UIMessageOutbox {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.ReplyTo),
+		Supersedes: o.Supersedes.DeepCopy(),
 		Filename:   o.Filename,
 		Title:      o.Title,
 		Preview: (func(x *MakePreviewRes) *MakePreviewRes {
@@ -1417,6 +1466,7 @@ const (
 	UITextDecorationTyp_LINK               UITextDecorationTyp = 4
 	UITextDecorationTyp_MAILTO             UITextDecorationTyp = 5
 	UITextDecorationTyp_KBFSPATH           UITextDecorationTyp = 6
+	UITextDecorationTyp_EMOJI              UITextDecorationTyp = 7
 )
 
 func (o UITextDecorationTyp) DeepCopy() UITextDecorationTyp { return o }
@@ -1429,6 +1479,7 @@ var UITextDecorationTypMap = map[string]UITextDecorationTyp{
 	"LINK":               4,
 	"MAILTO":             5,
 	"KBFSPATH":           6,
+	"EMOJI":              7,
 }
 
 var UITextDecorationTypRevMap = map[UITextDecorationTyp]string{
@@ -1439,6 +1490,7 @@ var UITextDecorationTypRevMap = map[UITextDecorationTyp]string{
 	4: "LINK",
 	5: "MAILTO",
 	6: "KBFSPATH",
+	7: "EMOJI",
 }
 
 func (e UITextDecorationTyp) String() string {
@@ -1565,6 +1617,7 @@ type UITextDecoration struct {
 	Link__               *UILinkDecoration     `codec:"link,omitempty" json:"link,omitempty"`
 	Mailto__             *UILinkDecoration     `codec:"mailto,omitempty" json:"mailto,omitempty"`
 	Kbfspath__           *KBFSPath             `codec:"kbfspath,omitempty" json:"kbfspath,omitempty"`
+	Emoji__              *Emoji                `codec:"emoji,omitempty" json:"emoji,omitempty"`
 }
 
 func (o *UITextDecoration) Typ() (ret UITextDecorationTyp, err error) {
@@ -1604,6 +1657,11 @@ func (o *UITextDecoration) Typ() (ret UITextDecorationTyp, err error) {
 			err = errors.New("unexpected nil value for Kbfspath__")
 			return ret, err
 		}
+	case UITextDecorationTyp_EMOJI:
+		if o.Emoji__ == nil {
+			err = errors.New("unexpected nil value for Emoji__")
+			return ret, err
+		}
 	}
 	return o.Typ__, nil
 }
@@ -1678,6 +1736,16 @@ func (o UITextDecoration) Kbfspath() (res KBFSPath) {
 	return *o.Kbfspath__
 }
 
+func (o UITextDecoration) Emoji() (res Emoji) {
+	if o.Typ__ != UITextDecorationTyp_EMOJI {
+		panic("wrong case accessed")
+	}
+	if o.Emoji__ == nil {
+		return
+	}
+	return *o.Emoji__
+}
+
 func NewUITextDecorationWithPayment(v TextPayment) UITextDecoration {
 	return UITextDecoration{
 		Typ__:     UITextDecorationTyp_PAYMENT,
@@ -1727,6 +1795,13 @@ func NewUITextDecorationWithKbfspath(v KBFSPath) UITextDecoration {
 	}
 }
 
+func NewUITextDecorationWithEmoji(v Emoji) UITextDecoration {
+	return UITextDecoration{
+		Typ__:   UITextDecorationTyp_EMOJI,
+		Emoji__: &v,
+	}
+}
+
 func (o UITextDecoration) DeepCopy() UITextDecoration {
 	return UITextDecoration{
 		Typ__: o.Typ__.DeepCopy(),
@@ -1779,6 +1854,13 @@ func (o UITextDecoration) DeepCopy() UITextDecoration {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.Kbfspath__),
+		Emoji__: (func(x *Emoji) *Emoji {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Emoji__),
 	}
 }
 
@@ -1918,6 +2000,7 @@ func (o UIChatSearchConvHits) DeepCopy() UIChatSearchConvHits {
 
 type UIChatSearchTeamHits struct {
 	Hits             []keybase1.TeamSearchItem `codec:"hits" json:"hits"`
+	SuggestedMatches bool                      `codec:"suggestedMatches" json:"suggestedMatches"`
 }
 
 func (o UIChatSearchTeamHits) DeepCopy() UIChatSearchTeamHits {
@@ -1933,6 +2016,29 @@ func (o UIChatSearchTeamHits) DeepCopy() UIChatSearchTeamHits {
 			}
 			return ret
 		})(o.Hits),
+		SuggestedMatches: o.SuggestedMatches,
+	}
+}
+
+type UIChatSearchBotHits struct {
+	Hits             []keybase1.FeaturedBot `codec:"hits" json:"hits"`
+	SuggestedMatches bool                   `codec:"suggestedMatches" json:"suggestedMatches"`
+}
+
+func (o UIChatSearchBotHits) DeepCopy() UIChatSearchBotHits {
+	return UIChatSearchBotHits{
+		Hits: (func(x []keybase1.FeaturedBot) []keybase1.FeaturedBot {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.FeaturedBot, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Hits),
+		SuggestedMatches: o.SuggestedMatches,
 	}
 }
 

v2/types/chat1/commands.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/commands.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/commands.avdl
 
 package chat1
 

v2/types/chat1/common.go

@@ -1,13 +1,15 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/common.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
 	"errors"
 	"fmt"
+
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
+	stellar1 "samhofi.us/x/keybase/v2/types/stellar1"
 )
 
 type ThreadID []byte
@@ -310,6 +312,8 @@ const (
 	TopicType_CHAT         TopicType = 1
 	TopicType_DEV          TopicType = 2
 	TopicType_KBFSFILEEDIT TopicType = 3
+	TopicType_EMOJI        TopicType = 4
+	TopicType_EMOJICROSS   TopicType = 5
 )
 
 func (o TopicType) DeepCopy() TopicType { return o }
@@ -319,6 +323,8 @@ var TopicTypeMap = map[string]TopicType{
 	"CHAT":         1,
 	"DEV":          2,
 	"KBFSFILEEDIT": 3,
+	"EMOJI":        4,
+	"EMOJICROSS":   5,
 }
 
 var TopicTypeRevMap = map[TopicType]string{
@@ -326,6 +332,8 @@ var TopicTypeRevMap = map[TopicType]string{
 	1: "CHAT",
 	2: "DEV",
 	3: "KBFSFILEEDIT",
+	4: "EMOJI",
+	5: "EMOJICROSS",
 }
 
 type TeamType int
@@ -626,6 +634,32 @@ func (o RateLimit) DeepCopy() RateLimit {
 	}
 }
 
+type InboxParticipantsMode int
+
+const (
+	InboxParticipantsMode_ALL        InboxParticipantsMode = 0
+	InboxParticipantsMode_SKIP_TEAMS InboxParticipantsMode = 1
+)
+
+func (o InboxParticipantsMode) DeepCopy() InboxParticipantsMode { return o }
+
+var InboxParticipantsModeMap = map[string]InboxParticipantsMode{
+	"ALL":        0,
+	"SKIP_TEAMS": 1,
+}
+
+var InboxParticipantsModeRevMap = map[InboxParticipantsMode]string{
+	0: "ALL",
+	1: "SKIP_TEAMS",
+}
+
+func (e InboxParticipantsMode) String() string {
+	if v, ok := InboxParticipantsModeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
 type GetInboxQuery struct {
 	ConvID            *ConversationID            `codec:"convID,omitempty" json:"convID,omitempty"`
 	TopicType         *TopicType                 `codec:"topicType,omitempty" json:"topicType,omitempty"`
@@ -644,6 +678,7 @@ type GetInboxQuery struct {
 	ReadOnly          bool                       `codec:"readOnly" json:"readOnly"`
 	ComputeActiveList bool                       `codec:"computeActiveList" json:"computeActiveList"`
 	SummarizeMaxMsgs  bool                       `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"`
+	ParticipantsMode  InboxParticipantsMode      `codec:"participantsMode" json:"participantsMode"`
 	SkipBgLoads       bool                       `codec:"skipBgLoads" json:"skipBgLoads"`
 	AllowUnseenQuery  bool                       `codec:"allowUnseenQuery" json:"allowUnseenQuery"`
 }
@@ -765,6 +800,7 @@ func (o GetInboxQuery) DeepCopy() GetInboxQuery {
 		ReadOnly:          o.ReadOnly,
 		ComputeActiveList: o.ComputeActiveList,
 		SummarizeMaxMsgs:  o.SummarizeMaxMsgs,
+		ParticipantsMode:  o.ParticipantsMode.DeepCopy(),
 		SkipBgLoads:       o.SkipBgLoads,
 		AllowUnseenQuery:  o.AllowUnseenQuery,
 	}
@@ -958,6 +994,7 @@ type ConversationReaderInfo struct {
 	MaxMsgid          MessageID                    `codec:"maxMsgid" json:"maxMsgid"`
 	Status            ConversationMemberStatus     `codec:"status" json:"status"`
 	UntrustedTeamRole keybase1.TeamRole            `codec:"untrustedTeamRole" json:"untrustedTeamRole"`
+	LastSendTime      gregor1.Time                 `codec:"l" json:"l"`
 	Journeycard       *ConversationJourneycardInfo `codec:"jc,omitempty" json:"jc,omitempty"`
 }
 
@@ -968,6 +1005,7 @@ func (o ConversationReaderInfo) DeepCopy() ConversationReaderInfo {
 		MaxMsgid:          o.MaxMsgid.DeepCopy(),
 		Status:            o.Status.DeepCopy(),
 		UntrustedTeamRole: o.UntrustedTeamRole.DeepCopy(),
+		LastSendTime:      o.LastSendTime.DeepCopy(),
 		Journeycard: (func(x *ConversationJourneycardInfo) *ConversationJourneycardInfo {
 			if x == nil {
 				return nil
@@ -1332,6 +1370,7 @@ type MessageClientHeader struct {
 	EphemeralMetadata *MsgEphemeralMetadata    `codec:"em,omitempty" json:"em,omitempty"`
 	PairwiseMacs      map[keybase1.KID][]byte  `codec:"pm" json:"pm"`
 	BotUID            *gregor1.UID             `codec:"b,omitempty" json:"b,omitempty"`
+	TxID              *stellar1.TransactionID  `codec:"t,omitempty" json:"t,omitempty"`
 }
 
 func (o MessageClientHeader) DeepCopy() MessageClientHeader {
@@ -1431,6 +1470,13 @@ func (o MessageClientHeader) DeepCopy() MessageClientHeader {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.BotUID),
+		TxID: (func(x *stellar1.TransactionID) *stellar1.TransactionID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.TxID),
 	}
 }
 
@@ -1958,6 +2004,7 @@ const (
 	GetThreadReason_KBFSFILEACTIVITY   GetThreadReason = 8
 	GetThreadReason_COINFLIP           GetThreadReason = 9
 	GetThreadReason_BOTCOMMANDS        GetThreadReason = 10
+	GetThreadReason_EMOJISOURCE        GetThreadReason = 11
 )
 
 func (o GetThreadReason) DeepCopy() GetThreadReason { return o }
@@ -1974,6 +2021,7 @@ var GetThreadReasonMap = map[string]GetThreadReason{
 	"KBFSFILEACTIVITY":   8,
 	"COINFLIP":           9,
 	"BOTCOMMANDS":        10,
+	"EMOJISOURCE":        11,
 }
 
 var GetThreadReasonRevMap = map[GetThreadReason]string{
@@ -1988,6 +2036,7 @@ var GetThreadReasonRevMap = map[GetThreadReason]string{
 	8:  "KBFSFILEACTIVITY",
 	9:  "COINFLIP",
 	10: "BOTCOMMANDS",
+	11: "EMOJISOURCE",
 }
 
 func (e GetThreadReason) String() string {
@@ -2044,6 +2093,8 @@ type SearchOpts struct {
 	ConvID            *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"`
 	MaxNameConvs      int             `codec:"maxNameConvs" json:"maxNameConvs"`
 	MaxTeams          int             `codec:"maxTeams" json:"maxTeams"`
+	MaxBots           int             `codec:"maxBots" json:"maxBots"`
+	SkipBotCache      bool            `codec:"skipBotCache" json:"skipBotCache"`
 }
 
 func (o SearchOpts) DeepCopy() SearchOpts {
@@ -2077,6 +2128,8 @@ func (o SearchOpts) DeepCopy() SearchOpts {
 		})(o.ConvID),
 		MaxNameConvs: o.MaxNameConvs,
 		MaxTeams:     o.MaxTeams,
+		MaxBots:      o.MaxBots,
+		SkipBotCache: o.SkipBotCache,
 	}
 }
 
@@ -2388,6 +2441,7 @@ type Asset struct {
 	Size      int64         `codec:"size" json:"size"`
 	MimeType  string        `codec:"mimeType" json:"mimeType"`
 	EncHash   Hash          `codec:"encHash" json:"encHash"`
+	PtHash    Hash          `codec:"ptHash" json:"ptHash"`
 	Key       []byte        `codec:"key" json:"key"`
 	VerifyKey []byte        `codec:"verifyKey" json:"verifyKey"`
 	Title     string        `codec:"title" json:"title"`
@@ -2406,6 +2460,7 @@ func (o Asset) DeepCopy() Asset {
 		Size:     o.Size,
 		MimeType: o.MimeType,
 		EncHash:  o.EncHash.DeepCopy(),
+		PtHash:   o.PtHash.DeepCopy(),
 		Key: (func(x []byte) []byte {
 			if x == nil {
 				return nil
@@ -2436,6 +2491,7 @@ const (
 	BotCommandsAdvertisementTyp_PUBLIC        BotCommandsAdvertisementTyp = 0
 	BotCommandsAdvertisementTyp_TLFID_MEMBERS BotCommandsAdvertisementTyp = 1
 	BotCommandsAdvertisementTyp_TLFID_CONVS   BotCommandsAdvertisementTyp = 2
+	BotCommandsAdvertisementTyp_CONV          BotCommandsAdvertisementTyp = 3
 )
 
 func (o BotCommandsAdvertisementTyp) DeepCopy() BotCommandsAdvertisementTyp { return o }
@@ -2444,12 +2500,14 @@ var BotCommandsAdvertisementTypMap = map[string]BotCommandsAdvertisementTyp{
 	"PUBLIC":        0,
 	"TLFID_MEMBERS": 1,
 	"TLFID_CONVS":   2,
+	"CONV":          3,
 }
 
 var BotCommandsAdvertisementTypRevMap = map[BotCommandsAdvertisementTyp]string{
 	0: "PUBLIC",
 	1: "TLFID_MEMBERS",
 	2: "TLFID_CONVS",
+	3: "CONV",
 }
 
 func (e BotCommandsAdvertisementTyp) String() string {
@@ -2472,3 +2530,126 @@ func (o TeamMember) DeepCopy() TeamMember {
 		Status: o.Status.DeepCopy(),
 	}
 }
+
+type LastActiveStatus int
+
+const (
+	LastActiveStatus_NONE            LastActiveStatus = 0
+	LastActiveStatus_ACTIVE          LastActiveStatus = 1
+	LastActiveStatus_RECENTLY_ACTIVE LastActiveStatus = 2
+)
+
+func (o LastActiveStatus) DeepCopy() LastActiveStatus { return o }
+
+var LastActiveStatusMap = map[string]LastActiveStatus{
+	"NONE":            0,
+	"ACTIVE":          1,
+	"RECENTLY_ACTIVE": 2,
+}
+
+var LastActiveStatusRevMap = map[LastActiveStatus]string{
+	0: "NONE",
+	1: "ACTIVE",
+	2: "RECENTLY_ACTIVE",
+}
+
+func (e LastActiveStatus) String() string {
+	if v, ok := LastActiveStatusRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type ChatMemberDetails struct {
+	Uid      keybase1.UID      `codec:"uid" json:"uid"`
+	Username string            `codec:"username" json:"username"`
+	FullName keybase1.FullName `codec:"fullName" json:"fullName"`
+}
+
+func (o ChatMemberDetails) DeepCopy() ChatMemberDetails {
+	return ChatMemberDetails{
+		Uid:      o.Uid.DeepCopy(),
+		Username: o.Username,
+		FullName: o.FullName.DeepCopy(),
+	}
+}
+
+type ChatMembersDetails struct {
+	Owners         []ChatMemberDetails `codec:"owners" json:"owners"`
+	Admins         []ChatMemberDetails `codec:"admins" json:"admins"`
+	Writers        []ChatMemberDetails `codec:"writers" json:"writers"`
+	Readers        []ChatMemberDetails `codec:"readers" json:"readers"`
+	Bots           []ChatMemberDetails `codec:"bots" json:"bots"`
+	RestrictedBots []ChatMemberDetails `codec:"restrictedBots" json:"restrictedBots"`
+}
+
+func (o ChatMembersDetails) DeepCopy() ChatMembersDetails {
+	return ChatMembersDetails{
+		Owners: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Owners),
+		Admins: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Admins),
+		Writers: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Writers),
+		Readers: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Readers),
+		Bots: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Bots),
+		RestrictedBots: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RestrictedBots),
+	}
+}

v2/types/chat1/emoji.go

@@ -0,0 +1,374 @@
+// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../../../../../../client/protocol/avdl/chat1/emoji.avdl
+
+package chat1
+
+import (
+	"errors"
+	"fmt"
+
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
+)
+
+type EmojiLoadSourceTyp int
+
+const (
+	EmojiLoadSourceTyp_HTTPSRV EmojiLoadSourceTyp = 0
+	EmojiLoadSourceTyp_STR     EmojiLoadSourceTyp = 1
+)
+
+func (o EmojiLoadSourceTyp) DeepCopy() EmojiLoadSourceTyp { return o }
+
+var EmojiLoadSourceTypMap = map[string]EmojiLoadSourceTyp{
+	"HTTPSRV": 0,
+	"STR":     1,
+}
+
+var EmojiLoadSourceTypRevMap = map[EmojiLoadSourceTyp]string{
+	0: "HTTPSRV",
+	1: "STR",
+}
+
+func (e EmojiLoadSourceTyp) String() string {
+	if v, ok := EmojiLoadSourceTypRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type EmojiLoadSource struct {
+	Typ__     EmojiLoadSourceTyp `codec:"typ" json:"typ"`
+	Httpsrv__ *string            `codec:"httpsrv,omitempty" json:"httpsrv,omitempty"`
+	Str__     *string            `codec:"str,omitempty" json:"str,omitempty"`
+}
+
+func (o *EmojiLoadSource) Typ() (ret EmojiLoadSourceTyp, err error) {
+	switch o.Typ__ {
+	case EmojiLoadSourceTyp_HTTPSRV:
+		if o.Httpsrv__ == nil {
+			err = errors.New("unexpected nil value for Httpsrv__")
+			return ret, err
+		}
+	case EmojiLoadSourceTyp_STR:
+		if o.Str__ == nil {
+			err = errors.New("unexpected nil value for Str__")
+			return ret, err
+		}
+	}
+	return o.Typ__, nil
+}
+
+func (o EmojiLoadSource) Httpsrv() (res string) {
+	if o.Typ__ != EmojiLoadSourceTyp_HTTPSRV {
+		panic("wrong case accessed")
+	}
+	if o.Httpsrv__ == nil {
+		return
+	}
+	return *o.Httpsrv__
+}
+
+func (o EmojiLoadSource) Str() (res string) {
+	if o.Typ__ != EmojiLoadSourceTyp_STR {
+		panic("wrong case accessed")
+	}
+	if o.Str__ == nil {
+		return
+	}
+	return *o.Str__
+}
+
+func NewEmojiLoadSourceWithHttpsrv(v string) EmojiLoadSource {
+	return EmojiLoadSource{
+		Typ__:     EmojiLoadSourceTyp_HTTPSRV,
+		Httpsrv__: &v,
+	}
+}
+
+func NewEmojiLoadSourceWithStr(v string) EmojiLoadSource {
+	return EmojiLoadSource{
+		Typ__: EmojiLoadSourceTyp_STR,
+		Str__: &v,
+	}
+}
+
+func (o EmojiLoadSource) DeepCopy() EmojiLoadSource {
+	return EmojiLoadSource{
+		Typ__: o.Typ__.DeepCopy(),
+		Httpsrv__: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Httpsrv__),
+		Str__: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Str__),
+	}
+}
+
+type EmojiRemoteSourceTyp int
+
+const (
+	EmojiRemoteSourceTyp_MESSAGE    EmojiRemoteSourceTyp = 0
+	EmojiRemoteSourceTyp_STOCKALIAS EmojiRemoteSourceTyp = 1
+)
+
+func (o EmojiRemoteSourceTyp) DeepCopy() EmojiRemoteSourceTyp { return o }
+
+var EmojiRemoteSourceTypMap = map[string]EmojiRemoteSourceTyp{
+	"MESSAGE":    0,
+	"STOCKALIAS": 1,
+}
+
+var EmojiRemoteSourceTypRevMap = map[EmojiRemoteSourceTyp]string{
+	0: "MESSAGE",
+	1: "STOCKALIAS",
+}
+
+func (e EmojiRemoteSourceTyp) String() string {
+	if v, ok := EmojiRemoteSourceTypRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type EmojiMessage struct {
+	ConvID  ConversationID `codec:"convID" json:"convID"`
+	MsgID   MessageID      `codec:"msgID" json:"msgID"`
+	IsAlias bool           `codec:"isAlias" json:"isAlias"`
+}
+
+func (o EmojiMessage) DeepCopy() EmojiMessage {
+	return EmojiMessage{
+		ConvID:  o.ConvID.DeepCopy(),
+		MsgID:   o.MsgID.DeepCopy(),
+		IsAlias: o.IsAlias,
+	}
+}
+
+type EmojiStockAlias struct {
+	Text     string       `codec:"text" json:"text"`
+	Username string       `codec:"username" json:"username"`
+	Time     gregor1.Time `codec:"time" json:"time"`
+}
+
+func (o EmojiStockAlias) DeepCopy() EmojiStockAlias {
+	return EmojiStockAlias{
+		Text:     o.Text,
+		Username: o.Username,
+		Time:     o.Time.DeepCopy(),
+	}
+}
+
+type EmojiRemoteSource struct {
+	Typ__        EmojiRemoteSourceTyp `codec:"typ" json:"typ"`
+	Message__    *EmojiMessage        `codec:"message,omitempty" json:"message,omitempty"`
+	Stockalias__ *EmojiStockAlias     `codec:"stockalias,omitempty" json:"stockalias,omitempty"`
+}
+
+func (o *EmojiRemoteSource) Typ() (ret EmojiRemoteSourceTyp, err error) {
+	switch o.Typ__ {
+	case EmojiRemoteSourceTyp_MESSAGE:
+		if o.Message__ == nil {
+			err = errors.New("unexpected nil value for Message__")
+			return ret, err
+		}
+	case EmojiRemoteSourceTyp_STOCKALIAS:
+		if o.Stockalias__ == nil {
+			err = errors.New("unexpected nil value for Stockalias__")
+			return ret, err
+		}
+	}
+	return o.Typ__, nil
+}
+
+func (o EmojiRemoteSource) Message() (res EmojiMessage) {
+	if o.Typ__ != EmojiRemoteSourceTyp_MESSAGE {
+		panic("wrong case accessed")
+	}
+	if o.Message__ == nil {
+		return
+	}
+	return *o.Message__
+}
+
+func (o EmojiRemoteSource) Stockalias() (res EmojiStockAlias) {
+	if o.Typ__ != EmojiRemoteSourceTyp_STOCKALIAS {
+		panic("wrong case accessed")
+	}
+	if o.Stockalias__ == nil {
+		return
+	}
+	return *o.Stockalias__
+}
+
+func NewEmojiRemoteSourceWithMessage(v EmojiMessage) EmojiRemoteSource {
+	return EmojiRemoteSource{
+		Typ__:     EmojiRemoteSourceTyp_MESSAGE,
+		Message__: &v,
+	}
+}
+
+func NewEmojiRemoteSourceWithStockalias(v EmojiStockAlias) EmojiRemoteSource {
+	return EmojiRemoteSource{
+		Typ__:        EmojiRemoteSourceTyp_STOCKALIAS,
+		Stockalias__: &v,
+	}
+}
+
+func (o EmojiRemoteSource) DeepCopy() EmojiRemoteSource {
+	return EmojiRemoteSource{
+		Typ__: o.Typ__.DeepCopy(),
+		Message__: (func(x *EmojiMessage) *EmojiMessage {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Message__),
+		Stockalias__: (func(x *EmojiStockAlias) *EmojiStockAlias {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Stockalias__),
+	}
+}
+
+type HarvestedEmoji struct {
+	Alias       string            `codec:"alias" json:"alias"`
+	IsBig       bool              `codec:"isBig" json:"isBig"`
+	IsCrossTeam bool              `codec:"isCrossTeam" json:"isCrossTeam"`
+	Source      EmojiRemoteSource `codec:"source" json:"source"`
+}
+
+func (o HarvestedEmoji) DeepCopy() HarvestedEmoji {
+	return HarvestedEmoji{
+		Alias:       o.Alias,
+		IsBig:       o.IsBig,
+		IsCrossTeam: o.IsCrossTeam,
+		Source:      o.Source.DeepCopy(),
+	}
+}
+
+type EmojiCreationInfo struct {
+	Username string       `codec:"username" json:"username"`
+	Time     gregor1.Time `codec:"time" json:"time"`
+}
+
+func (o EmojiCreationInfo) DeepCopy() EmojiCreationInfo {
+	return EmojiCreationInfo{
+		Username: o.Username,
+		Time:     o.Time.DeepCopy(),
+	}
+}
+
+type Emoji struct {
+	Alias        string             `codec:"alias" json:"alias"`
+	IsBig        bool               `codec:"isBig" json:"isBig"`
+	IsReacji     bool               `codec:"isReacji" json:"isReacji"`
+	IsCrossTeam  bool               `codec:"isCrossTeam" json:"isCrossTeam"`
+	IsAlias      bool               `codec:"isAlias" json:"isAlias"`
+	Source       EmojiLoadSource    `codec:"source" json:"source"`
+	NoAnimSource EmojiLoadSource    `codec:"noAnimSource" json:"noAnimSource"`
+	RemoteSource EmojiRemoteSource  `codec:"remoteSource" json:"remoteSource"`
+	CreationInfo *EmojiCreationInfo `codec:"creationInfo,omitempty" json:"creationInfo,omitempty"`
+	Teamname     *string            `codec:"teamname,omitempty" json:"teamname,omitempty"`
+}
+
+func (o Emoji) DeepCopy() Emoji {
+	return Emoji{
+		Alias:        o.Alias,
+		IsBig:        o.IsBig,
+		IsReacji:     o.IsReacji,
+		IsCrossTeam:  o.IsCrossTeam,
+		IsAlias:      o.IsAlias,
+		Source:       o.Source.DeepCopy(),
+		NoAnimSource: o.NoAnimSource.DeepCopy(),
+		RemoteSource: o.RemoteSource.DeepCopy(),
+		CreationInfo: (func(x *EmojiCreationInfo) *EmojiCreationInfo {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.CreationInfo),
+		Teamname: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Teamname),
+	}
+}
+
+type EmojiGroup struct {
+	Name   string  `codec:"name" json:"name"`
+	Emojis []Emoji `codec:"emojis" json:"emojis"`
+}
+
+func (o EmojiGroup) DeepCopy() EmojiGroup {
+	return EmojiGroup{
+		Name: o.Name,
+		Emojis: (func(x []Emoji) []Emoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]Emoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
+	}
+}
+
+type UserEmojis struct {
+	Emojis []EmojiGroup `codec:"emojis" json:"emojis"`
+}
+
+func (o UserEmojis) DeepCopy() UserEmojis {
+	return UserEmojis{
+		Emojis: (func(x []EmojiGroup) []EmojiGroup {
+			if x == nil {
+				return nil
+			}
+			ret := make([]EmojiGroup, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
+	}
+}
+
+type EmojiStorage struct {
+	Mapping map[string]EmojiRemoteSource `codec:"mapping" json:"mapping"`
+}
+
+func (o EmojiStorage) DeepCopy() EmojiStorage {
+	return EmojiStorage{
+		Mapping: (func(x map[string]EmojiRemoteSource) map[string]EmojiRemoteSource {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]EmojiRemoteSource, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Mapping),
+	}
+}

v2/types/chat1/gregor.go

@@ -1,11 +1,11 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/gregor.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/gregor.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
 )
 
 type GenericPayload struct {
@@ -453,16 +453,6 @@ func (o UpdateConversations) DeepCopy() UpdateConversations {
 	}
 }
 
-type TeamChannelUpdate struct {
-	TeamID TLFID `codec:"teamID" json:"teamID"`
-}
-
-func (o TeamChannelUpdate) DeepCopy() TeamChannelUpdate {
-	return TeamChannelUpdate{
-		TeamID: o.TeamID.DeepCopy(),
-	}
-}
-
 type SetConvRetentionUpdate struct {
 	InboxVers InboxVers       `codec:"inboxVers" json:"inboxVers"`
 	ConvID    ConversationID  `codec:"convID" json:"convID"`

v2/types/chat1/local.go

@@ -1,14 +1,15 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/local.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/local.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
-	stellar1 "samhofi.us/x/keybase/types/stellar1"
 	"errors"
 	"fmt"
+
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
+	stellar1 "samhofi.us/x/keybase/v2/types/stellar1"
 )
 
 type VersionKind string
@@ -201,6 +202,7 @@ type MessageText struct {
 	UserMentions []KnownUserMention        `codec:"userMentions" json:"userMentions"`
 	TeamMentions []KnownTeamMention        `codec:"teamMentions" json:"teamMentions"`
 	LiveLocation *LiveLocation             `codec:"liveLocation,omitempty" json:"liveLocation,omitempty"`
+	Emojis       map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageText) DeepCopy() MessageText {
@@ -260,6 +262,18 @@ func (o MessageText) DeepCopy() MessageText {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.LiveLocation),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -278,6 +292,7 @@ type MessageEdit struct {
 	Body         string                    `codec:"body" json:"body"`
 	UserMentions []KnownUserMention        `codec:"userMentions" json:"userMentions"`
 	TeamMentions []KnownTeamMention        `codec:"teamMentions" json:"teamMentions"`
+	Emojis       map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageEdit) DeepCopy() MessageEdit {
@@ -306,6 +321,18 @@ func (o MessageEdit) DeepCopy() MessageEdit {
 			}
 			return ret
 		})(o.TeamMentions),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -331,11 +358,24 @@ func (o MessageDelete) DeepCopy() MessageDelete {
 
 type MessageHeadline struct {
 	Headline string                    `codec:"headline" json:"headline"`
+	Emojis   map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageHeadline) DeepCopy() MessageHeadline {
 	return MessageHeadline{
 		Headline: o.Headline,
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -399,6 +439,7 @@ const (
 	MessageSystemType_CHANGERETENTION   MessageSystemType = 6
 	MessageSystemType_BULKADDTOCONV     MessageSystemType = 7
 	MessageSystemType_SBSRESOLVE        MessageSystemType = 8
+	MessageSystemType_NEWCHANNEL        MessageSystemType = 9
 )
 
 func (o MessageSystemType) DeepCopy() MessageSystemType { return o }
@@ -413,6 +454,7 @@ var MessageSystemTypeMap = map[string]MessageSystemType{
 	"CHANGERETENTION":   6,
 	"BULKADDTOCONV":     7,
 	"SBSRESOLVE":        8,
+	"NEWCHANNEL":        9,
 }
 
 var MessageSystemTypeRevMap = map[MessageSystemType]string{
@@ -425,6 +467,7 @@ var MessageSystemTypeRevMap = map[MessageSystemType]string{
 	6: "CHANGERETENTION",
 	7: "BULKADDTOCONV",
 	8: "SBSRESOLVE",
+	9: "NEWCHANNEL",
 }
 
 func (e MessageSystemType) String() string {
@@ -440,12 +483,6 @@ type MessageSystemAddedToTeam struct {
 	Addee    string            `codec:"addee" json:"addee"`
 	Role     keybase1.TeamRole `codec:"role" json:"role"`
 	BulkAdds []string          `codec:"bulkAdds" json:"bulkAdds"`
-	Owners         []string          `codec:"owners" json:"owners"`
-	Admins         []string          `codec:"admins" json:"admins"`
-	Writers        []string          `codec:"writers" json:"writers"`
-	Readers        []string          `codec:"readers" json:"readers"`
-	Bots           []string          `codec:"bots" json:"bots"`
-	RestrictedBots []string          `codec:"restrictedBots" json:"restrictedBots"`
 }
 
 func (o MessageSystemAddedToTeam) DeepCopy() MessageSystemAddedToTeam {
@@ -465,72 +502,6 @@ func (o MessageSystemAddedToTeam) DeepCopy() MessageSystemAddedToTeam {
 			}
 			return ret
 		})(o.BulkAdds),
-		Owners: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Owners),
-		Admins: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Admins),
-		Writers: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Writers),
-		Readers: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Readers),
-		Bots: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Bots),
-		RestrictedBots: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.RestrictedBots),
 	}
 }
 
@@ -672,6 +643,20 @@ func (o MessageSystemSbsResolve) DeepCopy() MessageSystemSbsResolve {
 	}
 }
 
+type MessageSystemNewChannel struct {
+	Creator        string         `codec:"creator" json:"creator"`
+	NameAtCreation string         `codec:"nameAtCreation" json:"nameAtCreation"`
+	ConvID         ConversationID `codec:"convID" json:"convID"`
+}
+
+func (o MessageSystemNewChannel) DeepCopy() MessageSystemNewChannel {
+	return MessageSystemNewChannel{
+		Creator:        o.Creator,
+		NameAtCreation: o.NameAtCreation,
+		ConvID:         o.ConvID.DeepCopy(),
+	}
+}
+
 type MessageSystem struct {
 	SystemType__        MessageSystemType               `codec:"systemType" json:"systemType"`
 	Addedtoteam__       *MessageSystemAddedToTeam       `codec:"addedtoteam,omitempty" json:"addedtoteam,omitempty"`
@@ -683,6 +668,7 @@ type MessageSystem struct {
 	Changeretention__   *MessageSystemChangeRetention   `codec:"changeretention,omitempty" json:"changeretention,omitempty"`
 	Bulkaddtoconv__     *MessageSystemBulkAddToConv     `codec:"bulkaddtoconv,omitempty" json:"bulkaddtoconv,omitempty"`
 	Sbsresolve__        *MessageSystemSbsResolve        `codec:"sbsresolve,omitempty" json:"sbsresolve,omitempty"`
+	Newchannel__        *MessageSystemNewChannel        `codec:"newchannel,omitempty" json:"newchannel,omitempty"`
 }
 
 func (o *MessageSystem) SystemType() (ret MessageSystemType, err error) {
@@ -732,6 +718,11 @@ func (o *MessageSystem) SystemType() (ret MessageSystemType, err error) {
 			err = errors.New("unexpected nil value for Sbsresolve__")
 			return ret, err
 		}
+	case MessageSystemType_NEWCHANNEL:
+		if o.Newchannel__ == nil {
+			err = errors.New("unexpected nil value for Newchannel__")
+			return ret, err
+		}
 	}
 	return o.SystemType__, nil
 }
@@ -826,6 +817,16 @@ func (o MessageSystem) Sbsresolve() (res MessageSystemSbsResolve) {
 	return *o.Sbsresolve__
 }
 
+func (o MessageSystem) Newchannel() (res MessageSystemNewChannel) {
+	if o.SystemType__ != MessageSystemType_NEWCHANNEL {
+		panic("wrong case accessed")
+	}
+	if o.Newchannel__ == nil {
+		return
+	}
+	return *o.Newchannel__
+}
+
 func NewMessageSystemWithAddedtoteam(v MessageSystemAddedToTeam) MessageSystem {
 	return MessageSystem{
 		SystemType__:  MessageSystemType_ADDEDTOTEAM,
@@ -889,6 +890,13 @@ func NewMessageSystemWithSbsresolve(v MessageSystemSbsResolve) MessageSystem {
 	}
 }
 
+func NewMessageSystemWithNewchannel(v MessageSystemNewChannel) MessageSystem {
+	return MessageSystem{
+		SystemType__: MessageSystemType_NEWCHANNEL,
+		Newchannel__: &v,
+	}
+}
+
 func (o MessageSystem) DeepCopy() MessageSystem {
 	return MessageSystem{
 		SystemType__: o.SystemType__.DeepCopy(),
@@ -955,6 +963,13 @@ func (o MessageSystem) DeepCopy() MessageSystem {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.Sbsresolve__),
+		Newchannel__: (func(x *MessageSystemNewChannel) *MessageSystemNewChannel {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Newchannel__),
 	}
 }
 
@@ -976,6 +991,7 @@ type MessageAttachment struct {
 	Uploaded     bool                      `codec:"uploaded" json:"uploaded"`
 	UserMentions []KnownUserMention        `codec:"userMentions" json:"userMentions"`
 	TeamMentions []KnownTeamMention        `codec:"teamMentions" json:"teamMentions"`
+	Emojis       map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageAttachment) DeepCopy() MessageAttachment {
@@ -1028,6 +1044,18 @@ func (o MessageAttachment) DeepCopy() MessageAttachment {
 			}
 			return ret
 		})(o.TeamMentions),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -1104,12 +1132,33 @@ func (o MessageLeave) DeepCopy() MessageLeave {
 type MessageReaction struct {
 	MessageID MessageID                 `codec:"m" json:"m"`
 	Body      string                    `codec:"b" json:"b"`
+	TargetUID *gregor1.UID              `codec:"t,omitempty" json:"t,omitempty"`
+	Emojis    map[string]HarvestedEmoji `codec:"e" json:"e"`
 }
 
 func (o MessageReaction) DeepCopy() MessageReaction {
 	return MessageReaction{
 		MessageID: o.MessageID.DeepCopy(),
 		Body:      o.Body,
+		TargetUID: (func(x *gregor1.UID) *gregor1.UID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.TargetUID),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -2816,6 +2865,7 @@ type MessagePlaintext struct {
 	ClientHeader       MessageClientHeader `codec:"clientHeader" json:"clientHeader"`
 	MessageBody        MessageBody         `codec:"messageBody" json:"messageBody"`
 	SupersedesOutboxID *OutboxID           `codec:"supersedesOutboxID,omitempty" json:"supersedesOutboxID,omitempty"`
+	Emojis             []HarvestedEmoji    `codec:"emojis" json:"emojis"`
 }
 
 func (o MessagePlaintext) DeepCopy() MessagePlaintext {
@@ -2829,6 +2879,17 @@ func (o MessagePlaintext) DeepCopy() MessagePlaintext {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.SupersedesOutboxID),
+		Emojis: (func(x []HarvestedEmoji) []HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]HarvestedEmoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -2838,7 +2899,7 @@ type MessageUnboxedValid struct {
 	MessageBody           MessageBody                 `codec:"messageBody" json:"messageBody"`
 	SenderUsername        string                      `codec:"senderUsername" json:"senderUsername"`
 	SenderDeviceName      string                      `codec:"senderDeviceName" json:"senderDeviceName"`
-	SenderDeviceType      string                      `codec:"senderDeviceType" json:"senderDeviceType"`
+	SenderDeviceType      keybase1.DeviceTypeV2       `codec:"senderDeviceType" json:"senderDeviceType"`
 	BodyHash              Hash                        `codec:"bodyHash" json:"bodyHash"`
 	HeaderHash            Hash                        `codec:"headerHash" json:"headerHash"`
 	HeaderSignature       *SignatureInfo              `codec:"headerSignature,omitempty" json:"headerSignature,omitempty"`
@@ -2851,6 +2912,7 @@ type MessageUnboxedValid struct {
 	ChannelNameMentions   []ChannelNameMention        `codec:"channelNameMentions" json:"channelNameMentions"`
 	Reactions             ReactionMap                 `codec:"reactions" json:"reactions"`
 	Unfurls               map[MessageID]UnfurlResult  `codec:"unfurls" json:"unfurls"`
+	Emojis                []HarvestedEmoji            `codec:"emojis" json:"emojis"`
 	ReplyTo               *MessageUnboxed             `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
 	BotUsername           string                      `codec:"botUsername" json:"botUsername"`
 }
@@ -2862,7 +2924,7 @@ func (o MessageUnboxedValid) DeepCopy() MessageUnboxedValid {
 		MessageBody:      o.MessageBody.DeepCopy(),
 		SenderUsername:   o.SenderUsername,
 		SenderDeviceName: o.SenderDeviceName,
-		SenderDeviceType: o.SenderDeviceType,
+		SenderDeviceType: o.SenderDeviceType.DeepCopy(),
 		BodyHash:         o.BodyHash.DeepCopy(),
 		HeaderHash:       o.HeaderHash.DeepCopy(),
 		HeaderSignature: (func(x *SignatureInfo) *SignatureInfo {
@@ -2949,6 +3011,17 @@ func (o MessageUnboxedValid) DeepCopy() MessageUnboxedValid {
 			}
 			return ret
 		})(o.Unfurls),
+		Emojis: (func(x []HarvestedEmoji) []HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]HarvestedEmoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 		ReplyTo: (func(x *MessageUnboxed) *MessageUnboxed {
 			if x == nil {
 				return nil
@@ -3007,7 +3080,7 @@ type MessageUnboxedError struct {
 	IsCritical       bool                    `codec:"isCritical" json:"isCritical"`
 	SenderUsername   string                  `codec:"senderUsername" json:"senderUsername"`
 	SenderDeviceName string                  `codec:"senderDeviceName" json:"senderDeviceName"`
-	SenderDeviceType string                  `codec:"senderDeviceType" json:"senderDeviceType"`
+	SenderDeviceType keybase1.DeviceTypeV2   `codec:"senderDeviceType" json:"senderDeviceType"`
 	MessageID        MessageID               `codec:"messageID" json:"messageID"`
 	MessageType      MessageType             `codec:"messageType" json:"messageType"`
 	Ctime            gregor1.Time            `codec:"ctime" json:"ctime"`
@@ -3027,7 +3100,7 @@ func (o MessageUnboxedError) DeepCopy() MessageUnboxedError {
 		IsCritical:       o.IsCritical,
 		SenderUsername:   o.SenderUsername,
 		SenderDeviceName: o.SenderDeviceName,
-		SenderDeviceType: o.SenderDeviceType,
+		SenderDeviceType: o.SenderDeviceType.DeepCopy(),
 		MessageID:        o.MessageID.DeepCopy(),
 		MessageType:      o.MessageType.DeepCopy(),
 		Ctime:            o.Ctime.DeepCopy(),
@@ -3344,6 +3417,7 @@ type ConversationInfoLocal struct {
 	TlfName        string                         `codec:"tlfName" json:"tlfName"`
 	TopicName      string                         `codec:"topicName" json:"topicName"`
 	Headline       string                         `codec:"headline" json:"headline"`
+	HeadlineEmojis []HarvestedEmoji               `codec:"headlineEmojis" json:"headlineEmojis"`
 	SnippetMsg     *MessageUnboxed                `codec:"snippetMsg,omitempty" json:"snippetMsg,omitempty"`
 	PinnedMsg      *ConversationPinnedMessage     `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"`
 	Draft          *string                        `codec:"draft,omitempty" json:"draft,omitempty"`
@@ -3368,6 +3442,17 @@ func (o ConversationInfoLocal) DeepCopy() ConversationInfoLocal {
 		TlfName:   o.TlfName,
 		TopicName: o.TopicName,
 		Headline:  o.Headline,
+		HeadlineEmojis: (func(x []HarvestedEmoji) []HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]HarvestedEmoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.HeadlineEmojis),
 		SnippetMsg: (func(x *MessageUnboxed) *MessageUnboxed {
 			if x == nil {
 				return nil
@@ -4366,6 +4451,98 @@ func (o SetConversationStatusLocalRes) DeepCopy() SetConversationStatusLocalRes
 	}
 }
 
+type NewConversationsLocalRes struct {
+	Results          []NewConversationsLocalResult `codec:"results" json:"results"`
+	RateLimits       []RateLimit                   `codec:"rateLimits" json:"rateLimits"`
+	IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"`
+}
+
+func (o NewConversationsLocalRes) DeepCopy() NewConversationsLocalRes {
+	return NewConversationsLocalRes{
+		Results: (func(x []NewConversationsLocalResult) []NewConversationsLocalResult {
+			if x == nil {
+				return nil
+			}
+			ret := make([]NewConversationsLocalResult, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Results),
+		RateLimits: (func(x []RateLimit) []RateLimit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RateLimit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RateLimits),
+		IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.TLFIdentifyFailure, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.IdentifyFailures),
+	}
+}
+
+type NewConversationsLocalResult struct {
+	Result *NewConversationLocalRes `codec:"result,omitempty" json:"result,omitempty"`
+	Err    *string                  `codec:"err,omitempty" json:"err,omitempty"`
+}
+
+func (o NewConversationsLocalResult) DeepCopy() NewConversationsLocalResult {
+	return NewConversationsLocalResult{
+		Result: (func(x *NewConversationLocalRes) *NewConversationLocalRes {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Result),
+		Err: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Err),
+	}
+}
+
+type NewConversationLocalArgument struct {
+	TlfName       string                  `codec:"tlfName" json:"tlfName"`
+	TopicType     TopicType               `codec:"topicType" json:"topicType"`
+	TlfVisibility keybase1.TLFVisibility  `codec:"tlfVisibility" json:"tlfVisibility"`
+	TopicName     *string                 `codec:"topicName,omitempty" json:"topicName,omitempty"`
+	MembersType   ConversationMembersType `codec:"membersType" json:"membersType"`
+}
+
+func (o NewConversationLocalArgument) DeepCopy() NewConversationLocalArgument {
+	return NewConversationLocalArgument{
+		TlfName:       o.TlfName,
+		TopicType:     o.TopicType.DeepCopy(),
+		TlfVisibility: o.TlfVisibility.DeepCopy(),
+		TopicName: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.TopicName),
+		MembersType: o.MembersType.DeepCopy(),
+	}
+}
+
 type NewConversationLocalRes struct {
 	Conv             ConversationLocal             `codec:"conv" json:"conv"`
 	UiConv           InboxUIItem                   `codec:"uiConv" json:"uiConv"`
@@ -5121,6 +5298,74 @@ func (o GetTLFConversationsLocalRes) DeepCopy() GetTLFConversationsLocalRes {
 	}
 }
 
+type GetChannelMembershipsLocalRes struct {
+	Channels   []ChannelNameMention `codec:"channels" json:"channels"`
+	Offline    bool                 `codec:"offline" json:"offline"`
+	RateLimits []RateLimit          `codec:"rateLimits" json:"rateLimits"`
+}
+
+func (o GetChannelMembershipsLocalRes) DeepCopy() GetChannelMembershipsLocalRes {
+	return GetChannelMembershipsLocalRes{
+		Channels: (func(x []ChannelNameMention) []ChannelNameMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChannelNameMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Channels),
+		Offline: o.Offline,
+		RateLimits: (func(x []RateLimit) []RateLimit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RateLimit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RateLimits),
+	}
+}
+
+type GetMutualTeamsLocalRes struct {
+	TeamIDs    []keybase1.TeamID `codec:"teamIDs" json:"teamIDs"`
+	Offline    bool              `codec:"offline" json:"offline"`
+	RateLimits []RateLimit       `codec:"rateLimits" json:"rateLimits"`
+}
+
+func (o GetMutualTeamsLocalRes) DeepCopy() GetMutualTeamsLocalRes {
+	return GetMutualTeamsLocalRes{
+		TeamIDs: (func(x []keybase1.TeamID) []keybase1.TeamID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.TeamID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.TeamIDs),
+		Offline: o.Offline,
+		RateLimits: (func(x []RateLimit) []RateLimit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RateLimit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RateLimits),
+	}
+}
+
 type SetAppNotificationSettingsLocalRes struct {
 	Offline    bool        `codec:"offline" json:"offline"`
 	RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"`
@@ -5291,6 +5536,34 @@ func (o SearchInboxRes) DeepCopy() SearchInboxRes {
 	}
 }
 
+type SimpleSearchInboxConvNamesHit struct {
+	Name    string         `codec:"name" json:"name"`
+	ConvID  ConversationID `codec:"convID" json:"convID"`
+	IsTeam  bool           `codec:"isTeam" json:"isTeam"`
+	Parts   []string       `codec:"parts" json:"parts"`
+	TlfName string         `codec:"tlfName" json:"tlfName"`
+}
+
+func (o SimpleSearchInboxConvNamesHit) DeepCopy() SimpleSearchInboxConvNamesHit {
+	return SimpleSearchInboxConvNamesHit{
+		Name:   o.Name,
+		ConvID: o.ConvID.DeepCopy(),
+		IsTeam: o.IsTeam,
+		Parts: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Parts),
+		TlfName: o.TlfName,
+	}
+}
+
 type ProfileSearchConvStats struct {
 	Err            string               `codec:"err" json:"err"`
 	ConvName       string               `codec:"convName" json:"convName"`
@@ -5675,6 +5948,7 @@ type AdvertiseCommandsParam struct {
 	Typ      BotCommandsAdvertisementTyp `codec:"typ" json:"typ"`
 	Commands []UserBotCommandInput       `codec:"commands" json:"commands"`
 	TeamName *string                     `codec:"teamName,omitempty" json:"teamName,omitempty"`
+	ConvID   *ConversationID             `codec:"convID,omitempty" json:"convID,omitempty"`
 }
 
 func (o AdvertiseCommandsParam) DeepCopy() AdvertiseCommandsParam {
@@ -5698,6 +5972,13 @@ func (o AdvertiseCommandsParam) DeepCopy() AdvertiseCommandsParam {
 			tmp := (*x)
 			return &tmp
 		})(o.TeamName),
+		ConvID: (func(x *ConversationID) *ConversationID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ConvID),
 	}
 }
 
@@ -5886,3 +6167,290 @@ func (e SnippetDecoration) String() string {
 	}
 	return fmt.Sprintf("%v", int(e))
 }
+
+type WelcomeMessageDisplay struct {
+	Set     bool   `codec:"set" json:"set"`
+	Display string `codec:"display" json:"display"`
+	Raw     string `codec:"raw" json:"raw"`
+}
+
+func (o WelcomeMessageDisplay) DeepCopy() WelcomeMessageDisplay {
+	return WelcomeMessageDisplay{
+		Set:     o.Set,
+		Display: o.Display,
+		Raw:     o.Raw,
+	}
+}
+
+type WelcomeMessage struct {
+	Set bool   `codec:"set" json:"set"`
+	Raw string `codec:"raw" json:"raw"`
+}
+
+func (o WelcomeMessage) DeepCopy() WelcomeMessage {
+	return WelcomeMessage{
+		Set: o.Set,
+		Raw: o.Raw,
+	}
+}
+
+type GetDefaultTeamChannelsLocalRes struct {
+	Convs     []InboxUIItem `codec:"convs" json:"convs"`
+	RateLimit *RateLimit    `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetDefaultTeamChannelsLocalRes) DeepCopy() GetDefaultTeamChannelsLocalRes {
+	return GetDefaultTeamChannelsLocalRes{
+		Convs: (func(x []InboxUIItem) []InboxUIItem {
+			if x == nil {
+				return nil
+			}
+			ret := make([]InboxUIItem, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Convs),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type SetDefaultTeamChannelsLocalRes struct {
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o SetDefaultTeamChannelsLocalRes) DeepCopy() SetDefaultTeamChannelsLocalRes {
+	return SetDefaultTeamChannelsLocalRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type LastActiveTimeAll struct {
+	Teams    map[TLFIDStr]gregor1.Time  `codec:"teams" json:"teams"`
+	Channels map[ConvIDStr]gregor1.Time `codec:"channels" json:"channels"`
+}
+
+func (o LastActiveTimeAll) DeepCopy() LastActiveTimeAll {
+	return LastActiveTimeAll{
+		Teams: (func(x map[TLFIDStr]gregor1.Time) map[TLFIDStr]gregor1.Time {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[TLFIDStr]gregor1.Time, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Teams),
+		Channels: (func(x map[ConvIDStr]gregor1.Time) map[ConvIDStr]gregor1.Time {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[ConvIDStr]gregor1.Time, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Channels),
+	}
+}
+
+type LastActiveStatusAll struct {
+	Teams    map[TLFIDStr]LastActiveStatus  `codec:"teams" json:"teams"`
+	Channels map[ConvIDStr]LastActiveStatus `codec:"channels" json:"channels"`
+}
+
+func (o LastActiveStatusAll) DeepCopy() LastActiveStatusAll {
+	return LastActiveStatusAll{
+		Teams: (func(x map[TLFIDStr]LastActiveStatus) map[TLFIDStr]LastActiveStatus {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[TLFIDStr]LastActiveStatus, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Teams),
+		Channels: (func(x map[ConvIDStr]LastActiveStatus) map[ConvIDStr]LastActiveStatus {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[ConvIDStr]LastActiveStatus, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Channels),
+	}
+}
+
+type EmojiError struct {
+	Clidisplay string `codec:"clidisplay" json:"clidisplay"`
+	Uidisplay  string `codec:"uidisplay" json:"uidisplay"`
+}
+
+func (o EmojiError) DeepCopy() EmojiError {
+	return EmojiError{
+		Clidisplay: o.Clidisplay,
+		Uidisplay:  o.Uidisplay,
+	}
+}
+
+type AddEmojiRes struct {
+	RateLimit *RateLimit  `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	Error     *EmojiError `codec:"error,omitempty" json:"error,omitempty"`
+}
+
+func (o AddEmojiRes) DeepCopy() AddEmojiRes {
+	return AddEmojiRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+		Error: (func(x *EmojiError) *EmojiError {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Error),
+	}
+}
+
+type AddEmojisRes struct {
+	RateLimit        *RateLimit            `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	SuccessFilenames []string              `codec:"successFilenames" json:"successFilenames"`
+	FailedFilenames  map[string]EmojiError `codec:"failedFilenames" json:"failedFilenames"`
+}
+
+func (o AddEmojisRes) DeepCopy() AddEmojisRes {
+	return AddEmojisRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+		SuccessFilenames: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.SuccessFilenames),
+		FailedFilenames: (func(x map[string]EmojiError) map[string]EmojiError {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]EmojiError, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.FailedFilenames),
+	}
+}
+
+type AddEmojiAliasRes struct {
+	RateLimit *RateLimit  `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	Error     *EmojiError `codec:"error,omitempty" json:"error,omitempty"`
+}
+
+func (o AddEmojiAliasRes) DeepCopy() AddEmojiAliasRes {
+	return AddEmojiAliasRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+		Error: (func(x *EmojiError) *EmojiError {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Error),
+	}
+}
+
+type RemoveEmojiRes struct {
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o RemoveEmojiRes) DeepCopy() RemoveEmojiRes {
+	return RemoveEmojiRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type UserEmojiRes struct {
+	Emojis    UserEmojis `codec:"emojis" json:"emojis"`
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o UserEmojiRes) DeepCopy() UserEmojiRes {
+	return UserEmojiRes{
+		Emojis: o.Emojis.DeepCopy(),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type EmojiFetchOpts struct {
+	GetCreationInfo bool `codec:"getCreationInfo" json:"getCreationInfo"`
+	GetAliases      bool `codec:"getAliases" json:"getAliases"`
+	OnlyInTeam      bool `codec:"onlyInTeam" json:"onlyInTeam"`
+}
+
+func (o EmojiFetchOpts) DeepCopy() EmojiFetchOpts {
+	return EmojiFetchOpts{
+		GetCreationInfo: o.GetCreationInfo,
+		GetAliases:      o.GetAliases,
+		OnlyInTeam:      o.OnlyInTeam,
+	}
+}

v2/types/chat1/notify.go

@@ -1,12 +1,13 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/notify.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/notify.avdl
 
 package chat1
 
 import (
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
 	"errors"
 	"fmt"
+
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
 )
 
 type ChatActivitySource int
@@ -323,7 +324,7 @@ func (o EphemeralPurgeNotifInfo) DeepCopy() EphemeralPurgeNotifInfo {
 }
 
 type ReactionUpdate struct {
-	Reactions   ReactionMap `codec:"reactions" json:"reactions"`
+	Reactions   UIReactionMap `codec:"reactions" json:"reactions"`
 	TargetMsgID MessageID     `codec:"targetMsgID" json:"targetMsgID"`
 }
 
@@ -760,8 +761,6 @@ type TyperInfo struct {
 	Uid      keybase1.UID      `codec:"uid" json:"uid"`
 	Username string            `codec:"username" json:"username"`
 	DeviceID keybase1.DeviceID `codec:"deviceID" json:"deviceID"`
-	DeviceName string            `codec:"deviceName" json:"deviceName"`
-	DeviceType string            `codec:"deviceType" json:"deviceType"`
 }
 
 func (o TyperInfo) DeepCopy() TyperInfo {
@@ -769,8 +768,6 @@ func (o TyperInfo) DeepCopy() TyperInfo {
 		Uid:      o.Uid.DeepCopy(),
 		Username: o.Username,
 		DeviceID: o.DeviceID.DeepCopy(),
-		DeviceName: o.DeviceName,
-		DeviceType: o.DeviceType,
 	}
 }
 

v2/types/chat1/remote.go

@@ -1,13 +1,14 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/remote.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/remote.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
-	keybase1 "samhofi.us/x/keybase/types/keybase1"
 	"errors"
 	"fmt"
+
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
+	keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
 )
 
 type MessageBoxed struct {
@@ -232,6 +233,8 @@ func (o NewConversationRemoteRes) DeepCopy() NewConversationRemoteRes {
 
 type GetMessagesRemoteRes struct {
 	Msgs        []MessageBoxed          `codec:"msgs" json:"msgs"`
+	MembersType ConversationMembersType `codec:"membersType" json:"membersType"`
+	Visibility  keybase1.TLFVisibility  `codec:"visibility" json:"visibility"`
 	RateLimit   *RateLimit              `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
 }
 
@@ -248,6 +251,8 @@ func (o GetMessagesRemoteRes) DeepCopy() GetMessagesRemoteRes {
 			}
 			return ret
 		})(o.Msgs),
+		MembersType: o.MembersType.DeepCopy(),
+		Visibility:  o.Visibility.DeepCopy(),
 		RateLimit: (func(x *RateLimit) *RateLimit {
 			if x == nil {
 				return nil
@@ -961,11 +966,24 @@ func (o RemoteBotCommandsAdvertisementTLFID) DeepCopy() RemoteBotCommandsAdverti
 	}
 }
 
+type RemoteBotCommandsAdvertisementConv struct {
+	ConvID          ConversationID `codec:"convID" json:"convID"`
+	AdvertiseConvID ConversationID `codec:"advertiseConvID" json:"advertiseConvID"`
+}
+
+func (o RemoteBotCommandsAdvertisementConv) DeepCopy() RemoteBotCommandsAdvertisementConv {
+	return RemoteBotCommandsAdvertisementConv{
+		ConvID:          o.ConvID.DeepCopy(),
+		AdvertiseConvID: o.AdvertiseConvID.DeepCopy(),
+	}
+}
+
 type RemoteBotCommandsAdvertisement struct {
 	Typ__          BotCommandsAdvertisementTyp           `codec:"typ" json:"typ"`
 	Public__       *RemoteBotCommandsAdvertisementPublic `codec:"public,omitempty" json:"public,omitempty"`
 	TlfidMembers__ *RemoteBotCommandsAdvertisementTLFID  `codec:"tlfidMembers,omitempty" json:"tlfidMembers,omitempty"`
 	TlfidConvs__   *RemoteBotCommandsAdvertisementTLFID  `codec:"tlfidConvs,omitempty" json:"tlfidConvs,omitempty"`
+	Conv__         *RemoteBotCommandsAdvertisementConv   `codec:"conv,omitempty" json:"conv,omitempty"`
 }
 
 func (o *RemoteBotCommandsAdvertisement) Typ() (ret BotCommandsAdvertisementTyp, err error) {
@@ -985,6 +1003,11 @@ func (o *RemoteBotCommandsAdvertisement) Typ() (ret BotCommandsAdvertisementTyp,
 			err = errors.New("unexpected nil value for TlfidConvs__")
 			return ret, err
 		}
+	case BotCommandsAdvertisementTyp_CONV:
+		if o.Conv__ == nil {
+			err = errors.New("unexpected nil value for Conv__")
+			return ret, err
+		}
 	}
 	return o.Typ__, nil
 }
@@ -1019,6 +1042,16 @@ func (o RemoteBotCommandsAdvertisement) TlfidConvs() (res RemoteBotCommandsAdver
 	return *o.TlfidConvs__
 }
 
+func (o RemoteBotCommandsAdvertisement) Conv() (res RemoteBotCommandsAdvertisementConv) {
+	if o.Typ__ != BotCommandsAdvertisementTyp_CONV {
+		panic("wrong case accessed")
+	}
+	if o.Conv__ == nil {
+		return
+	}
+	return *o.Conv__
+}
+
 func NewRemoteBotCommandsAdvertisementWithPublic(v RemoteBotCommandsAdvertisementPublic) RemoteBotCommandsAdvertisement {
 	return RemoteBotCommandsAdvertisement{
 		Typ__:    BotCommandsAdvertisementTyp_PUBLIC,
@@ -1040,6 +1073,13 @@ func NewRemoteBotCommandsAdvertisementWithTlfidConvs(v RemoteBotCommandsAdvertis
 	}
 }
 
+func NewRemoteBotCommandsAdvertisementWithConv(v RemoteBotCommandsAdvertisementConv) RemoteBotCommandsAdvertisement {
+	return RemoteBotCommandsAdvertisement{
+		Typ__:  BotCommandsAdvertisementTyp_CONV,
+		Conv__: &v,
+	}
+}
+
 func (o RemoteBotCommandsAdvertisement) DeepCopy() RemoteBotCommandsAdvertisement {
 	return RemoteBotCommandsAdvertisement{
 		Typ__: o.Typ__.DeepCopy(),
@@ -1064,6 +1104,13 @@ func (o RemoteBotCommandsAdvertisement) DeepCopy() RemoteBotCommandsAdvertisemen
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.TlfidConvs__),
+		Conv__: (func(x *RemoteBotCommandsAdvertisementConv) *RemoteBotCommandsAdvertisementConv {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Conv__),
 	}
 }
 
@@ -1247,3 +1294,155 @@ func (o BotInfoHash) DeepCopy() BotInfoHash {
 		return append([]byte{}, x...)
 	})(o)
 }
+
+type GetDefaultTeamChannelsRes struct {
+	Convs     []ConversationID `codec:"convs" json:"convs"`
+	RateLimit *RateLimit       `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetDefaultTeamChannelsRes) DeepCopy() GetDefaultTeamChannelsRes {
+	return GetDefaultTeamChannelsRes{
+		Convs: (func(x []ConversationID) []ConversationID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ConversationID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Convs),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type SetDefaultTeamChannelsRes struct {
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o SetDefaultTeamChannelsRes) DeepCopy() SetDefaultTeamChannelsRes {
+	return SetDefaultTeamChannelsRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type GetRecentJoinsRes struct {
+	NumJoins  int        `codec:"numJoins" json:"numJoins"`
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetRecentJoinsRes) DeepCopy() GetRecentJoinsRes {
+	return GetRecentJoinsRes{
+		NumJoins: o.NumJoins,
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type RefreshParticipantsRemoteRes struct {
+	HashMatch bool          `codec:"hashMatch" json:"hashMatch"`
+	Uids      []gregor1.UID `codec:"uids" json:"uids"`
+	Hash      string        `codec:"hash" json:"hash"`
+	RateLimit *RateLimit    `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o RefreshParticipantsRemoteRes) DeepCopy() RefreshParticipantsRemoteRes {
+	return RefreshParticipantsRemoteRes{
+		HashMatch: o.HashMatch,
+		Uids: (func(x []gregor1.UID) []gregor1.UID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]gregor1.UID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Uids),
+		Hash: o.Hash,
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type GetLastActiveAtRes struct {
+	LastActiveAt gregor1.Time `codec:"lastActiveAt" json:"lastActiveAt"`
+	RateLimit    *RateLimit   `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetLastActiveAtRes) DeepCopy() GetLastActiveAtRes {
+	return GetLastActiveAtRes{
+		LastActiveAt: o.LastActiveAt.DeepCopy(),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type ResetConversationMember struct {
+	ConvID ConversationID `codec:"convID" json:"convID"`
+	Uid    gregor1.UID    `codec:"uid" json:"uid"`
+}
+
+func (o ResetConversationMember) DeepCopy() ResetConversationMember {
+	return ResetConversationMember{
+		ConvID: o.ConvID.DeepCopy(),
+		Uid:    o.Uid.DeepCopy(),
+	}
+}
+
+type GetResetConversationsRes struct {
+	ResetConvs []ResetConversationMember `codec:"resetConvs" json:"resetConvs"`
+	RateLimit  *RateLimit                `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetResetConversationsRes) DeepCopy() GetResetConversationsRes {
+	return GetResetConversationsRes{
+		ResetConvs: (func(x []ResetConversationMember) []ResetConversationMember {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ResetConversationMember, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.ResetConvs),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}

v2/types/chat1/unfurl.go

@@ -1,12 +1,13 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/chat1/unfurl.avdl
+//   Input file: ../../../../../../client/protocol/avdl/chat1/unfurl.avdl
 
 package chat1
 
 import (
-	gregor1 "samhofi.us/x/keybase/types/gregor1"
 	"errors"
 	"fmt"
+
+	gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
 )
 
 type UnfurlType int

v2/types/gregor1/auth.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/auth.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/auth.avdl
 
 package gregor1
 

v2/types/gregor1/auth_internal.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/auth_internal.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/auth_internal.avdl
 
 package gregor1

v2/types/gregor1/auth_update.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/auth_update.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/auth_update.avdl
 
 package gregor1

v2/types/gregor1/common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/common.avdl
 
 package gregor1
 

v2/types/gregor1/incoming.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/incoming.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/incoming.avdl
 
 package gregor1
 

v2/types/gregor1/outgoing.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/outgoing.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/outgoing.avdl
 
 package gregor1

v2/types/gregor1/remind.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/gregor1/remind.avdl
+//   Input file: ../../../../../../client/protocol/avdl/gregor1/remind.avdl
 
 package gregor1

v2/types/keybase1/account.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/account.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/account.avdl
 
 package keybase1
 

v2/types/keybase1/airdrop.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/airdrop.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/airdrop.avdl
 
 package keybase1
 

v2/types/keybase1/apiserver.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/apiserver.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/apiserver.avdl
 
 package keybase1
 

v2/types/keybase1/appstate.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/appstate.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/appstate.avdl
 
 package keybase1
 

v2/types/keybase1/audit.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/audit.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/audit.avdl
 
 package keybase1
 

v2/types/keybase1/avatars.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/avatars.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/avatars.avdl
 
 package keybase1
 

v2/types/keybase1/backend_common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/backend_common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/backend_common.avdl
 
 package keybase1
 

v2/types/keybase1/badger.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/badger.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/badger.avdl
 
 package keybase1

v2/types/keybase1/block.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/block.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/block.avdl
 
 package keybase1
 
@@ -57,6 +57,38 @@ func (o GetBlockRes) DeepCopy() GetBlockRes {
 	}
 }
 
+type GetBlockSizesRes struct {
+	Sizes    []int         `codec:"sizes" json:"sizes"`
+	Statuses []BlockStatus `codec:"statuses" json:"statuses"`
+}
+
+func (o GetBlockSizesRes) DeepCopy() GetBlockSizesRes {
+	return GetBlockSizesRes{
+		Sizes: (func(x []int) []int {
+			if x == nil {
+				return nil
+			}
+			ret := make([]int, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Sizes),
+		Statuses: (func(x []BlockStatus) []BlockStatus {
+			if x == nil {
+				return nil
+			}
+			ret := make([]BlockStatus, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Statuses),
+	}
+}
+
 type BlockRefNonce [8]byte
 
 func (o BlockRefNonce) DeepCopy() BlockRefNonce {
@@ -151,3 +183,75 @@ type BlockPingResponse struct {
 func (o BlockPingResponse) DeepCopy() BlockPingResponse {
 	return BlockPingResponse{}
 }
+
+type UsageStatRecord struct {
+	Write      int64 `codec:"write" json:"write"`
+	Archive    int64 `codec:"archive" json:"archive"`
+	Read       int64 `codec:"read" json:"read"`
+	MdWrite    int64 `codec:"mdWrite" json:"mdWrite"`
+	GitWrite   int64 `codec:"gitWrite" json:"gitWrite"`
+	GitArchive int64 `codec:"gitArchive" json:"gitArchive"`
+}
+
+func (o UsageStatRecord) DeepCopy() UsageStatRecord {
+	return UsageStatRecord{
+		Write:      o.Write,
+		Archive:    o.Archive,
+		Read:       o.Read,
+		MdWrite:    o.MdWrite,
+		GitWrite:   o.GitWrite,
+		GitArchive: o.GitArchive,
+	}
+}
+
+type UsageStat struct {
+	Bytes  UsageStatRecord `codec:"bytes" json:"bytes"`
+	Blocks UsageStatRecord `codec:"blocks" json:"blocks"`
+	Mtime  Time            `codec:"mtime" json:"mtime"`
+}
+
+func (o UsageStat) DeepCopy() UsageStat {
+	return UsageStat{
+		Bytes:  o.Bytes.DeepCopy(),
+		Blocks: o.Blocks.DeepCopy(),
+		Mtime:  o.Mtime.DeepCopy(),
+	}
+}
+
+type FolderUsageStat struct {
+	FolderID string    `codec:"folderID" json:"folderID"`
+	Stats    UsageStat `codec:"stats" json:"stats"`
+}
+
+func (o FolderUsageStat) DeepCopy() FolderUsageStat {
+	return FolderUsageStat{
+		FolderID: o.FolderID,
+		Stats:    o.Stats.DeepCopy(),
+	}
+}
+
+type BlockQuotaInfo struct {
+	Folders  []FolderUsageStat `codec:"folders" json:"folders"`
+	Total    UsageStat         `codec:"total" json:"total"`
+	Limit    int64             `codec:"limit" json:"limit"`
+	GitLimit int64             `codec:"gitLimit" json:"gitLimit"`
+}
+
+func (o BlockQuotaInfo) DeepCopy() BlockQuotaInfo {
+	return BlockQuotaInfo{
+		Folders: (func(x []FolderUsageStat) []FolderUsageStat {
+			if x == nil {
+				return nil
+			}
+			ret := make([]FolderUsageStat, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Folders),
+		Total:    o.Total.DeepCopy(),
+		Limit:    o.Limit,
+		GitLimit: o.GitLimit,
+	}
+}

v2/types/keybase1/bot.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/bot.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/bot.avdl
 
 package keybase1
 

v2/types/keybase1/btc.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/btc.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/btc.avdl
 
 package keybase1

v2/types/keybase1/common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/common.avdl
 
 package keybase1
 
@@ -26,6 +26,12 @@ func (o DurationSec) DeepCopy() DurationSec {
 	return o
 }
 
+type DurationMsec float64
+
+func (o DurationMsec) DeepCopy() DurationMsec {
+	return o
+}
+
 type StringKVPair struct {
 	Key   string `codec:"key" json:"key"`
 	Value string `codec:"value" json:"value"`
@@ -432,7 +438,7 @@ type PublicKey struct {
 	ParentID          string        `codec:"parentID" json:"parentID"`
 	DeviceID          DeviceID      `codec:"deviceID" json:"deviceID"`
 	DeviceDescription string        `codec:"deviceDescription" json:"deviceDescription"`
-	DeviceType        string        `codec:"deviceType" json:"deviceType"`
+	DeviceType        DeviceTypeV2  `codec:"deviceType" json:"deviceType"`
 	CTime             Time          `codec:"cTime" json:"cTime"`
 	ETime             Time          `codec:"eTime" json:"eTime"`
 	IsRevoked         bool          `codec:"isRevoked" json:"isRevoked"`
@@ -458,7 +464,7 @@ func (o PublicKey) DeepCopy() PublicKey {
 		ParentID:          o.ParentID,
 		DeviceID:          o.DeviceID.DeepCopy(),
 		DeviceDescription: o.DeviceDescription,
-		DeviceType:        o.DeviceType,
+		DeviceType:        o.DeviceType.DeepCopy(),
 		CTime:             o.CTime.DeepCopy(),
 		ETime:             o.ETime.DeepCopy(),
 		IsRevoked:         o.IsRevoked,
@@ -504,7 +510,7 @@ func (o User) DeepCopy() User {
 }
 
 type Device struct {
-	Type               string   `codec:"type" json:"type"`
+	Type               DeviceTypeV2 `codec:"type" json:"type"`
 	Name               string       `codec:"name" json:"name"`
 	DeviceID           DeviceID     `codec:"deviceID" json:"deviceID"`
 	DeviceNumberOfType int          `codec:"deviceNumberOfType" json:"deviceNumberOfType"`
@@ -518,7 +524,7 @@ type Device struct {
 
 func (o Device) DeepCopy() Device {
 	return Device{
-		Type:               o.Type,
+		Type:               o.Type.DeepCopy(),
 		Name:               o.Name,
 		DeviceID:           o.DeviceID.DeepCopy(),
 		DeviceNumberOfType: o.DeviceNumberOfType,
@@ -557,6 +563,12 @@ func (e DeviceType) String() string {
 	return fmt.Sprintf("%v", int(e))
 }
 
+type DeviceTypeV2 string
+
+func (o DeviceTypeV2) DeepCopy() DeviceTypeV2 {
+	return o
+}
+
 type Stream struct {
 	Fd int `codec:"fd" json:"fd"`
 }
@@ -1061,26 +1073,84 @@ func (e OfflineAvailability) String() string {
 	return fmt.Sprintf("%v", int(e))
 }
 
+type UserReacji struct {
+	Name             string  `codec:"name" json:"name"`
+	CustomAddr       *string `codec:"customAddr,omitempty" json:"customAddr,omitempty"`
+	CustomAddrNoAnim *string `codec:"customAddrNoAnim,omitempty" json:"customAddrNoAnim,omitempty"`
+}
+
+func (o UserReacji) DeepCopy() UserReacji {
+	return UserReacji{
+		Name: o.Name,
+		CustomAddr: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.CustomAddr),
+		CustomAddrNoAnim: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.CustomAddrNoAnim),
+	}
+}
+
 type ReacjiSkinTone int
 
-func (o ReacjiSkinTone) DeepCopy() ReacjiSkinTone {
+const (
-	return o
+	ReacjiSkinTone_NONE      ReacjiSkinTone = 0
+	ReacjiSkinTone_SKINTONE1 ReacjiSkinTone = 1
+	ReacjiSkinTone_SKINTONE2 ReacjiSkinTone = 2
+	ReacjiSkinTone_SKINTONE3 ReacjiSkinTone = 3
+	ReacjiSkinTone_SKINTONE4 ReacjiSkinTone = 4
+	ReacjiSkinTone_SKINTONE5 ReacjiSkinTone = 5
+)
+
+func (o ReacjiSkinTone) DeepCopy() ReacjiSkinTone { return o }
+
+var ReacjiSkinToneMap = map[string]ReacjiSkinTone{
+	"NONE":      0,
+	"SKINTONE1": 1,
+	"SKINTONE2": 2,
+	"SKINTONE3": 3,
+	"SKINTONE4": 4,
+	"SKINTONE5": 5,
+}
+
+var ReacjiSkinToneRevMap = map[ReacjiSkinTone]string{
+	0: "NONE",
+	1: "SKINTONE1",
+	2: "SKINTONE2",
+	3: "SKINTONE3",
+	4: "SKINTONE4",
+	5: "SKINTONE5",
+}
+
+func (e ReacjiSkinTone) String() string {
+	if v, ok := ReacjiSkinToneRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
 }
 
 type UserReacjis struct {
-	TopReacjis []string       `codec:"topReacjis" json:"topReacjis"`
+	TopReacjis []UserReacji   `codec:"topReacjis" json:"topReacjis"`
 	SkinTone   ReacjiSkinTone `codec:"skinTone" json:"skinTone"`
 }
 
 func (o UserReacjis) DeepCopy() UserReacjis {
 	return UserReacjis{
-		TopReacjis: (func(x []string) []string {
+		TopReacjis: (func(x []UserReacji) []UserReacji {
 			if x == nil {
 				return nil
 			}
-			ret := make([]string, len(x))
+			ret := make([]UserReacji, len(x))
 			for i, v := range x {
-				vCopy := v
+				vCopy := v.DeepCopy()
 				ret[i] = vCopy
 			}
 			return ret
@@ -1088,3 +1158,38 @@ func (o UserReacjis) DeepCopy() UserReacjis {
 		SkinTone: o.SkinTone.DeepCopy(),
 	}
 }
+
+type WotStatusType int
+
+const (
+	WotStatusType_NONE     WotStatusType = 0
+	WotStatusType_PROPOSED WotStatusType = 1
+	WotStatusType_ACCEPTED WotStatusType = 2
+	WotStatusType_REJECTED WotStatusType = 3
+	WotStatusType_REVOKED  WotStatusType = 4
+)
+
+func (o WotStatusType) DeepCopy() WotStatusType { return o }
+
+var WotStatusTypeMap = map[string]WotStatusType{
+	"NONE":     0,
+	"PROPOSED": 1,
+	"ACCEPTED": 2,
+	"REJECTED": 3,
+	"REVOKED":  4,
+}
+
+var WotStatusTypeRevMap = map[WotStatusType]string{
+	0: "NONE",
+	1: "PROPOSED",
+	2: "ACCEPTED",
+	3: "REJECTED",
+	4: "REVOKED",
+}
+
+func (e WotStatusType) String() string {
+	if v, ok := WotStatusTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}

v2/types/keybase1/config.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/config.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/config.avdl
 
 package keybase1
 
@@ -14,6 +14,7 @@ type CurrentStatus struct {
 	LoggedIn       bool   `codec:"loggedIn" json:"loggedIn"`
 	SessionIsValid bool   `codec:"sessionIsValid" json:"sessionIsValid"`
 	User           *User  `codec:"user,omitempty" json:"user,omitempty"`
+	DeviceName     string `codec:"deviceName" json:"deviceName"`
 }
 
 func (o CurrentStatus) DeepCopy() CurrentStatus {
@@ -29,6 +30,7 @@ func (o CurrentStatus) DeepCopy() CurrentStatus {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.User),
+		DeviceName: o.DeviceName,
 	}
 }
 
@@ -331,6 +333,7 @@ type KbServiceStatus struct {
 	Pid     string `codec:"pid" json:"pid"`
 	Log     string `codec:"log" json:"log"`
 	EkLog   string `codec:"ekLog" json:"ekLog"`
+	PerfLog string `codec:"perfLog" json:"perfLog"`
 }
 
 func (o KbServiceStatus) DeepCopy() KbServiceStatus {
@@ -340,6 +343,7 @@ func (o KbServiceStatus) DeepCopy() KbServiceStatus {
 		Pid:     o.Pid,
 		Log:     o.Log,
 		EkLog:   o.EkLog,
+		PerfLog: o.PerfLog,
 	}
 }
 
@@ -349,6 +353,7 @@ type KBFSStatus struct {
 	Running          bool   `codec:"running" json:"running"`
 	Pid              string `codec:"pid" json:"pid"`
 	Log              string `codec:"log" json:"log"`
+	PerfLog          string `codec:"perfLog" json:"perfLog"`
 	Mount            string `codec:"mount" json:"mount"`
 }
 
@@ -359,6 +364,7 @@ func (o KBFSStatus) DeepCopy() KBFSStatus {
 		Running:          o.Running,
 		Pid:              o.Pid,
 		Log:              o.Log,
+		PerfLog:          o.PerfLog,
 		Mount:            o.Mount,
 	}
 }
@@ -399,11 +405,13 @@ func (o StartStatus) DeepCopy() StartStatus {
 
 type GitStatus struct {
 	Log     string `codec:"log" json:"log"`
+	PerfLog string `codec:"perfLog" json:"perfLog"`
 }
 
 func (o GitStatus) DeepCopy() GitStatus {
 	return GitStatus{
 		Log:     o.Log,
+		PerfLog: o.PerfLog,
 	}
 }
 

v2/types/keybase1/constants.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/constants.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/constants.avdl
 
 package keybase1
 
@@ -12,6 +12,7 @@ type StatusCode int
 const (
 	StatusCode_SCOk                                        StatusCode = 0
 	StatusCode_SCInputError                                StatusCode = 100
+	StatusCode_SCAssertionParseError                       StatusCode = 101
 	StatusCode_SCLoginRequired                             StatusCode = 201
 	StatusCode_SCBadSession                                StatusCode = 202
 	StatusCode_SCBadLoginUserNotFound                      StatusCode = 203
@@ -34,11 +35,13 @@ const (
 	StatusCode_SCWrongCryptoFormat                         StatusCode = 279
 	StatusCode_SCDecryptionError                           StatusCode = 280
 	StatusCode_SCInvalidAddress                            StatusCode = 281
+	StatusCode_SCWrongCryptoMsgType                        StatusCode = 282
 	StatusCode_SCNoSession                                 StatusCode = 283
 	StatusCode_SCAccountReset                              StatusCode = 290
 	StatusCode_SCIdentifiesFailed                          StatusCode = 295
 	StatusCode_SCNoSpaceOnDevice                           StatusCode = 297
 	StatusCode_SCMerkleClientError                         StatusCode = 299
+	StatusCode_SCMerkleUpdateRoot                          StatusCode = 300
 	StatusCode_SCBadEmail                                  StatusCode = 472
 	StatusCode_SCRateLimit                                 StatusCode = 602
 	StatusCode_SCBadSignupUsernameTaken                    StatusCode = 701
@@ -69,6 +72,7 @@ const (
 	StatusCode_SCKeyDuplicateUpdate                        StatusCode = 921
 	StatusCode_SCSibkeyAlreadyExists                       StatusCode = 922
 	StatusCode_SCDecryptionKeyNotFound                     StatusCode = 924
+	StatusCode_SCVerificationKeyNotFound                   StatusCode = 925
 	StatusCode_SCKeyNoPGPEncryption                        StatusCode = 927
 	StatusCode_SCKeyNoNaClEncryption                       StatusCode = 928
 	StatusCode_SCKeySyncedPGPNotFound                      StatusCode = 929
@@ -102,6 +106,7 @@ const (
 	StatusCode_SCGenericAPIError                           StatusCode = 1600
 	StatusCode_SCAPINetworkError                           StatusCode = 1601
 	StatusCode_SCTimeout                                   StatusCode = 1602
+	StatusCode_SCKBFSClientTimeout                         StatusCode = 1603
 	StatusCode_SCProofError                                StatusCode = 1701
 	StatusCode_SCIdentificationExpired                     StatusCode = 1702
 	StatusCode_SCSelfNotFound                              StatusCode = 1703
@@ -143,6 +148,7 @@ const (
 	StatusCode_SCChatStalePreviousState                    StatusCode = 2518
 	StatusCode_SCChatEphemeralRetentionPolicyViolatedError StatusCode = 2519
 	StatusCode_SCChatUsersAlreadyInConversationError       StatusCode = 2520
+	StatusCode_SCChatBadConversationError                  StatusCode = 2521
 	StatusCode_SCTeamBadMembership                         StatusCode = 2604
 	StatusCode_SCTeamSelfNotOwner                          StatusCode = 2607
 	StatusCode_SCTeamNotFound                              StatusCode = 2614
@@ -153,6 +159,7 @@ const (
 	StatusCode_SCNoOp                                      StatusCode = 2638
 	StatusCode_SCTeamInviteBadCancel                       StatusCode = 2645
 	StatusCode_SCTeamInviteBadToken                        StatusCode = 2646
+	StatusCode_SCTeamBadNameReservedDB                     StatusCode = 2650
 	StatusCode_SCTeamTarDuplicate                          StatusCode = 2663
 	StatusCode_SCTeamTarNotFound                           StatusCode = 2664
 	StatusCode_SCTeamMemberExists                          StatusCode = 2665
@@ -243,6 +250,10 @@ const (
 	StatusCode_SCTeambotKeyOldBoxedGeneration              StatusCode = 3801
 	StatusCode_SCTeambotKeyBadGeneration                   StatusCode = 3802
 	StatusCode_SCAirdropRegisterFailedMisc                 StatusCode = 4207
+	StatusCode_SCSimpleFSNameExists                        StatusCode = 5101
+	StatusCode_SCSimpleFSDirNotEmpty                       StatusCode = 5102
+	StatusCode_SCSimpleFSNotExist                          StatusCode = 5103
+	StatusCode_SCSimpleFSNoAccess                          StatusCode = 5104
 )
 
 func (o StatusCode) DeepCopy() StatusCode { return o }
@@ -250,6 +261,7 @@ func (o StatusCode) DeepCopy() StatusCode { return o }
 var StatusCodeMap = map[string]StatusCode{
 	"SCOk":                        0,
 	"SCInputError":                100,
+	"SCAssertionParseError":       101,
 	"SCLoginRequired":             201,
 	"SCBadSession":                202,
 	"SCBadLoginUserNotFound":      203,
@@ -272,11 +284,13 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCWrongCryptoFormat":         279,
 	"SCDecryptionError":           280,
 	"SCInvalidAddress":            281,
+	"SCWrongCryptoMsgType":        282,
 	"SCNoSession":                 283,
 	"SCAccountReset":              290,
 	"SCIdentifiesFailed":          295,
 	"SCNoSpaceOnDevice":           297,
 	"SCMerkleClientError":         299,
+	"SCMerkleUpdateRoot":          300,
 	"SCBadEmail":                  472,
 	"SCRateLimit":                 602,
 	"SCBadSignupUsernameTaken":    701,
@@ -307,6 +321,7 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCKeyDuplicateUpdate":        921,
 	"SCSibkeyAlreadyExists":       922,
 	"SCDecryptionKeyNotFound":     924,
+	"SCVerificationKeyNotFound":   925,
 	"SCKeyNoPGPEncryption":        927,
 	"SCKeyNoNaClEncryption":       928,
 	"SCKeySyncedPGPNotFound":      929,
@@ -340,6 +355,7 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCGenericAPIError":           1600,
 	"SCAPINetworkError":           1601,
 	"SCTimeout":                   1602,
+	"SCKBFSClientTimeout":         1603,
 	"SCProofError":                1701,
 	"SCIdentificationExpired":     1702,
 	"SCSelfNotFound":              1703,
@@ -381,6 +397,7 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCChatStalePreviousState":    2518,
 	"SCChatEphemeralRetentionPolicyViolatedError": 2519,
 	"SCChatUsersAlreadyInConversationError":       2520,
+	"SCChatBadConversationError":                  2521,
 	"SCTeamBadMembership":                         2604,
 	"SCTeamSelfNotOwner":                          2607,
 	"SCTeamNotFound":                              2614,
@@ -391,6 +408,7 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCNoOp":                                      2638,
 	"SCTeamInviteBadCancel":                       2645,
 	"SCTeamInviteBadToken":                        2646,
+	"SCTeamBadNameReservedDB":                     2650,
 	"SCTeamTarDuplicate":                          2663,
 	"SCTeamTarNotFound":                           2664,
 	"SCTeamMemberExists":                          2665,
@@ -481,11 +499,16 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCTeambotKeyOldBoxedGeneration":              3801,
 	"SCTeambotKeyBadGeneration":                   3802,
 	"SCAirdropRegisterFailedMisc":                 4207,
+	"SCSimpleFSNameExists":                        5101,
+	"SCSimpleFSDirNotEmpty":                       5102,
+	"SCSimpleFSNotExist":                          5103,
+	"SCSimpleFSNoAccess":                          5104,
 }
 
 var StatusCodeRevMap = map[StatusCode]string{
 	0:    "SCOk",
 	100:  "SCInputError",
+	101:  "SCAssertionParseError",
 	201:  "SCLoginRequired",
 	202:  "SCBadSession",
 	203:  "SCBadLoginUserNotFound",
@@ -508,11 +531,13 @@ var StatusCodeRevMap = map[StatusCode]string{
 	279:  "SCWrongCryptoFormat",
 	280:  "SCDecryptionError",
 	281:  "SCInvalidAddress",
+	282:  "SCWrongCryptoMsgType",
 	283:  "SCNoSession",
 	290:  "SCAccountReset",
 	295:  "SCIdentifiesFailed",
 	297:  "SCNoSpaceOnDevice",
 	299:  "SCMerkleClientError",
+	300:  "SCMerkleUpdateRoot",
 	472:  "SCBadEmail",
 	602:  "SCRateLimit",
 	701:  "SCBadSignupUsernameTaken",
@@ -543,6 +568,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	921:  "SCKeyDuplicateUpdate",
 	922:  "SCSibkeyAlreadyExists",
 	924:  "SCDecryptionKeyNotFound",
+	925:  "SCVerificationKeyNotFound",
 	927:  "SCKeyNoPGPEncryption",
 	928:  "SCKeyNoNaClEncryption",
 	929:  "SCKeySyncedPGPNotFound",
@@ -576,6 +602,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	1600: "SCGenericAPIError",
 	1601: "SCAPINetworkError",
 	1602: "SCTimeout",
+	1603: "SCKBFSClientTimeout",
 	1701: "SCProofError",
 	1702: "SCIdentificationExpired",
 	1703: "SCSelfNotFound",
@@ -617,6 +644,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	2518: "SCChatStalePreviousState",
 	2519: "SCChatEphemeralRetentionPolicyViolatedError",
 	2520: "SCChatUsersAlreadyInConversationError",
+	2521: "SCChatBadConversationError",
 	2604: "SCTeamBadMembership",
 	2607: "SCTeamSelfNotOwner",
 	2614: "SCTeamNotFound",
@@ -627,6 +655,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	2638: "SCNoOp",
 	2645: "SCTeamInviteBadCancel",
 	2646: "SCTeamInviteBadToken",
+	2650: "SCTeamBadNameReservedDB",
 	2663: "SCTeamTarDuplicate",
 	2664: "SCTeamTarNotFound",
 	2665: "SCTeamMemberExists",
@@ -717,6 +746,10 @@ var StatusCodeRevMap = map[StatusCode]string{
 	3801: "SCTeambotKeyOldBoxedGeneration",
 	3802: "SCTeambotKeyBadGeneration",
 	4207: "SCAirdropRegisterFailedMisc",
+	5101: "SCSimpleFSNameExists",
+	5102: "SCSimpleFSDirNotEmpty",
+	5103: "SCSimpleFSNotExist",
+	5104: "SCSimpleFSNoAccess",
 }
 
 func (e StatusCode) String() string {

v2/types/keybase1/contacts.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/contacts.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/contacts.avdl
 
 package keybase1
 

v2/types/keybase1/crypto.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/crypto.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/crypto.avdl
 
 package keybase1
 

v2/types/keybase1/cryptocurrency.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/cryptocurrency.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/cryptocurrency.avdl
 
 package keybase1
 

v2/types/keybase1/ctl.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/ctl.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/ctl.avdl
 
 package keybase1
 

v2/types/keybase1/debugging.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/debugging.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/debugging.avdl
 
 package keybase1
 

v2/types/keybase1/delegate_ui_ctl.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/delegate_ui_ctl.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/delegate_ui_ctl.avdl
 
 package keybase1

v2/types/keybase1/device.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/device.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/device.avdl
 
 package keybase1
 

v2/types/keybase1/emails.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/emails.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/emails.avdl
 
 package keybase1
 

v2/types/keybase1/ephemeral.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/ephemeral.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/ephemeral.avdl
 
 package keybase1
 

v2/types/keybase1/favorite.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/favorite.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/favorite.avdl
 
 package keybase1
 

v2/types/keybase1/featured_bot.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/featured_bot.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/featured_bot.avdl
 
 package keybase1
 

v2/types/keybase1/fs.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/fs.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/fs.avdl
 
 package keybase1
 

v2/types/keybase1/git.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/git.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/git.avdl
 
 package keybase1
 

v2/types/keybase1/gpg_common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/gpg_common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/gpg_common.avdl
 
 package keybase1
 

v2/types/keybase1/gpg_ui.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/gpg_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/gpg_ui.avdl
 
 package keybase1
 

v2/types/keybase1/gregor.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/gregor.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/gregor.avdl
 
 package keybase1

v2/types/keybase1/gregor_ui.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/gregor_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/gregor_ui.avdl
 
 package keybase1
 

v2/types/keybase1/home.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/home.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/home.avdl
 
 package keybase1
 
@@ -298,19 +298,19 @@ const (
 	HomeScreenTodoType_PROOF                   HomeScreenTodoType = 2
 	HomeScreenTodoType_DEVICE                  HomeScreenTodoType = 3
 	HomeScreenTodoType_FOLLOW                  HomeScreenTodoType = 4
-	HomeScreenTodoType_CHAT                    HomeScreenTodoType = 5
 	HomeScreenTodoType_PAPERKEY                HomeScreenTodoType = 6
 	HomeScreenTodoType_TEAM                    HomeScreenTodoType = 7
 	HomeScreenTodoType_FOLDER                  HomeScreenTodoType = 8
 	HomeScreenTodoType_GIT_REPO                HomeScreenTodoType = 9
 	HomeScreenTodoType_TEAM_SHOWCASE           HomeScreenTodoType = 10
-	HomeScreenTodoType_AVATAR_USER             HomeScreenTodoType = 11
 	HomeScreenTodoType_AVATAR_TEAM             HomeScreenTodoType = 12
 	HomeScreenTodoType_ADD_PHONE_NUMBER        HomeScreenTodoType = 18
 	HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER HomeScreenTodoType = 19
 	HomeScreenTodoType_VERIFY_ALL_EMAIL        HomeScreenTodoType = 20
 	HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY HomeScreenTodoType = 21
 	HomeScreenTodoType_ADD_EMAIL               HomeScreenTodoType = 22
+	HomeScreenTodoType_AVATAR_USER             HomeScreenTodoType = 23
+	HomeScreenTodoType_CHAT                    HomeScreenTodoType = 24
 	HomeScreenTodoType_ANNONCEMENT_PLACEHOLDER HomeScreenTodoType = 10000
 )
 
@@ -322,19 +322,19 @@ var HomeScreenTodoTypeMap = map[string]HomeScreenTodoType{
 	"PROOF":                   2,
 	"DEVICE":                  3,
 	"FOLLOW":                  4,
-	"CHAT":                    5,
 	"PAPERKEY":                6,
 	"TEAM":                    7,
 	"FOLDER":                  8,
 	"GIT_REPO":                9,
 	"TEAM_SHOWCASE":           10,
-	"AVATAR_USER":             11,
 	"AVATAR_TEAM":             12,
 	"ADD_PHONE_NUMBER":        18,
 	"VERIFY_ALL_PHONE_NUMBER": 19,
 	"VERIFY_ALL_EMAIL":        20,
 	"LEGACY_EMAIL_VISIBILITY": 21,
 	"ADD_EMAIL":               22,
+	"AVATAR_USER":             23,
+	"CHAT":                    24,
 	"ANNONCEMENT_PLACEHOLDER": 10000,
 }
 
@@ -344,19 +344,19 @@ var HomeScreenTodoTypeRevMap = map[HomeScreenTodoType]string{
 	2:     "PROOF",
 	3:     "DEVICE",
 	4:     "FOLLOW",
-	5:     "CHAT",
 	6:     "PAPERKEY",
 	7:     "TEAM",
 	8:     "FOLDER",
 	9:     "GIT_REPO",
 	10:    "TEAM_SHOWCASE",
-	11:    "AVATAR_USER",
 	12:    "AVATAR_TEAM",
 	18:    "ADD_PHONE_NUMBER",
 	19:    "VERIFY_ALL_PHONE_NUMBER",
 	20:    "VERIFY_ALL_EMAIL",
 	21:    "LEGACY_EMAIL_VISIBILITY",
 	22:    "ADD_EMAIL",
+	23:    "AVATAR_USER",
+	24:    "CHAT",
 	10000: "ANNONCEMENT_PLACEHOLDER",
 }
 

v2/types/keybase1/home_ui.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/home_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/home_ui.avdl
 
 package keybase1

v2/types/keybase1/identify.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/identify.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/identify.avdl
 
 package keybase1
 

v2/types/keybase1/identify3.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/identify3.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/identify3.avdl
 
 package keybase1

v2/types/keybase1/identify3_common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/identify3_common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/identify3_common.avdl
 
 package keybase1
 

v2/types/keybase1/identify3_ui.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/identify3_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/identify3_ui.avdl
 
 package keybase1
 
@@ -134,8 +134,9 @@ type Identify3Row struct {
 	Priority             int                `codec:"priority" json:"priority"`
 	SiteURL              string             `codec:"siteURL" json:"siteURL"`
 	SiteIcon             []SizedImage       `codec:"siteIcon" json:"siteIcon"`
+	SiteIconDarkmode     []SizedImage       `codec:"siteIconDarkmode" json:"siteIconDarkmode"`
 	SiteIconFull         []SizedImage       `codec:"siteIconFull" json:"siteIconFull"`
-	SiteIconWhite []SizedImage       `codec:"siteIconWhite" json:"siteIconWhite"`
+	SiteIconFullDarkmode []SizedImage       `codec:"siteIconFullDarkmode" json:"siteIconFullDarkmode"`
 	ProofURL             string             `codec:"proofURL" json:"proofURL"`
 	SigID                SigID              `codec:"sigID" json:"sigID"`
 	Ctime                Time               `codec:"ctime" json:"ctime"`
@@ -163,6 +164,17 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 			}
 			return ret
 		})(o.SiteIcon),
+		SiteIconDarkmode: (func(x []SizedImage) []SizedImage {
+			if x == nil {
+				return nil
+			}
+			ret := make([]SizedImage, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.SiteIconDarkmode),
 		SiteIconFull: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
@@ -174,7 +186,7 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 			}
 			return ret
 		})(o.SiteIconFull),
-		SiteIconWhite: (func(x []SizedImage) []SizedImage {
+		SiteIconFullDarkmode: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
 			}
@@ -184,7 +196,7 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 				ret[i] = vCopy
 			}
 			return ret
-		})(o.SiteIconWhite),
+		})(o.SiteIconFullDarkmode),
 		ProofURL: o.ProofURL,
 		SigID:    o.SigID.DeepCopy(),
 		Ctime:    o.Ctime.DeepCopy(),
@@ -210,3 +222,15 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 		})(o.Kid),
 	}
 }
+
+type Identify3Summary struct {
+	GuiID            Identify3GUIID `codec:"guiID" json:"guiID"`
+	NumProofsToCheck int            `codec:"numProofsToCheck" json:"numProofsToCheck"`
+}
+
+func (o Identify3Summary) DeepCopy() Identify3Summary {
+	return Identify3Summary{
+		GuiID:            o.GuiID.DeepCopy(),
+		NumProofsToCheck: o.NumProofsToCheck,
+	}
+}

v2/types/keybase1/identify_common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/identify_common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/identify_common.avdl
 
 package keybase1
 

v2/types/keybase1/identify_ui.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/identify_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/identify_ui.avdl
 
 package keybase1
 
@@ -337,8 +337,8 @@ func (o UserTeamShowcase) DeepCopy() UserTeamShowcase {
 }
 
 type UserCard struct {
-	Following            int                `codec:"following" json:"following"`
+	UnverifiedNumFollowing int                `codec:"unverifiedNumFollowing" json:"unverifiedNumFollowing"`
-	Followers            int                `codec:"followers" json:"followers"`
+	UnverifiedNumFollowers int                `codec:"unverifiedNumFollowers" json:"unverifiedNumFollowers"`
 	Uid                    UID                `codec:"uid" json:"uid"`
 	FullName               string             `codec:"fullName" json:"fullName"`
 	Location               string             `codec:"location" json:"location"`
@@ -346,8 +346,6 @@ type UserCard struct {
 	BioDecorated           string             `codec:"bioDecorated" json:"bioDecorated"`
 	Website                string             `codec:"website" json:"website"`
 	Twitter                string             `codec:"twitter" json:"twitter"`
-	YouFollowThem        bool               `codec:"youFollowThem" json:"youFollowThem"`
-	TheyFollowYou        bool               `codec:"theyFollowYou" json:"theyFollowYou"`
 	TeamShowcase           []UserTeamShowcase `codec:"teamShowcase" json:"teamShowcase"`
 	RegisteredForAirdrop   bool               `codec:"registeredForAirdrop" json:"registeredForAirdrop"`
 	StellarHidden          bool               `codec:"stellarHidden" json:"stellarHidden"`
@@ -357,8 +355,8 @@ type UserCard struct {
 
 func (o UserCard) DeepCopy() UserCard {
 	return UserCard{
-		Following:     o.Following,
+		UnverifiedNumFollowing: o.UnverifiedNumFollowing,
-		Followers:     o.Followers,
+		UnverifiedNumFollowers: o.UnverifiedNumFollowers,
 		Uid:                    o.Uid.DeepCopy(),
 		FullName:               o.FullName,
 		Location:               o.Location,
@@ -366,8 +364,6 @@ func (o UserCard) DeepCopy() UserCard {
 		BioDecorated:           o.BioDecorated,
 		Website:                o.Website,
 		Twitter:                o.Twitter,
-		YouFollowThem: o.YouFollowThem,
-		TheyFollowYou: o.TheyFollowYou,
 		TeamShowcase: (func(x []UserTeamShowcase) []UserTeamShowcase {
 			if x == nil {
 				return nil

v2/types/keybase1/implicit_team_migration.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/implicit_team_migration.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/implicit_team_migration.avdl
 
 package keybase1

v2/types/keybase1/incoming-share.go

@@ -0,0 +1,98 @@
+// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/incoming-share.avdl
+
+package keybase1
+
+import (
+	"fmt"
+)
+
+type IncomingShareType int
+
+const (
+	IncomingShareType_FILE  IncomingShareType = 0
+	IncomingShareType_TEXT  IncomingShareType = 1
+	IncomingShareType_IMAGE IncomingShareType = 2
+	IncomingShareType_VIDEO IncomingShareType = 3
+)
+
+func (o IncomingShareType) DeepCopy() IncomingShareType { return o }
+
+var IncomingShareTypeMap = map[string]IncomingShareType{
+	"FILE":  0,
+	"TEXT":  1,
+	"IMAGE": 2,
+	"VIDEO": 3,
+}
+
+var IncomingShareTypeRevMap = map[IncomingShareType]string{
+	0: "FILE",
+	1: "TEXT",
+	2: "IMAGE",
+	3: "VIDEO",
+}
+
+func (e IncomingShareType) String() string {
+	if v, ok := IncomingShareTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type IncomingShareItem struct {
+	Type          IncomingShareType `codec:"type" json:"type"`
+	OriginalPath  *string           `codec:"originalPath,omitempty" json:"originalPath,omitempty"`
+	OriginalSize  *int              `codec:"originalSize,omitempty" json:"originalSize,omitempty"`
+	ScaledPath    *string           `codec:"scaledPath,omitempty" json:"scaledPath,omitempty"`
+	ScaledSize    *int              `codec:"scaledSize,omitempty" json:"scaledSize,omitempty"`
+	ThumbnailPath *string           `codec:"thumbnailPath,omitempty" json:"thumbnailPath,omitempty"`
+	Content       *string           `codec:"content,omitempty" json:"content,omitempty"`
+}
+
+func (o IncomingShareItem) DeepCopy() IncomingShareItem {
+	return IncomingShareItem{
+		Type: o.Type.DeepCopy(),
+		OriginalPath: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OriginalPath),
+		OriginalSize: (func(x *int) *int {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OriginalSize),
+		ScaledPath: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ScaledPath),
+		ScaledSize: (func(x *int) *int {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ScaledSize),
+		ThumbnailPath: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ThumbnailPath),
+		Content: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Content),
+	}
+}

v2/types/keybase1/install.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/install.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/install.avdl
 
 package keybase1
 

v2/types/keybase1/invite_friends.go

@@ -0,0 +1,56 @@
+// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/invite_friends.avdl
+
+package keybase1
+
+type InviteCounts struct {
+	InviteCount      int     `codec:"inviteCount" json:"inviteCount"`
+	PercentageChange float64 `codec:"percentageChange" json:"percentageChange"`
+	ShowNumInvites   bool    `codec:"showNumInvites" json:"showNumInvites"`
+	ShowFire         bool    `codec:"showFire" json:"showFire"`
+	TooltipMarkdown  string  `codec:"tooltipMarkdown" json:"tooltipMarkdown"`
+}
+
+func (o InviteCounts) DeepCopy() InviteCounts {
+	return InviteCounts{
+		InviteCount:      o.InviteCount,
+		PercentageChange: o.PercentageChange,
+		ShowNumInvites:   o.ShowNumInvites,
+		ShowFire:         o.ShowFire,
+		TooltipMarkdown:  o.TooltipMarkdown,
+	}
+}
+
+type EmailInvites struct {
+	CommaSeparatedEmailsFromUser *string         `codec:"commaSeparatedEmailsFromUser,omitempty" json:"commaSeparatedEmailsFromUser,omitempty"`
+	EmailsFromContacts           *[]EmailAddress `codec:"emailsFromContacts,omitempty" json:"emailsFromContacts,omitempty"`
+}
+
+func (o EmailInvites) DeepCopy() EmailInvites {
+	return EmailInvites{
+		CommaSeparatedEmailsFromUser: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.CommaSeparatedEmailsFromUser),
+		EmailsFromContacts: (func(x *[]EmailAddress) *[]EmailAddress {
+			if x == nil {
+				return nil
+			}
+			tmp := (func(x []EmailAddress) []EmailAddress {
+				if x == nil {
+					return nil
+				}
+				ret := make([]EmailAddress, len(x))
+				for i, v := range x {
+					vCopy := v.DeepCopy()
+					ret[i] = vCopy
+				}
+				return ret
+			})((*x))
+			return &tmp
+		})(o.EmailsFromContacts),
+	}
+}

v2/types/keybase1/kbfs.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kbfs.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kbfs.avdl
 
 package keybase1
 

v2/types/keybase1/kbfs_common.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kbfs_common.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kbfs_common.avdl
 
 package keybase1
 

v2/types/keybase1/kbfs_git.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kbfs_git.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kbfs_git.avdl
 
 package keybase1
 

v2/types/keybase1/kbfsmount.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kbfsmount.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kbfsmount.avdl
 
 package keybase1

v2/types/keybase1/kex2provisionee.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kex2provisionee.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kex2provisionee.avdl
 
 package keybase1
 

v2/types/keybase1/kex2provisionee2.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kex2provisionee2.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kex2provisionee2.avdl
 
 package keybase1
 

v2/types/keybase1/kex2provisioner.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kex2provisioner.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kex2provisioner.avdl
 
 package keybase1

v2/types/keybase1/kvstore.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/kvstore.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/kvstore.avdl
 
 package keybase1
 

v2/types/keybase1/log.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/log.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/log.avdl
 
 package keybase1

v2/types/keybase1/log_ui.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/log_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/log_ui.avdl
 
 package keybase1

v2/types/keybase1/login.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/login.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/login.avdl
 
 package keybase1
 

v2/types/keybase1/login_ui.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/login_ui.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/login_ui.avdl
 
 package keybase1
 

v2/types/keybase1/logsend.go

@@ -1,4 +1,4 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/logsend.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/logsend.avdl
 
 package keybase1

v2/types/keybase1/merkle.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/merkle.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/merkle.avdl
 
 package keybase1
 

v2/types/keybase1/merkle_store.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/merkle_store.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/merkle_store.avdl
 
 package keybase1
 

v2/types/keybase1/metadata.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/metadata.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/metadata.avdl
 
 package keybase1
 

v2/types/keybase1/metadata_update.go

@@ -1,5 +1,5 @@
 // Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: ../client/protocol/avdl/keybase1/metadata_update.avdl
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/metadata_update.avdl
 
 package keybase1
 

v2/types/keybase1/network_stats.go

@@ -0,0 +1,66 @@
+// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../../../../../../client/protocol/avdl/keybase1/network_stats.avdl
+
+package keybase1
+
+import (
+	"fmt"
+)
+
+type NetworkSource int
+
+const (
+	NetworkSource_LOCAL  NetworkSource = 0
+	NetworkSource_REMOTE NetworkSource = 1
+)
+
+func (o NetworkSource) DeepCopy() NetworkSource { return o }
+
+var NetworkSourceMap = map[string]NetworkSource{
+	"LOCAL":  0,
+	"REMOTE": 1,
+}
+
+var NetworkSourceRevMap = map[NetworkSource]string{
+	0: "LOCAL",
+	1: "REMOTE",
+}
+
+func (e NetworkSource) String() string {
+	if v, ok := NetworkSourceRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type InstrumentationStat struct {
+	Tag       string       `codec:"t" json:"tag"`
+	NumCalls  int          `codec:"n" json:"numCalls"`
+	Ctime     Time         `codec:"c" json:"ctime"`
+	Mtime     Time         `codec:"m" json:"mtime"`
+	AvgDur    DurationMsec `codec:"ad" json:"avgDur"`
+	MaxDur    DurationMsec `codec:"xd" json:"maxDur"`
+	MinDur    DurationMsec `codec:"nd" json:"minDur"`
+	TotalDur  DurationMsec `codec:"td" json:"totalDur"`
+	AvgSize   int64        `codec:"as" json:"avgSize"`
+	MaxSize   int64        `codec:"xs" json:"maxSize"`
+	MinSize   int64        `codec:"ns" json:"minSize"`
+	TotalSize int64        `codec:"ts" json:"totalSize"`
+}
+
+func (o InstrumentationStat) DeepCopy() InstrumentationStat {
+	return InstrumentationStat{
+		Tag:       o.Tag,
+		NumCalls:  o.NumCalls,
+		Ctime:     o.Ctime.DeepCopy(),
+		Mtime:     o.Mtime.DeepCopy(),
+		AvgDur:    o.AvgDur.DeepCopy(),
+		MaxDur:    o.MaxDur.DeepCopy(),
+		MinDur:    o.MinDur.DeepCopy(),
+		TotalDur:  o.TotalDur.DeepCopy(),
+		AvgSize:   o.AvgSize,
+		MaxSize:   o.MaxSize,
+		MinSize:   o.MinSize,
+		TotalSize: o.TotalSize,
+	}
+}