diff --git a/services/syncbase/bridge/blessings.go b/services/syncbase/bridge/blessings.go
index a1bbaac..e8dc8ba 100644
--- a/services/syncbase/bridge/blessings.go
+++ b/services/syncbase/bridge/blessings.go
@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file provides utilities for exchanging an OAuth token for a blessing
-// via the Vanadium identity provider, and initializing a Vanadium context
-// with this blessing.
+// This file provides utilities for exchanging an OAuth token for a blessing via
+// the Vanadium identity provider, and initializing a Vanadium context with this
+// blessing.
 //
-// See v.io/x/ref/services/syncbase/bridge/mojo/blessings.go for more documentation.
+// See v.io/x/ref/services/syncbase/bridge/mojo/blessings.go for more
+// documentation.
 
 package bridge
 
@@ -25,20 +26,12 @@
 	seclib "v.io/x/ref/lib/security"
 )
 
-// SetBlessings exchanges an oauth token for blessings from the dev.v.io server.
-// Currently oauthProvider must be set to "google".
+// SetBlessings exchanges an OAuth token for blessings from the dev.v.io server.
+// Currently, oauthProvider must be set to "google".
 func SetBlessings(ctx *context.T, oauthProvider string, oauthToken string) error {
 	if strings.ToLower(oauthProvider) != "google" {
-		return fmt.Errorf("unsupported oauthProvider %q; currently, \"google\" is the only supported provider",
-			oauthProvider)
+		return fmt.Errorf("unsupported oauthProvider %q; currently, \"google\" is the only supported provider", oauthProvider)
 	}
-	// Get an OAuth2 token from the mojo authentication service.
-	// TODO(ashankar,ataly): This is almost a duplicate of what
-	// is in
-	// https://github.com/domokit/mojo/blob/master/services/vanadium/security/principal_service.go
-	// - at some point this needs to be cleared up and this
-	// syncbase should use the principal service?
-	ctx.Infof("Obtained OAuth2 token, will exchange for blessings")
 	p := v23.GetPrincipal(ctx)
 	blessings, err := token2blessings(oauthToken, p.PublicKey())
 	if err != nil {
diff --git a/services/syncbase/bridge/cgo/impl.go b/services/syncbase/bridge/cgo/impl.go
index c218b67..b58fd86 100644
--- a/services/syncbase/bridge/cgo/impl.go
+++ b/services/syncbase/bridge/cgo/impl.go
@@ -4,12 +4,18 @@
 
 // +build cgo
 
+// TODO(sadovsky): Make DbWatchPatterns and CollectionScan cancelable, e.g. by
+// returning a cancel closure handle to the client.
+
 // Syncbase C/Cgo API. Our strategy is to translate Cgo requests into Vanadium
 // stub requests, and Vanadium stub responses into Cgo responses. As part of
 // this procedure, we synthesize "fake" ctx and call objects to pass to the
 // Vanadium stubs.
 //
 // Implementation notes:
+// - This API partly mirrors the Syncbase RPC API. Many methods take 'cName' as
+//   their first argument; this is a service-relative Vanadium object name. For
+//   example, the 'cName' argument to DbCreate is an encoded database id.
 // - All exported function and type names start with "v23_syncbase_", to avoid
 //   colliding with desired client library names.
 // - Exported functions take input arguments by value, optional input arguments
@@ -32,6 +38,8 @@
 	"v.io/v23/rpc"
 	"v.io/v23/services/permissions"
 	wire "v.io/v23/services/syncbase"
+	"v.io/v23/services/watch"
+	"v.io/v23/syncbase"
 	"v.io/v23/syncbase/util"
 	"v.io/v23/verror"
 	"v.io/v23/vom"
@@ -43,6 +51,13 @@
 /*
 #include "lib.h"
 
+static void CallDbWatchPatternsCallbacksOnChange(v23_syncbase_DbWatchPatternsCallbacks cbs, v23_syncbase_WatchChange wc) {
+  cbs.onChange(cbs.hOnChange, wc);
+}
+static void CallDbWatchPatternsCallbacksOnError(v23_syncbase_DbWatchPatternsCallbacks cbs, v23_syncbase_VError err) {
+  cbs.onError(cbs.hOnChange, cbs.hOnError, err);
+}
+
 static void CallCollectionScanCallbacksOnKeyValue(v23_syncbase_CollectionScanCallbacks cbs, v23_syncbase_KeyValue kv) {
   cbs.onKeyValue(cbs.hOnKeyValue, kv);
 }
@@ -165,6 +180,7 @@
 
 //export v23_syncbase_ServiceListDatabases
 func v23_syncbase_ServiceListDatabases(cIds *C.v23_syncbase_Ids, cErr *C.v23_syncbase_VError) {
+	// TODO(sadovsky): This is broken; it always returns an empty list.
 	listChildIds("", cIds, cErr)
 }
 
@@ -307,8 +323,6 @@
 	cErr.init(stub.SetPermissions(ctx, call, perms, version))
 }
 
-// TODO(sadovsky): Add watch API.
-
 //export v23_syncbase_DbGetResumeMarker
 func v23_syncbase_DbGetResumeMarker(cName, cBatchHandle C.v23_syncbase_String, cMarker *C.v23_syncbase_Bytes, cErr *C.v23_syncbase_VError) {
 	name := cName.toString()
@@ -327,11 +341,64 @@
 	cMarker.init(marker)
 }
 
+type watchStreamImpl struct {
+	ctx *context.T
+	cbs C.v23_syncbase_DbWatchPatternsCallbacks
+}
+
+func (s *watchStreamImpl) Send(item interface{}) error {
+	wireWC, ok := item.(watch.Change)
+	if !ok {
+		return verror.NewErrInternal(s.ctx)
+	}
+	// C.CallDbWatchPatternsCallbacksOnChange() blocks until the client acks the
+	// previous invocation, thus providing flow control.
+	cWatchChange := C.v23_syncbase_WatchChange{}
+	cWatchChange.init(syncbase.ToWatchChange(wireWC))
+	C.CallDbWatchPatternsCallbacksOnChange(s.cbs, cWatchChange)
+	return nil
+}
+
+func (s *watchStreamImpl) Recv(_ interface{}) error {
+	// This should never be called.
+	return verror.NewErrInternal(s.ctx)
+}
+
+var _ rpc.Stream = (*watchStreamImpl)(nil)
+
+//export v23_syncbase_DbWatchPatterns
+func v23_syncbase_DbWatchPatterns(cName, cResumeMarker C.v23_syncbase_String, cPatterns C.v23_syncbase_CollectionRowPatterns, cbs C.v23_syncbase_DbWatchPatternsCallbacks, cErr *C.v23_syncbase_VError) {
+	name := cName.toString()
+	resumeMarker := watch.ResumeMarker(cResumeMarker.toString())
+	patterns := cPatterns.toCollectionRowPatterns()
+	ctx, call := b.NewCtxCall(name, bridge.MethodDesc(wire.DatabaseWatcherDesc, "WatchPatterns"))
+	stub, err := b.GetDb(ctx, call, name)
+	if err != nil {
+		cErr.init(err)
+		return
+	}
+
+	streamStub := &wire.DatabaseWatcherWatchPatternsServerCallStub{struct {
+		rpc.Stream
+		rpc.ServerCall
+	}{
+		&watchStreamImpl{ctx: ctx, cbs: cbs},
+		call,
+	}}
+
+	go func() {
+		err := stub.WatchPatterns(ctx, streamStub, resumeMarker, patterns)
+		// Note: Since we are now streaming, any new error must be sent back on the
+		// stream; the function itself should not return an error at this point.
+		cErr := C.v23_syncbase_VError{}
+		cErr.init(err)
+		C.CallDbWatchPatternsCallbacksOnError(cbs, cErr)
+	}()
+}
+
 ////////////////////////////////////////
 // SyncgroupManager
 
-// FIXME(sadovsky): Implement "NewErrNotImplemented" methods below.
-
 //export v23_syncbase_DbListSyncgroups
 func v23_syncbase_DbListSyncgroups(cName C.v23_syncbase_String, cIds *C.v23_syncbase_Ids, cErr *C.v23_syncbase_VError) {
 	name := cName.toString()
@@ -341,8 +408,12 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_ = stub // prevent "declared and not used"
+	ids, err := stub.ListSyncgroups(ctx, call)
+	if err != nil {
+		cErr.init(err)
+		return
+	}
+	cIds.init(ids)
 }
 
 //export v23_syncbase_DbCreateSyncgroup
@@ -357,13 +428,14 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _, _, _ = sgId, spec, myInfo, stub // prevent "declared and not used"
+	cErr.init(stub.CreateSyncgroup(ctx, call, sgId, spec, myInfo))
 }
 
 //export v23_syncbase_DbJoinSyncgroup
-func v23_syncbase_DbJoinSyncgroup(cName C.v23_syncbase_String, cSgId C.v23_syncbase_Id, cMyInfo C.v23_syncbase_SyncgroupMemberInfo, cSpec *C.v23_syncbase_SyncgroupSpec, cErr *C.v23_syncbase_VError) {
+func v23_syncbase_DbJoinSyncgroup(cName, cRemoteSyncbaseName C.v23_syncbase_String, cExpectedSyncbaseBlessings C.v23_syncbase_Strings, cSgId C.v23_syncbase_Id, cMyInfo C.v23_syncbase_SyncgroupMemberInfo, cSpec *C.v23_syncbase_SyncgroupSpec, cErr *C.v23_syncbase_VError) {
 	name := cName.toString()
+	remoteSyncbaseName := cRemoteSyncbaseName.toString()
+	expectedSyncbaseBlessings := cExpectedSyncbaseBlessings.toStrings()
 	sgId := cSgId.toId()
 	myInfo := cMyInfo.toSyncgroupMemberInfo()
 	ctx, call := b.NewCtxCall(name, bridge.MethodDesc(wire.SyncgroupManagerDesc, "JoinSyncgroup"))
@@ -372,8 +444,12 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _, _ = sgId, myInfo, stub // prevent "declared and not used"
+	spec, err := stub.JoinSyncgroup(ctx, call, remoteSyncbaseName, expectedSyncbaseBlessings, sgId, myInfo)
+	if err != nil {
+		cErr.init(err)
+		return
+	}
+	cSpec.init(spec)
 }
 
 //export v23_syncbase_DbLeaveSyncgroup
@@ -386,8 +462,7 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _ = sgId, stub // prevent "declared and not used"
+	cErr.init(stub.LeaveSyncgroup(ctx, call, sgId))
 }
 
 //export v23_syncbase_DbDestroySyncgroup
@@ -400,8 +475,7 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _ = sgId, stub // prevent "declared and not used"
+	cErr.init(stub.DestroySyncgroup(ctx, call, sgId))
 }
 
 //export v23_syncbase_DbEjectFromSyncgroup
@@ -415,8 +489,7 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _, _ = sgId, member, stub // prevent "declared and not used"
+	cErr.init(stub.EjectFromSyncgroup(ctx, call, sgId, member))
 }
 
 //export v23_syncbase_DbGetSyncgroupSpec
@@ -429,8 +502,13 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _ = sgId, stub // prevent "declared and not used"
+	spec, version, err := stub.GetSyncgroupSpec(ctx, call, sgId)
+	if err != nil {
+		cErr.init(err)
+		return
+	}
+	cSpec.init(spec)
+	cVersion.init(version)
 }
 
 //export v23_syncbase_DbSetSyncgroupSpec
@@ -445,8 +523,7 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _, _, _ = sgId, spec, version, stub // prevent "declared and not used"
+	cErr.init(stub.SetSyncgroupSpec(ctx, call, sgId, spec, version))
 }
 
 //export v23_syncbase_DbGetSyncgroupMembers
@@ -459,8 +536,12 @@
 		cErr.init(err)
 		return
 	}
-	cErr.init(verror.NewErrNotImplemented(nil))
-	_, _ = sgId, stub // prevent "declared and not used"
+	members, err := stub.GetSyncgroupMembers(ctx, call, sgId)
+	if err != nil {
+		cErr.init(err)
+		return
+	}
+	cMembers.init(members)
 }
 
 ////////////////////////////////////////
@@ -586,8 +667,6 @@
 
 var _ rpc.Stream = (*scanStreamImpl)(nil)
 
-// TODO(nlacasse): Provide some way for the client to cancel the stream.
-
 //export v23_syncbase_CollectionScan
 func v23_syncbase_CollectionScan(cName, cBatchHandle C.v23_syncbase_String, cStart, cLimit C.v23_syncbase_Bytes, cbs C.v23_syncbase_CollectionScanCallbacks, cErr *C.v23_syncbase_VError) {
 	name := cName.toString()
@@ -600,7 +679,7 @@
 		return
 	}
 
-	collectionScanServerCallStub := &wire.CollectionScanServerCallStub{struct {
+	streamStub := &wire.CollectionScanServerCallStub{struct {
 		rpc.Stream
 		rpc.ServerCall
 	}{
@@ -609,10 +688,9 @@
 	}}
 
 	go func() {
-		err := stub.Scan(ctx, collectionScanServerCallStub, batchHandle, start, limit)
-		// NOTE(nlacasse): Since we are already streaming, we send any error back to
-		// the client on the stream. The CollectionScan function itself should not
-		// return an error at this point.
+		err := stub.Scan(ctx, streamStub, batchHandle, start, limit)
+		// Note: Since we are now streaming, any new error must be sent back on the
+		// stream; the function itself should not return an error at this point.
 		cErr := C.v23_syncbase_VError{}
 		cErr.init(err)
 		C.CallCollectionScanCallbacksOnDone(cbs, cErr)
diff --git a/services/syncbase/bridge/cgo/lib.h b/services/syncbase/bridge/cgo/lib.h
index 11d416a..fc8565a 100644
--- a/services/syncbase/bridge/cgo/lib.h
+++ b/services/syncbase/bridge/cgo/lib.h
@@ -8,8 +8,6 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-// TODO(sadovsky): Add types and functions for watch and sync.
-
 ////////////////////////////////////////
 // Generic types
 
@@ -71,6 +69,35 @@
   bool readOnly;
 } v23_syncbase_BatchOptions;
 
+// syncbase.CollectionRowPattern
+typedef struct {
+  v23_syncbase_String collectionBlessing;
+  v23_syncbase_String collectionName;
+  v23_syncbase_String rowKey;
+} v23_syncbase_CollectionRowPattern;
+
+// []syncbase.CollectionRowPattern
+typedef struct {
+  v23_syncbase_CollectionRowPattern* p;
+  int n;
+} v23_syncbase_CollectionRowPatterns;
+
+typedef enum v23_syncbase_ChangeType {
+  kPut = 0,
+  kDelete = 1
+} v23_syncbase_ChangeType;
+
+// syncbase.WatchChange
+typedef struct {
+  v23_syncbase_Id collection;
+  v23_syncbase_String row;
+  v23_syncbase_ChangeType changeType;
+  v23_syncbase_Bytes value;
+  v23_syncbase_String resumeMarker;
+  bool fromSync;
+  bool continued;
+} v23_syncbase_WatchChange;
+
 // syncbase.KeyValue
 typedef struct {
   v23_syncbase_String key;
@@ -80,6 +107,7 @@
 // syncbase.SyncgroupSpec
 typedef struct {
   v23_syncbase_String description;
+  v23_syncbase_String publishSyncbaseName;
   v23_syncbase_Permissions perms;
   v23_syncbase_Ids collections;
   v23_syncbase_Strings mountTables;
@@ -110,6 +138,13 @@
 typedef int v23_syncbase_Handle;
 
 typedef struct {
+  v23_syncbase_Handle hOnChange;
+  v23_syncbase_Handle hOnError;
+  void (*onChange)(v23_syncbase_Handle hOnChange, v23_syncbase_WatchChange);
+  void (*onError)(v23_syncbase_Handle hOnChange, v23_syncbase_Handle hOnError, v23_syncbase_VError);
+} v23_syncbase_DbWatchPatternsCallbacks;
+
+typedef struct {
   v23_syncbase_Handle hOnKeyValue;
   v23_syncbase_Handle hOnDone;
   void (*onKeyValue)(v23_syncbase_Handle hOnKeyValue, v23_syncbase_KeyValue);
diff --git a/services/syncbase/bridge/cgo/types.go b/services/syncbase/bridge/cgo/types.go
index dff0408..3dbfc9c 100644
--- a/services/syncbase/bridge/cgo/types.go
+++ b/services/syncbase/bridge/cgo/types.go
@@ -10,7 +10,9 @@
 
 	"v.io/v23/security/access"
 	wire "v.io/v23/services/syncbase"
+	"v.io/v23/syncbase"
 	"v.io/v23/verror"
+	"v.io/v23/vom"
 )
 
 // All "x.toFoo" methods free the memory associated with x.
@@ -22,7 +24,7 @@
 */
 import "C"
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_Bool
 
 func (x *C.v23_syncbase_Bool) init(b bool) {
@@ -40,7 +42,7 @@
 	return true
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_String
 
 func (x *C.v23_syncbase_String) init(s string) {
@@ -56,7 +58,7 @@
 	return C.GoStringN(x.p, x.n)
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_Bytes
 
 func init() {
@@ -67,7 +69,7 @@
 
 func (x *C.v23_syncbase_Bytes) init(b []byte) {
 	x.n = C.int(len(b))
-	x.p = (*C.uint8_t)(C.malloc(C.size_t(len(b))))
+	x.p = (*C.uint8_t)(C.malloc(C.size_t(x.n)))
 	C.memcpy(unsafe.Pointer(x.p), unsafe.Pointer(&b[0]), C.size_t(len(b)))
 }
 
@@ -79,7 +81,7 @@
 	return C.GoBytes(unsafe.Pointer(x.p), x.n)
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_Strings
 
 func (x *C.v23_syncbase_Strings) at(i int) *C.v23_syncbase_String {
@@ -88,7 +90,7 @@
 
 func (x *C.v23_syncbase_Strings) init(strs []string) {
 	x.n = C.int(len(strs))
-	x.p = (*C.v23_syncbase_String)(C.malloc(C.size_t(len(strs)) * C.sizeof_v23_syncbase_String))
+	x.p = (*C.v23_syncbase_String)(C.malloc(C.size_t(x.n) * C.sizeof_v23_syncbase_String))
 	for i, v := range strs {
 		x.at(i).init(v)
 	}
@@ -106,7 +108,7 @@
 	return res
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_VError
 
 func (x *C.v23_syncbase_VError) init(err error) {
@@ -119,7 +121,7 @@
 	x.stack.init(verror.Stack(err).String())
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_Permissions
 
 func (x *C.v23_syncbase_Permissions) init(perms access.Permissions) {
@@ -142,7 +144,7 @@
 	return perms
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_Id
 
 func (x *C.v23_syncbase_Id) init(id wire.Id) {
@@ -157,7 +159,7 @@
 	}
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_Ids
 
 func (x *C.v23_syncbase_Ids) at(i int) *C.v23_syncbase_Id {
@@ -166,13 +168,25 @@
 
 func (x *C.v23_syncbase_Ids) init(ids []wire.Id) {
 	x.n = C.int(len(ids))
-	x.p = (*C.v23_syncbase_Id)(C.malloc(C.size_t(len(ids)) * C.sizeof_v23_syncbase_Id))
+	x.p = (*C.v23_syncbase_Id)(C.malloc(C.size_t(x.n) * C.sizeof_v23_syncbase_Id))
 	for i, v := range ids {
 		x.at(i).init(v)
 	}
 }
 
-////////////////////////////////////////
+func (x *C.v23_syncbase_Ids) toIds() []wire.Id {
+	if x.p == nil {
+		return nil
+	}
+	defer C.free(unsafe.Pointer(x.p))
+	res := make([]wire.Id, x.n)
+	for i := 0; i < int(x.n); i++ {
+		res[i] = x.at(i).toId()
+	}
+	return res
+}
+
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_BatchOptions
 
 func (x *C.v23_syncbase_BatchOptions) init(opts wire.BatchOptions) {
@@ -187,7 +201,69 @@
 	}
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
+// C.v23_syncbase_CollectionRowPattern
+
+func (x *C.v23_syncbase_CollectionRowPattern) init(crp wire.CollectionRowPattern) {
+	x.collectionBlessing.init(crp.CollectionBlessing)
+	x.collectionName.init(crp.CollectionName)
+	x.rowKey.init(crp.RowKey)
+}
+
+func (x *C.v23_syncbase_CollectionRowPattern) toCollectionRowPattern() wire.CollectionRowPattern {
+	return wire.CollectionRowPattern{
+		CollectionBlessing: x.collectionBlessing.toString(),
+		CollectionName:     x.collectionName.toString(),
+		RowKey:             x.rowKey.toString(),
+	}
+}
+
+////////////////////////////////////////////////////////////
+// C.v23_syncbase_CollectionRowPatterns
+
+func (x *C.v23_syncbase_CollectionRowPatterns) at(i int) *C.v23_syncbase_CollectionRowPattern {
+	return (*C.v23_syncbase_CollectionRowPattern)(unsafe.Pointer(uintptr(unsafe.Pointer(x.p)) + uintptr(C.size_t(i)*C.sizeof_v23_syncbase_CollectionRowPattern)))
+}
+
+func (x *C.v23_syncbase_CollectionRowPatterns) init(crps []wire.CollectionRowPattern) {
+	x.n = C.int(len(crps))
+	x.p = (*C.v23_syncbase_CollectionRowPattern)(C.malloc(C.size_t(x.n) * C.sizeof_v23_syncbase_CollectionRowPattern))
+	for i, v := range crps {
+		x.at(i).init(v)
+	}
+}
+
+func (x *C.v23_syncbase_CollectionRowPatterns) toCollectionRowPatterns() []wire.CollectionRowPattern {
+	if x.p == nil {
+		return nil
+	}
+	defer C.free(unsafe.Pointer(x.p))
+	res := make([]wire.CollectionRowPattern, x.n)
+	for i := 0; i < int(x.n); i++ {
+		res[i] = x.at(i).toCollectionRowPattern()
+	}
+	return res
+}
+
+////////////////////////////////////////////////////////////
+// C.v23_syncbase_WatchChange
+
+func (x *C.v23_syncbase_WatchChange) init(wc syncbase.WatchChange) error {
+	x.collection.init(wc.Collection)
+	x.row.init(wc.Row)
+	x.changeType = C.v23_syncbase_ChangeType(wc.ChangeType)
+	value, err := vom.Encode(wc.Value)
+	if err != nil {
+		return err
+	}
+	x.value.init(value)
+	x.resumeMarker.init(string(wc.ResumeMarker))
+	x.fromSync = C.bool(wc.FromSync)
+	x.continued = C.bool(wc.Continued)
+	return nil
+}
+
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_KeyValue
 
 func (x *C.v23_syncbase_KeyValue) init(key string, value []byte) {
@@ -195,33 +271,62 @@
 	x.value.init(value)
 }
 
-// FIXME(sadovsky): Implement stubbed-out methods below.
-
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_SyncgroupSpec
 
 func (x *C.v23_syncbase_SyncgroupSpec) init(spec wire.SyncgroupSpec) {
-
+	x.description.init(spec.Description)
+	x.publishSyncbaseName.init(spec.PublishSyncbaseName)
+	x.perms.init(spec.Perms)
+	x.collections.init(spec.Collections)
+	x.mountTables.init(spec.MountTables)
+	x.isPrivate = C.bool(spec.IsPrivate)
 }
 
 func (x *C.v23_syncbase_SyncgroupSpec) toSyncgroupSpec() wire.SyncgroupSpec {
-	return wire.SyncgroupSpec{}
+	return wire.SyncgroupSpec{
+		Description:         x.description.toString(),
+		PublishSyncbaseName: x.publishSyncbaseName.toString(),
+		Perms:               x.perms.toPermissions(),
+		Collections:         x.collections.toIds(),
+		MountTables:         x.mountTables.toStrings(),
+		IsPrivate:           bool(x.isPrivate),
+	}
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_SyncgroupMemberInfo
 
 func (x *C.v23_syncbase_SyncgroupMemberInfo) init(member wire.SyncgroupMemberInfo) {
-
+	x.syncPriority = C.uint8_t(member.SyncPriority)
+	x.blobDevType = C.uint8_t(member.BlobDevType)
 }
 
 func (x *C.v23_syncbase_SyncgroupMemberInfo) toSyncgroupMemberInfo() wire.SyncgroupMemberInfo {
-	return wire.SyncgroupMemberInfo{}
+	return wire.SyncgroupMemberInfo{
+		SyncPriority: byte(x.syncPriority),
+		BlobDevType:  byte(x.blobDevType),
+	}
 }
 
-////////////////////////////////////////
+////////////////////////////////////////////////////////////
 // C.v23_syncbase_SyncgroupMemberInfoMap
 
-func (x *C.v23_syncbase_SyncgroupMemberInfoMap) init(members map[string]wire.SyncgroupMemberInfo) {
+func (x *C.v23_syncbase_SyncgroupMemberInfoMap) at(i int) (*C.v23_syncbase_String, *C.v23_syncbase_SyncgroupMemberInfo) {
+	k := (*C.v23_syncbase_String)(unsafe.Pointer(uintptr(unsafe.Pointer(x.keys)) + uintptr(C.size_t(i)*C.sizeof_v23_syncbase_String)))
+	v := (*C.v23_syncbase_SyncgroupMemberInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(x.values)) + uintptr(C.size_t(i)*C.sizeof_v23_syncbase_SyncgroupMemberInfo)))
+	return k, v
+}
 
+func (x *C.v23_syncbase_SyncgroupMemberInfoMap) init(members map[string]wire.SyncgroupMemberInfo) {
+	x.n = C.int(len(members))
+	x.keys = (*C.v23_syncbase_String)(C.malloc(C.size_t(x.n) * C.sizeof_v23_syncbase_String))
+	x.values = (*C.v23_syncbase_SyncgroupMemberInfo)(C.malloc(C.size_t(x.n) * C.sizeof_v23_syncbase_SyncgroupMemberInfo))
+	i := 0
+	for k, v := range members {
+		ck, cv := x.at(i)
+		ck.init(k)
+		cv.init(v)
+		i++
+	}
 }
diff --git a/services/syncbase/bridge/mojo/blessings.go b/services/syncbase/bridge/mojo/blessings.go
index 1b2441e..fbce4c1 100644
--- a/services/syncbase/bridge/mojo/blessings.go
+++ b/services/syncbase/bridge/mojo/blessings.go
@@ -78,11 +78,11 @@
 		v23ctx.Infof("Using default blessings for non-Android OS (%v)", runtime.GOOS)
 		return nil
 	}
-	// TODO(ashankar,ataly): This is almost a duplicate of what
-	// is in
+	// Get an OAuth2 token from the mojo authentication service.
+	// TODO(ashankar,ataly): This is almost a duplicate of:
 	// https://github.com/domokit/mojo/blob/master/services/vanadium/security/principal_service.go
-	// - at some point this needs to be cleared up and this
-	// syncbase should use the principal service?
+	// At some point this needs to be cleared up - the syncbase mojo service
+	// should talk to the principal mojo service.
 	token, err := oauthToken(appctx)
 	if err != nil {
 		if _, ok := err.(selectAccountFailed); ok {
@@ -93,6 +93,7 @@
 		}
 		return err
 	}
+	ctx.Infof("Obtained OAuth2 token, will exchange for blessings")
 	return bridge.SetBlessings(v23ctx, "google", token)
 }
 
diff --git a/services/syncbase/bridge/mojo/impl.go b/services/syncbase/bridge/mojo/impl.go
index 8139e23..e5281aa 100644
--- a/services/syncbase/bridge/mojo/impl.go
+++ b/services/syncbase/bridge/mojo/impl.go
@@ -4,8 +4,10 @@
 
 // +build mojo
 
-// TODO(sadovsky): Finish updating to reflect new, simplified API. Some, but not
-// all, of this code has been updated.
+// NOTE(sadovsky): The code below reflects some, but not all, of the Syncbase
+// API changes and simplifications. If at some point we choose to update this
+// code, the person doing this work should compare against bridge/cgo/impl.go to
+// figure out what needs to change.
 
 // Implementation of Syncbase Mojo stubs. Our strategy is to translate Mojo stub
 // requests into Vanadium stub requests, and Vanadium stub responses into Mojo
@@ -13,6 +15,9 @@
 // objects to pass to the Vanadium stubs.
 //
 // Implementation notes:
+// - This API partly mirrors the Syncbase RPC API. Many methods take 'name' as
+//   their first argument; this is a service-relative Vanadium object name. For
+//   example, the 'name' argument to DbCreate is an encoded database id.
 // - Variables with Mojo-specific types have names that start with "m".
 
 package bridge_mojo