Repository: lightninglabs/taproot-assets

Issue:
Add `IgnoreAsset` RPC endpoint
Add `IgnoreAsset` RPC endpoint. This allows an asset issuer to mark an asset UTXO (identified by `PrevID`) as "ignored". Ignored assets will be included in the ignore tree of the next universe commitment transaction.

Discussion:

Solution patch:
diff --git a/asset/asset.go b/asset/asset.go
index 07008e6f..153c2b9d 100644
--- a/asset/asset.go
+++ b/asset/asset.go
@@ -55,6 +55,22 @@ const (
 // compressed, 33-byte form.
 type SerializedKey [33]byte
 
+// NewSerializedKeyFromBytes creates a new SerializedKey from the given byte
+// slice.
+func NewSerializedKeyFromBytes(key []byte) (SerializedKey, error) {
+	var zero SerializedKey
+
+	// Ensure that the key is a valid public key.
+	if _, err := btcec.ParsePubKey(key); err != nil {
+		return zero, fmt.Errorf("invalid public key: %w", err)
+	}
+
+	var serialized SerializedKey
+	copy(serialized[:], key)
+
+	return serialized, nil
+}
+
 // ToPubKey returns the public key parsed from the serialized key.
 func (s SerializedKey) ToPubKey() (*btcec.PublicKey, error) {
 	return btcec.ParsePubKey(s[:])
@@ -74,6 +90,11 @@ func (s SerializedKey) CopyBytes() []byte {
 	return c
 }
 
+// String returns the hex-encoded string representation of the serialized key.
+func (s SerializedKey) String() string {
+	return hex.EncodeToString(s[:])
+}
+
 // ToSerialized serializes a public key in its 33-byte compressed form.
 func ToSerialized(pubKey *btcec.PublicKey) SerializedKey {
 	var serialized SerializedKey
@@ -330,6 +351,23 @@ func (g Genesis) TagHash() [sha256.Size]byte {
 //	  outputIndex || assetType)
 type ID [sha256.Size]byte
 
+// NewIDFromBytes creates a new ID from the given byte slice. The byte slice
+// must be exactly 32 bytes long, otherwise an error is returned.
+func NewIDFromBytes(id []byte) (ID, error) {
+	var zero ID
+
+	// Basic sanity check to ensure the ID is the correct length.
+	if len(id) != sha256.Size {
+		return zero, fmt.Errorf("invalid ID length: %d", len(id))
+	}
+
+	// Copy the byte slice into a new ID instance.
+	var assetID ID
+	copy(assetID[:], id)
+
+	return assetID, nil
+}
+
 // String returns the hex-encoded string representation of the ID.
 func (i ID) String() string {
 	return hex.EncodeToString(i[:])
@@ -731,6 +769,10 @@ func (id PrevID) Hash() [sha256.Size]byte {
 	return *(*[sha256.Size]byte)(h.Sum(nil))
 }
 
+// AnchorPoint is a type alias for an asset anchor outpoint. It relates the
+// on-chain anchor outpoint (txid:vout) to the corresponding committed asset.
+type AnchorPoint = PrevID
+
 // SplitCommitment represents the asset witness for an asset split.
 type SplitCommitment struct {
 	// Proof is the proof for a particular asset split resulting from a
diff --git a/cmd/commands/universe.go b/cmd/commands/universe.go
index 53f8a3ea..0bbfc741 100644
--- a/cmd/commands/universe.go
+++ b/cmd/commands/universe.go
@@ -9,6 +9,7 @@ import (
 	tap "github.com/lightninglabs/taproot-assets"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
+	"github.com/lightninglabs/taproot-assets/taprpc"
 	unirpc "github.com/lightninglabs/taproot-assets/taprpc/universerpc"
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/lncfg"
@@ -48,6 +49,7 @@ var universeCommands = []cli.Command{
 			universeFederationCommand,
 			universeInfoCommand,
 			universeStatsCommand,
+			universeSupplyCommitCommand,
 		},
 	},
 }
@@ -1503,3 +1505,212 @@ func universeEventStatsQueryCommand(ctx *cli.Context) error {
 	printRespJSON(resp)
 	return nil
 }
+
+var universeSupplyCommitCommand = cli.Command{
+	Name:      "supplycommit",
+	ShortName: "sc",
+	Usage:     "manage the supply commitment for a Universe",
+	Description: `
+	Manage the supply commitment for a Universe. The supply commitment
+	is a cryptographic commitment to the total supply of assets in a
+	Universe.
+	`,
+	Subcommands: []cli.Command{
+		ignoreAssetOutPointCmd,
+		updateSupplyCommitCmd,
+		fetchSupplyCommitCmd,
+	},
+}
+
+var ignoreAssetOutPointCmd = cli.Command{
+	Name:  "ignore",
+	Usage: "ignores an asset outpoint when committing to the asset supply",
+	Description: "This command allows us to ignore a specific asset UTXO " +
+		"when creating a new supply commitment. This is useful if " +
+		"an otherwise valid asset should not be counted towards the " +
+		"total asset group supply.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name: "asset_anchor_point",
+			Usage: "the asset anchor point to ignore, specified " +
+				"as txid:vout",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     assetIDName,
+			Usage:    "the asset ID of the asset to ignore",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     scriptKeyName,
+			Usage:    "the script key of the asset to ignore",
+			Required: true,
+		},
+		&cli.Uint64Flag{
+			Name: "amount",
+			Usage: "the amount of the asset at the anchor " +
+				"outpoint",
+			Required: true,
+		},
+	},
+	Action: ignoreAssetOutPoint,
+}
+
+func ignoreAssetOutPoint(ctx *cli.Context) error {
+	cliCtx := getContext()
+	client, cleanUp := getUniverseClient(ctx)
+	defer cleanUp()
+
+	anchorPointStr := ctx.String("asset_anchor_point")
+
+	assetID, err := hex.DecodeString(ctx.String(assetIDName))
+	if err != nil {
+		return fmt.Errorf("invalid asset_id: %w", err)
+	}
+
+	scriptKey, err := hex.DecodeString(ctx.String(scriptKeyName))
+	if err != nil {
+		return fmt.Errorf("invalid script_key: %w", err)
+	}
+
+	req := &unirpc.IgnoreAssetOutPointRequest{
+		AssetOutPoint: &taprpc.AssetOutPoint{
+			AnchorOutPoint: anchorPointStr,
+			AssetId:        assetID,
+			ScriptKey:      scriptKey,
+		},
+		Amount: ctx.Uint64("amount"),
+	}
+
+	resp, err := client.IgnoreAssetOutPoint(cliCtx, req)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+	return nil
+}
+
+var updateSupplyCommitCmd = cli.Command{
+	Name:  "update",
+	Usage: "updates the on-chain supply commitment for an asset group",
+	Description: "This command updates the on-chain supply " +
+		"commitment for a specific asset group.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:     "group_key",
+			Usage:    "the group key of the asset group to update",
+			Required: true,
+		},
+	},
+	Action: updateSupplyCommit,
+}
+
+func updateSupplyCommit(ctx *cli.Context) error {
+	cliCtx := getContext()
+	client, cleanUp := getUniverseClient(ctx)
+	defer cleanUp()
+
+	req := &unirpc.UpdateSupplyCommitRequest{
+		GroupKey: &unirpc.UpdateSupplyCommitRequest_GroupKeyStr{
+			GroupKeyStr: ctx.String("group_key"),
+		},
+	}
+
+	resp, err := client.UpdateSupplyCommit(cliCtx, req)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+	return nil
+}
+
+var fetchSupplyCommitCmd = cli.Command{
+	Name:  "fetch",
+	Usage: "fetches the on-chain supply commitment for an asset group",
+	Description: "This command fetches the on-chain supply " +
+		"commitment for a specific asset group.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:     "group_key",
+			Usage:    "the group key of the asset group to fetch",
+			Required: true,
+		},
+		&cli.StringSliceFlag{
+			Name: "issuance_leaf_keys",
+			Usage: "a list of issuance leaf keys to fetch " +
+				"inclusion proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "burn_leaf_keys",
+			Usage: "a list of burn leaf keys to fetch inclusion " +
+				"proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "ignore_leaf_keys",
+			Usage: "a list of ignore leaf keys to fetch " +
+				"inclusion proofs for",
+		},
+	},
+	Action: fetchSupplyCommit,
+}
+
+func fetchSupplyCommit(ctx *cli.Context) error {
+	cliCtx := getContext()
+	client, cleanUp := getUniverseClient(ctx)
+	defer cleanUp()
+
+	req := &unirpc.FetchSupplyCommitRequest{
+		GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyStr{
+			GroupKeyStr: ctx.String("group_key"),
+		},
+	}
+
+	issuanceKeys, err := parseHexStrings(
+		ctx.StringSlice("issuance_leaf_keys"),
+	)
+	if err != nil {
+		return fmt.Errorf("invalid issuance_leaf_keys: %w", err)
+	}
+	req.IssuanceLeafKeys = issuanceKeys
+
+	burnKeys, err := parseHexStrings(ctx.StringSlice("burn_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid burn_leaf_keys: %w", err)
+	}
+	req.BurnLeafKeys = burnKeys
+
+	ignoreKeys, err := parseHexStrings(ctx.StringSlice("ignore_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid ignore_leaf_keys: %w", err)
+	}
+	req.IgnoreLeafKeys = ignoreKeys
+
+	resp, err := client.FetchSupplyCommit(cliCtx, req)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+	return nil
+}
+
+// parseHexStrings converts a slice of hex-encoded strings into a slice of byte
+// slices. Each string in hexStrings must be a valid hex representation, or an
+// error is returned.
+func parseHexStrings(hexStrings []string) ([][]byte, error) {
+	result := make([][]byte, len(hexStrings))
+
+	for i, hexStr := range hexStrings {
+		decoded, err := hex.DecodeString(hexStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid hex string %q: %w",
+				hexStr, err)
+		}
+
+		result[i] = decoded
+	}
+
+	return result, nil
+}
diff --git a/mssmt/proof.go b/mssmt/proof.go
index 3114c5f3..031fc4c2 100644
--- a/mssmt/proof.go
+++ b/mssmt/proof.go
@@ -42,7 +42,7 @@ func NewProof(nodes []Node) *Proof {
 }
 
 // Root returns the root node obtained by walking up the tree.
-func (p Proof) Root(key [32]byte, leaf *LeafNode) *BranchNode {
+func (p Proof) Root(key [32]byte, leaf Node) *BranchNode {
 	// Note that we don't need to check the error here since the only point
 	// where the error could come from is the passed iterator which is nil.
 	node, _ := walkUp(&key, leaf, p.Nodes, nil)
diff --git a/mssmt/tree.go b/mssmt/tree.go
index 577d15e5..60e81218 100644
--- a/mssmt/tree.go
+++ b/mssmt/tree.go
@@ -145,10 +145,10 @@ func (t *FullTree) walkDown(tx TreeStoreViewTx, key *[hashSize]byte,
 
 // walkUp walks up from the `start` leaf node up to the root with the help of
 // `siblings`. The root branch node computed is returned.
-func walkUp(key *[hashSize]byte, start *LeafNode, siblings []Node,
+func walkUp(key *[hashSize]byte, start Node, siblings []Node,
 	iter iterFunc) (*BranchNode, error) {
 
-	var current Node = start
+	var current = start
 	for i := lastBitIndex; i >= 0; i-- {
 		sibling := siblings[lastBitIndex-i]
 		var parent Node
diff --git a/rpcserver.go b/rpcserver.go
index f8392105..3503446e 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -57,6 +57,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/tapscript"
 	"github.com/lightninglabs/taproot-assets/tapsend"
 	"github.com/lightninglabs/taproot-assets/universe"
+	"github.com/lightninglabs/taproot-assets/universe/supplycommit"
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/lnrpc"
@@ -3796,6 +3797,457 @@ func marshalOutputType(outputType tappsbt.VOutputType) (taprpc.OutputType,
 	}
 }
 
+// IgnoreAssetOutPointRequest is the request type for the IgnoreAssetOutPoint
+// RPC method.
+type IgnoreAssetOutPointRequest struct {
+	// AssetAnchorPoint is the asset anchor point to ignore.
+	AssetAnchorPoint asset.AnchorPoint
+
+	// Amount is the amount of the asset at the anchor outpoint.
+	Amount uint64
+}
+
+// unmarshalIgnoreAssetOutPointRequest converts the RPC request into the
+// native request type.
+func unmarshalIgnoreAssetOutPointRequest(
+	req *unirpc.IgnoreAssetOutPointRequest) (IgnoreAssetOutPointRequest,
+	error) {
+
+	var zero IgnoreAssetOutPointRequest
+
+	// Parse asset outpoint from the request.
+	assetOutPoint, err := rpcutils.UnmarshalAssetOutPoint(req.AssetOutPoint)
+	if err != nil {
+		return zero, fmt.Errorf("failed to parse asset outpoint: %w",
+			err)
+	}
+
+	return IgnoreAssetOutPointRequest{
+		AssetAnchorPoint: assetOutPoint,
+		Amount:           req.Amount,
+	}, nil
+}
+
+// IgnoreAssetOutPoint allows an asset issuer to mark a specific asset outpoint
+// as ignored. An ignored outpoint will be included in the next universe
+// commitment transaction that is published.
+func (r *rpcServer) IgnoreAssetOutPoint(ctx context.Context,
+	rpcReq *unirpc.IgnoreAssetOutPointRequest) (
+	*unirpc.IgnoreAssetOutPointResponse, error) {
+
+	// Unmarshal the request into the native type.
+	req, err := unmarshalIgnoreAssetOutPointRequest(rpcReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal request: %w", err)
+	}
+
+	assetID := req.AssetAnchorPoint.ID
+
+	// Fetch the asset group for the given asset ID.
+	assetGroup, err := r.cfg.TapAddrBook.QueryAssetGroup(ctx, assetID)
+	if err != nil {
+		return nil, fmt.Errorf("fail to find asset group given "+
+			"asset ID: %w", err)
+	}
+
+	// Formulate an asset specifier from the asset ID and group key.
+	assetSpec := asset.NewSpecifierOptionalGroupKey(
+		assetID, assetGroup.GroupKey,
+	)
+
+	// Retrieve asset meta reveal for the asset ID. This will be used to
+	// obtain the supply commitment delegation key.
+	metaReveal, err := r.cfg.TapAddrBook.FetchAssetMetaForAsset(
+		ctx, assetID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("faild to fetch asset meta: %w", err)
+	}
+
+	// Extract supply commitment delegation pub key from the asset metadata.
+	delegationPubKey, err := metaReveal.DelegationKey.UnwrapOrErr(
+		fmt.Errorf("delegation key not found for given asset"),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// Fetch the delegation key locator.
+	delegationKeyLoc, err := r.cfg.TapAddrBook.FetchInternalKeyLocator(
+		ctx, &delegationPubKey,
+	)
+	switch {
+	case errors.Is(err, address.ErrInternalKeyNotFound):
+		return nil, fmt.Errorf("delegation key locator not found; " +
+			"only delegation key owners can ignore asset " +
+			"outpoints for this asset group")
+	case err != nil:
+		return nil, fmt.Errorf("failed to fetch delegation key "+
+			"locator: %w", err)
+	}
+	// Formulate the ignore entry and sign it with the delegation key.
+	ignoreTuple := universe.IgnoreTuple{
+		PrevID: req.AssetAnchorPoint,
+		Amount: req.Amount,
+	}
+
+	signedIgnore, err := ignoreTuple.GenSignedIgnore(
+		ctx, r.cfg.Lnd.Signer, delegationKeyLoc,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign ignore tuple: %w", err)
+	}
+
+	// Upsert a signed ignore tuple into the ignore tree archive and
+	// get back the authenticated ignore tuples.
+	ignoreEvent := supplycommit.NewIgnoreEvent{
+		SignedIgnoreTuple: signedIgnore,
+	}
+	err = r.cfg.SupplyCommitManager.SendEvent(ctx, assetSpec, &ignoreEvent)
+	if err != nil {
+		return nil, fmt.Errorf("failed to upsert ignore tuple: %w", err)
+	}
+
+	leafNode, err := signedIgnore.UniverseLeafNode()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get universe leaf node: %w",
+			err)
+	}
+
+	return &unirpc.IgnoreAssetOutPointResponse{
+		LeafKey: fn.ByteSlice(signedIgnore.UniverseKey()),
+		Leaf:    marshalMssmtNode(leafNode),
+	}, nil
+}
+
+// UpdateSupplyCommit updates the on-chain supply commitment for a specific
+// asset group.
+func (r *rpcServer) UpdateSupplyCommit(ctx context.Context,
+	req *unirpc.UpdateSupplyCommitRequest) (
+	*unirpc.UpdateSupplyCommitResponse, error) {
+
+	// Parse asset group key from the request.
+	var groupPubKey btcec.PublicKey
+
+	switch {
+	case len(req.GetGroupKeyBytes()) > 0:
+		gk, err := btcec.ParsePubKey(req.GetGroupKeyBytes())
+		if err != nil {
+			return nil, fmt.Errorf("parsing group key: %w", err)
+		}
+
+		groupPubKey = *gk
+
+	case len(req.GetGroupKeyStr()) > 0:
+		groupKeyBytes, err := hex.DecodeString(req.GetGroupKeyStr())
+		if err != nil {
+			return nil, fmt.Errorf("decoding group key: %w", err)
+		}
+
+		gk, err := btcec.ParsePubKey(groupKeyBytes)
+		if err != nil {
+			return nil, fmt.Errorf("parsing group key: %w", err)
+		}
+
+		groupPubKey = *gk
+
+	default:
+		return nil, fmt.Errorf("group key unspecified")
+	}
+
+	// We will now check to ensure that universe commitments are enabled for
+	// the asset group.
+	//
+	// Look up the asset group by the group key.
+	assetGroup, err := r.cfg.TapAddrBook.QueryAssetGroupByGroupKey(
+		ctx, &groupPubKey,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to find asset group "+
+			"given group key: %w", err)
+	}
+
+	// Fetch the asset metadata given the group anchor asset ID.
+	metaReveal, err := r.cfg.TapAddrBook.FetchAssetMetaForAsset(
+		ctx, assetGroup.ID(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("faild to fetch asset meta: %w", err)
+	}
+
+	// Ensure that universe commitment is enabled for the asset group.
+	if !metaReveal.UniverseCommitments {
+		return nil, fmt.Errorf("universe commitment is not " +
+			"enabled for asset group anchor asset")
+	}
+
+	// Formulate an asset specifier from the asset group key.
+	assetSpec := asset.NewSpecifierFromGroupKey(groupPubKey)
+
+	// Send a commit tick event to the supply commitment manager.
+	event := supplycommit.CommitTickEvent{}
+	err = r.cfg.SupplyCommitManager.SendEvent(ctx, assetSpec, &event)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send commit tick event: %w",
+			err)
+	}
+
+	return &unirpc.UpdateSupplyCommitResponse{}, nil
+}
+
+// inclusionProofs fetches the inclusion proofs for the given leaf keys from
+// the provided MSSMT tree. The leaf keys are expected to be 32-byte long.
+func inclusionProofs(ctx context.Context, tree mssmt.Tree,
+	leafKeys [][]byte) ([][]byte, error) {
+
+	proofs := make([][]byte, 0, len(leafKeys))
+	for idx := range leafKeys {
+		leafKey := leafKeys[idx]
+
+		if len(leafKey) != 32 {
+			return nil, fmt.Errorf("leaf key is not 32 bytes long")
+		}
+
+		var key [32]byte
+		copy(key[:], leafKey)
+
+		inclusionProof, err := tree.MerkleProof(ctx, key)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get inclusion proof "+
+				"for leaf key %x: %w", leafKey, err)
+		}
+
+		proofBytes, err := marshalMssmtProof(inclusionProof)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal inclusion "+
+				"proof for leaf key %x: %w", leafKey, err)
+		}
+
+		proofs = append(proofs, proofBytes)
+	}
+
+	return proofs, nil
+}
+
+// supplySubtreeRoot fetches the root of a specific supply subtree and its
+// supply tree inclusion proof.
+func supplySubtreeRoot(ctx context.Context, supplyTree mssmt.Tree,
+	subtrees supplycommit.SupplyTrees,
+	subtreeType supplycommit.SupplySubTree) (
+	*unirpc.SupplyCommitSubtreeRoot, error) {
+
+	// Fetch supply subtree root for the given subtree type.
+	subtree := subtrees[subtreeType]
+	subtreeRoot, err := subtree.Root(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get supply subtree root: "+
+			"%w", err)
+	}
+
+	// Fetch subtree inclusion proof for the given subtree type. This can
+	// be used to verify that the subtree root is indeed part of the
+	// supply tree.
+	subtreeRootLeafKey := subtreeType.UniverseKey()
+	subtreeInclusionProof, err := supplyTree.MerkleProof(
+		ctx, subtreeRootLeafKey,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get supply subtree "+
+			"inclusion proof: %w", err)
+	}
+
+	inclusionProofBytes, err := marshalMssmtProof(subtreeInclusionProof)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal inclusion "+
+			"proof for issuance subtree: %w", err)
+	}
+
+	return &unirpc.SupplyCommitSubtreeRoot{
+		Type:                     subtreeType.String(),
+		RootNode:                 marshalMssmtNode(subtreeRoot),
+		SupplyTreeLeafKey:        subtreeRootLeafKey[:],
+		SupplyTreeInclusionProof: inclusionProofBytes,
+	}, nil
+}
+
+// FetchSupplyCommit fetches the on-chain supply commitment for a specific
+// asset group.
+func (r *rpcServer) FetchSupplyCommit(ctx context.Context,
+	req *unirpc.FetchSupplyCommitRequest) (
+	*unirpc.FetchSupplyCommitResponse, error) {
+
+	// Parse asset group key from the request.
+	var groupPubKey btcec.PublicKey
+
+	switch {
+	case len(req.GetGroupKeyBytes()) > 0:
+		gk, err := btcec.ParsePubKey(req.GetGroupKeyBytes())
+		if err != nil {
+			return nil, fmt.Errorf("parsing group key: %w", err)
+		}
+
+		groupPubKey = *gk
+
+	case len(req.GetGroupKeyStr()) > 0:
+		groupKeyBytes, err := hex.DecodeString(req.GetGroupKeyStr())
+		if err != nil {
+			return nil, fmt.Errorf("decoding group key: %w", err)
+		}
+
+		gk, err := btcec.ParsePubKey(groupKeyBytes)
+		if err != nil {
+			return nil, fmt.Errorf("parsing group key: %w", err)
+		}
+
+		groupPubKey = *gk
+
+	default:
+		return nil, fmt.Errorf("group key unspecified")
+	}
+
+	// Formulate an asset specifier from the asset group key.
+	assetSpec := asset.NewSpecifierFromGroupKey(groupPubKey)
+
+	// Fetch the supply commitment for the asset specifier.
+	respOpt, err := r.cfg.SupplyCommitManager.FetchCommitment(
+		ctx, assetSpec,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch supply commit: %w",
+			err)
+	}
+	if respOpt.IsNone() {
+		return nil, fmt.Errorf("supply commitment not found for "+
+			"asset group with key %x",
+			groupPubKey.SerializeCompressed())
+	}
+	resp, err := respOpt.UnwrapOrErr(fmt.Errorf("unexpected None value " +
+		"for supply commitment response"))
+	if err != nil {
+		return nil, err
+	}
+
+	supplyTreeRoot, err := resp.SupplyTree.Root(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get supply tree root: %w",
+			err)
+	}
+
+	// Fetch subtree commitment root and inclusion proofs for the issuance
+	// subtree.
+	rpcIssuanceSubtreeRoot, err := supplySubtreeRoot(
+		ctx, resp.SupplyTree, resp.Subtrees, supplycommit.MintTreeType,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch supply issuance "+
+			"subtree root: %w", err)
+	}
+
+	// Fetch subtree commitment root and inclusion proofs for the burn
+	// subtree.
+	rpcBurnSubtreeRoot, err := supplySubtreeRoot(
+		ctx, resp.SupplyTree, resp.Subtrees, supplycommit.BurnTreeType,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch supply burn subtree "+
+			"root: %w", err)
+	}
+
+	// Fetch subtree commitment root and inclusion proofs for the ignore
+	// subtree.
+	rpcIgnoreSubtreeRoot, err := supplySubtreeRoot(
+		ctx, resp.SupplyTree, resp.Subtrees,
+		supplycommit.IgnoreTreeType,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch supply ignore subtree "+
+			"root: %w", err)
+	}
+
+	// Get inclusion proofs for any issuance leaf key specified in the
+	// request.
+	issuanceTree := resp.Subtrees[supplycommit.MintTreeType]
+	issuanceInclusionProofs, err := inclusionProofs(
+		ctx, issuanceTree, req.IssuanceLeafKeys,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch issuance tree "+
+			"inclusion proofs: %w", err)
+	}
+
+	// Get inclusion proofs for any burn leaf key specified in the request.
+	burnTree := resp.Subtrees[supplycommit.BurnTreeType]
+	burnInclusionProofs, err := inclusionProofs(
+		ctx, burnTree, req.BurnLeafKeys,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch burn tree "+
+			"inclusion proofs: %w", err)
+	}
+
+	// Get inclusion proofs for any ignore leaf key specified in the
+	// request.
+	ignoreTree := resp.Subtrees[supplycommit.IgnoreTreeType]
+	ignoreInclusionProofs, err := inclusionProofs(
+		ctx, ignoreTree, req.IgnoreLeafKeys,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch ignore tree "+
+			"inclusion proofs: %w", err)
+	}
+
+	// Sanity check: ensure the supply root derived from the supply tree
+	// matches the root provided in the chain commitment.
+	if resp.ChainCommitment.SupplyRoot.NodeHash() !=
+		supplyTreeRoot.NodeHash() {
+
+		return nil, fmt.Errorf("mismatched supply commitment root: "+
+			"expected %x, got %x",
+			resp.ChainCommitment.SupplyRoot.NodeHash(),
+			supplyTreeRoot.NodeHash())
+	}
+
+	txOutInternalKey := resp.ChainCommitment.InternalKey.PubKey
+
+	// Extract the block height and hash from the chain commitment if
+	// present.
+	var (
+		blockHeight uint32
+		blockHash   []byte
+		txIndex     uint32
+		chainFees   int64
+	)
+	resp.ChainCommitment.CommitmentBlock.WhenSome(
+		func(b supplycommit.CommitmentBlock) {
+			blockHeight = b.Height
+			blockHash = b.Hash[:]
+			txIndex = b.TxIndex
+			chainFees = b.ChainFees
+		},
+	)
+
+	return &unirpc.FetchSupplyCommitResponse{
+		SupplyCommitmentRoot: marshalMssmtNode(supplyTreeRoot),
+
+		AnchorTxid:             resp.ChainCommitment.Txn.TxID(),
+		AnchorTxOutIdx:         resp.ChainCommitment.TxOutIdx,
+		AnchorTxOutInternalKey: txOutInternalKey.SerializeCompressed(),
+
+		BlockHeight:     blockHeight,
+		BlockHash:       blockHash,
+		BlockTxIndex:    txIndex,
+		TxChainFeesSats: chainFees,
+
+		IssuanceSubtreeRoot: rpcIssuanceSubtreeRoot,
+		BurnSubtreeRoot:     rpcBurnSubtreeRoot,
+		IgnoreSubtreeRoot:   rpcIgnoreSubtreeRoot,
+
+		IssuanceLeafInclusionProofs: issuanceInclusionProofs,
+		BurnLeafInclusionProofs:     burnInclusionProofs,
+		IgnoreLeafInclusionProofs:   ignoreInclusionProofs,
+	}, nil
+}
+
 // SubscribeSendAssetEventNtfns registers a subscription to the event
 // notification stream which relates to the asset sending process.
 func (r *rpcServer) SubscribeSendAssetEventNtfns(
@@ -3818,7 +4270,9 @@ func (r *rpcServer) SubscribeReceiveAssetEventNtfns(
 	_ *tapdevrpc.SubscribeReceiveAssetEventNtfnsRequest,
 	ntfnStream devReceiveEventStream) error {
 
-	marshaler := func(event fn.Event) (*tapdevrpc.ReceiveAssetEvent, error) {
+	marshaler := func(event fn.Event) (*tapdevrpc.ReceiveAssetEvent,
+		error) {
+
 		return marshallReceiveAssetEvent(
 			event, r.cfg.TapAddrBook,
 		)
diff --git a/rpcutils/marshal.go b/rpcutils/marshal.go
index 1dbeaf33..c26ae736 100644
--- a/rpcutils/marshal.go
+++ b/rpcutils/marshal.go
@@ -761,3 +761,44 @@ func ParseScriptKeyTypeQuery(
 		return fn.Some(asset.ScriptKeyBip86), false, nil
 	}
 }
+
+// UnmarshalAssetOutPoint parses an asset outpoint from the RPC variant.
+func UnmarshalAssetOutPoint(
+	rpcAssetOutPoint *taprpc.AssetOutPoint) (asset.AnchorPoint, error) {
+
+	var zero asset.AnchorPoint
+
+	if rpcAssetOutPoint == nil {
+		return zero, fmt.Errorf("unexpected nil RPC outpoint")
+	}
+
+	// Unmarshal anchor outpoint.
+	anchorOutPoint, err := wire.NewOutPointFromString(
+		rpcAssetOutPoint.AnchorOutPoint,
+	)
+	if err != nil {
+		return zero, fmt.Errorf("failed to parse anchor outpoint: %w",
+			err)
+	}
+
+	// Unmarshal asset ID.
+	assetID, err := asset.NewIDFromBytes(rpcAssetOutPoint.AssetId)
+	if err != nil {
+		return zero, fmt.Errorf("failed to parse asset ID: %w", err)
+	}
+
+	// Unmarshal serialized script key.
+	serializedScriptKey, err := asset.NewSerializedKeyFromBytes(
+		rpcAssetOutPoint.ScriptKey,
+	)
+	if err != nil {
+		return zero, fmt.Errorf("failed to parse script key: "+
+			"%w", err)
+	}
+
+	return asset.AnchorPoint{
+		OutPoint:  *anchorOutPoint,
+		ID:        assetID,
+		ScriptKey: serializedScriptKey,
+	}, nil
+}
diff --git a/tapdb/sqlc/queries/supply_commit.sql b/tapdb/sqlc/queries/supply_commit.sql
index 031e0792..c94d2f1f 100644
--- a/tapdb/sqlc/queries/supply_commit.sql
+++ b/tapdb/sqlc/queries/supply_commit.sql
@@ -163,6 +163,10 @@ SELECT
     sc.output_key,
     sqlc.embed(ik),
     txn.raw_tx,
+    txn.block_height,
+    txn.block_hash,
+    txn.tx_index,
+    txn.chain_fees,
     sc.supply_root_hash AS root_hash,
     sc.supply_root_sum AS root_sum 
 FROM supply_commit_state_machines sm
diff --git a/tapdb/sqlc/supply_commit.sql.go b/tapdb/sqlc/supply_commit.sql.go
index 56f25493..5b81df51 100644
--- a/tapdb/sqlc/supply_commit.sql.go
+++ b/tapdb/sqlc/supply_commit.sql.go
@@ -74,6 +74,10 @@ SELECT
     sc.output_key,
     ik.key_id, ik.raw_key, ik.key_family, ik.key_index,
     txn.raw_tx,
+    txn.block_height,
+    txn.block_hash,
+    txn.tx_index,
+    txn.chain_fees,
     sc.supply_root_hash AS root_hash,
     sc.supply_root_sum AS root_sum 
 FROM supply_commit_state_machines sm
@@ -94,6 +98,10 @@ type FetchSupplyCommitRow struct {
 	OutputKey   []byte
 	InternalKey InternalKey
 	RawTx       []byte
+	BlockHeight sql.NullInt32
+	BlockHash   []byte
+	TxIndex     sql.NullInt32
+	ChainFees   int64
 	RootHash    []byte
 	RootSum     sql.NullInt64
 }
@@ -110,6 +118,10 @@ func (q *Queries) FetchSupplyCommit(ctx context.Context, groupKey []byte) (Fetch
 		&i.InternalKey.KeyFamily,
 		&i.InternalKey.KeyIndex,
 		&i.RawTx,
+		&i.BlockHeight,
+		&i.BlockHash,
+		&i.TxIndex,
+		&i.ChainFees,
 		&i.RootHash,
 		&i.RootSum,
 	)
diff --git a/tapdb/supply_commit.go b/tapdb/supply_commit.go
index 718792ce..25f987f6 100644
--- a/tapdb/supply_commit.go
+++ b/tapdb/supply_commit.go
@@ -10,8 +10,10 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
@@ -330,6 +332,41 @@ func (s *SupplyCommitMachine) SupplyCommit(ctx context.Context,
 				err)
 		}
 
+		// Parse block related data from row if present.
+		var commitmentBlock fn.Option[supplycommit.CommitmentBlock]
+		if len(row.BlockHash) > 0 {
+			// Parse block height if present, otherwise return an
+			// error as it must be set if block hash is set.
+			if !row.BlockHeight.Valid {
+				return fmt.Errorf("block height must be set " +
+					"if block hash is set")
+			}
+
+			blockHeight := uint32(row.BlockHeight.Int32)
+
+			// Parse the block hash, which should be valid at this
+			// point.
+			blockHash, err := chainhash.NewHash(row.BlockHash)
+			if err != nil {
+				return fmt.Errorf("parsing block hash: %w", err)
+			}
+
+			// Parse transaction block index which should be set
+			// if the block height is set.
+			if !row.TxIndex.Valid {
+				return fmt.Errorf("transaction index must be " +
+					"set if block height is set")
+			}
+			txIndex := uint32(row.TxIndex.Int32)
+
+			commitmentBlock = fn.Some(supplycommit.CommitmentBlock{
+				Hash:      *blockHash,
+				Height:    blockHeight,
+				TxIndex:   txIndex,
+				ChainFees: row.ChainFees,
+			})
+		}
+
 		// Construct the root node directly from the stored hash and
 		// sum. Handle potential NULL values if the root wasn't set yet
 		// (though FetchSupplyCommit filters for confirmed TX, so it
@@ -355,11 +392,12 @@ func (s *SupplyCommitMachine) SupplyCommit(ctx context.Context,
 		}
 
 		rootCommitment := supplycommit.RootCommitment{
-			Txn:         &commitTx,
-			TxOutIdx:    uint32(row.OutputIndex.Int32),
-			InternalKey: internalKey,
-			OutputKey:   outputKey,
-			SupplyRoot:  rootNode,
+			Txn:             &commitTx,
+			TxOutIdx:        uint32(row.OutputIndex.Int32),
+			InternalKey:     internalKey,
+			OutputKey:       outputKey,
+			SupplyRoot:      rootNode,
+			CommitmentBlock: commitmentBlock,
 		}
 		rootCommitmentOpt = lfn.Some(rootCommitment)
 
diff --git a/taprpc/perms.go b/taprpc/perms.go
index 6fdbf8bf..10ac4c04 100644
--- a/taprpc/perms.go
+++ b/taprpc/perms.go
@@ -255,6 +255,18 @@ var (
 			Entity: "universe",
 			Action: "read",
 		}},
+		"/universerpc.Universe/IgnoreAssetOutPoint": {{
+			Entity: "universe",
+			Action: "write",
+		}},
+		"/universerpc.Universe/UpdateSupplyCommit": {{
+			Entity: "universe",
+			Action: "write",
+		}},
+		"/universerpc.Universe/FetchSupplyCommit": {{
+			Entity: "universe",
+			Action: "read",
+		}},
 		"/rfqrpc.Rfq/AddAssetBuyOrder": {{
 			Entity: "rfq",
 			Action: "write",
diff --git a/taprpc/tapcommon.pb.go b/taprpc/tapcommon.pb.go
index b6c3896b..a91d9305 100644
--- a/taprpc/tapcommon.pb.go
+++ b/taprpc/tapcommon.pb.go
@@ -78,6 +78,79 @@ func (x *OutPoint) GetOutputIndex() uint32 {
 	return 0
 }
 
+// A transaction outpoint annotated with TAP-level asset metadata. It uniquely
+// identifies an asset anchored at a specific outpoint.
+type AssetOutPoint struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The outpoint of the asset anchor, represented as a string in the
+	// format "<txid>:<vout>". The <txid> is the transaction ID of the UTXO,
+	// hex-encoded and byte-reversed (i.e., the internal little-endian
+	// 32-byte value is reversed to big-endian hex format) to match standard
+	// Bitcoin RPC and UI conventions.
+	AnchorOutPoint string `protobuf:"bytes,1,opt,name=anchor_out_point,json=anchorOutPoint,proto3" json:"anchor_out_point,omitempty"`
+	// The asset ID of the asset anchored at the outpoint.
+	AssetId []byte `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
+	// The script key of the asset. This is the taproot output key that the
+	// asset is locked to.
+	ScriptKey []byte `protobuf:"bytes,3,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"`
+}
+
+func (x *AssetOutPoint) Reset() {
+	*x = AssetOutPoint{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_tapcommon_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AssetOutPoint) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AssetOutPoint) ProtoMessage() {}
+
+func (x *AssetOutPoint) ProtoReflect() protoreflect.Message {
+	mi := &file_tapcommon_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AssetOutPoint.ProtoReflect.Descriptor instead.
+func (*AssetOutPoint) Descriptor() ([]byte, []int) {
+	return file_tapcommon_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *AssetOutPoint) GetAnchorOutPoint() string {
+	if x != nil {
+		return x.AnchorOutPoint
+	}
+	return ""
+}
+
+func (x *AssetOutPoint) GetAssetId() []byte {
+	if x != nil {
+		return x.AssetId
+	}
+	return nil
+}
+
+func (x *AssetOutPoint) GetScriptKey() []byte {
+	if x != nil {
+		return x.ScriptKey
+	}
+	return nil
+}
+
 var File_tapcommon_proto protoreflect.FileDescriptor
 
 var file_tapcommon_proto_rawDesc = []byte{
@@ -86,11 +159,18 @@ var file_tapcommon_proto_rawDesc = []byte{
 	0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x69, 0x64, 0x18, 0x01, 0x20,
 	0x01, 0x28, 0x0c, 0x52, 0x04, 0x74, 0x78, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74,
 	0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52,
-	0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x30, 0x5a, 0x2e,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x6e, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74,
-	0x2d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x73, 0x0a, 0x0d,
+	0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x28, 0x0a,
+	0x10, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x70, 0x6f, 0x69, 0x6e,
+	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x4f,
+	0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x73, 0x73, 0x65, 0x74,
+	0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74,
+	0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65,
+	0x79, 0x42, 0x30, 0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x74, 0x61,
+	0x70, 0x72, 0x6f, 0x6f, 0x74, 0x2d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2f, 0x74, 0x61, 0x70,
+	0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -105,9 +185,10 @@ func file_tapcommon_proto_rawDescGZIP() []byte {
 	return file_tapcommon_proto_rawDescData
 }
 
-var file_tapcommon_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_tapcommon_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
 var file_tapcommon_proto_goTypes = []any{
-	(*OutPoint)(nil), // 0: taprpc.OutPoint
+	(*OutPoint)(nil),      // 0: taprpc.OutPoint
+	(*AssetOutPoint)(nil), // 1: taprpc.AssetOutPoint
 }
 var file_tapcommon_proto_depIdxs = []int32{
 	0, // [0:0] is the sub-list for method output_type
@@ -135,6 +216,18 @@ func file_tapcommon_proto_init() {
 				return nil
 			}
 		}
+		file_tapcommon_proto_msgTypes[1].Exporter = func(v any, i int) any {
+			switch v := v.(*AssetOutPoint); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -142,7 +235,7 @@ func file_tapcommon_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_tapcommon_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   1,
+			NumMessages:   2,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/taprpc/tapcommon.proto b/taprpc/tapcommon.proto
index 7f865116..c7613711 100644
--- a/taprpc/tapcommon.proto
+++ b/taprpc/tapcommon.proto
@@ -16,3 +16,21 @@ message OutPoint {
     */
     uint32 output_index = 2;
 }
+
+// A transaction outpoint annotated with TAP-level asset metadata. It uniquely
+// identifies an asset anchored at a specific outpoint.
+message AssetOutPoint {
+    // The outpoint of the asset anchor, represented as a string in the
+    // format "<txid>:<vout>". The <txid> is the transaction ID of the UTXO,
+    // hex-encoded and byte-reversed (i.e., the internal little-endian
+    // 32-byte value is reversed to big-endian hex format) to match standard
+    // Bitcoin RPC and UI conventions.
+    string anchor_out_point = 1;
+
+    // The asset ID of the asset anchored at the outpoint.
+    bytes asset_id = 2;
+
+    // The script key of the asset. This is the taproot output key that the
+    // asset is locked to.
+    bytes script_key = 3;
+}
diff --git a/taprpc/universerpc/universe.pb.go b/taprpc/universerpc/universe.pb.go
index 9389b90e..52ad2cdb 100644
--- a/taprpc/universerpc/universe.pb.go
+++ b/taprpc/universerpc/universe.pb.go
@@ -3367,560 +3367,1294 @@ func (x *QueryFederationSyncConfigResponse) GetAssetSyncConfigs() []*AssetFedera
 	return nil
 }
 
+type IgnoreAssetOutPointRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The outpoint of the asset to ignore.
+	AssetOutPoint *taprpc.AssetOutPoint `protobuf:"bytes,1,opt,name=asset_out_point,json=assetOutPoint,proto3" json:"asset_out_point,omitempty"`
+	// The amount of asset units at the associated asset outpoint.
+	Amount uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *IgnoreAssetOutPointRequest) Reset() {
+	*x = IgnoreAssetOutPointRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[51]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *IgnoreAssetOutPointRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*IgnoreAssetOutPointRequest) ProtoMessage() {}
+
+func (x *IgnoreAssetOutPointRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[51]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use IgnoreAssetOutPointRequest.ProtoReflect.Descriptor instead.
+func (*IgnoreAssetOutPointRequest) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{51}
+}
+
+func (x *IgnoreAssetOutPointRequest) GetAssetOutPoint() *taprpc.AssetOutPoint {
+	if x != nil {
+		return x.AssetOutPoint
+	}
+	return nil
+}
+
+func (x *IgnoreAssetOutPointRequest) GetAmount() uint64 {
+	if x != nil {
+		return x.Amount
+	}
+	return 0
+}
+
+type IgnoreAssetOutPointResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The key identifying the signed ignore outpoint leaf in the ignore supply
+	// commitment subtree.
+	LeafKey []byte `protobuf:"bytes,1,opt,name=leaf_key,json=leafKey,proto3" json:"leaf_key,omitempty"`
+	// The signed ignore outpoint leaf in the ignore supply commitment tree.
+	Leaf *MerkleSumNode `protobuf:"bytes,2,opt,name=leaf,proto3" json:"leaf,omitempty"`
+}
+
+func (x *IgnoreAssetOutPointResponse) Reset() {
+	*x = IgnoreAssetOutPointResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[52]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *IgnoreAssetOutPointResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*IgnoreAssetOutPointResponse) ProtoMessage() {}
+
+func (x *IgnoreAssetOutPointResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[52]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use IgnoreAssetOutPointResponse.ProtoReflect.Descriptor instead.
+func (*IgnoreAssetOutPointResponse) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{52}
+}
+
+func (x *IgnoreAssetOutPointResponse) GetLeafKey() []byte {
+	if x != nil {
+		return x.LeafKey
+	}
+	return nil
+}
+
+func (x *IgnoreAssetOutPointResponse) GetLeaf() *MerkleSumNode {
+	if x != nil {
+		return x.Leaf
+	}
+	return nil
+}
+
+type UpdateSupplyCommitRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The unique identifier for the target asset group whose supply commitment
+	// is being updated.
+	//
+	// Types that are assignable to GroupKey:
+	//
+	//	*UpdateSupplyCommitRequest_GroupKeyBytes
+	//	*UpdateSupplyCommitRequest_GroupKeyStr
+	GroupKey isUpdateSupplyCommitRequest_GroupKey `protobuf_oneof:"group_key"`
+}
+
+func (x *UpdateSupplyCommitRequest) Reset() {
+	*x = UpdateSupplyCommitRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[53]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UpdateSupplyCommitRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateSupplyCommitRequest) ProtoMessage() {}
+
+func (x *UpdateSupplyCommitRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[53]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateSupplyCommitRequest.ProtoReflect.Descriptor instead.
+func (*UpdateSupplyCommitRequest) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{53}
+}
+
+func (m *UpdateSupplyCommitRequest) GetGroupKey() isUpdateSupplyCommitRequest_GroupKey {
+	if m != nil {
+		return m.GroupKey
+	}
+	return nil
+}
+
+func (x *UpdateSupplyCommitRequest) GetGroupKeyBytes() []byte {
+	if x, ok := x.GetGroupKey().(*UpdateSupplyCommitRequest_GroupKeyBytes); ok {
+		return x.GroupKeyBytes
+	}
+	return nil
+}
+
+func (x *UpdateSupplyCommitRequest) GetGroupKeyStr() string {
+	if x, ok := x.GetGroupKey().(*UpdateSupplyCommitRequest_GroupKeyStr); ok {
+		return x.GroupKeyStr
+	}
+	return ""
+}
+
+type isUpdateSupplyCommitRequest_GroupKey interface {
+	isUpdateSupplyCommitRequest_GroupKey()
+}
+
+type UpdateSupplyCommitRequest_GroupKeyBytes struct {
+	// The 32-byte asset group key specified as raw bytes (gRPC only).
+	GroupKeyBytes []byte `protobuf:"bytes,1,opt,name=group_key_bytes,json=groupKeyBytes,proto3,oneof"`
+}
+
+type UpdateSupplyCommitRequest_GroupKeyStr struct {
+	// The 32-byte asset group key encoded as hex string (use this for
+	// REST).
+	GroupKeyStr string `protobuf:"bytes,2,opt,name=group_key_str,json=groupKeyStr,proto3,oneof"`
+}
+
+func (*UpdateSupplyCommitRequest_GroupKeyBytes) isUpdateSupplyCommitRequest_GroupKey() {}
+
+func (*UpdateSupplyCommitRequest_GroupKeyStr) isUpdateSupplyCommitRequest_GroupKey() {}
+
+type UpdateSupplyCommitResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *UpdateSupplyCommitResponse) Reset() {
+	*x = UpdateSupplyCommitResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[54]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UpdateSupplyCommitResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateSupplyCommitResponse) ProtoMessage() {}
+
+func (x *UpdateSupplyCommitResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[54]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateSupplyCommitResponse.ProtoReflect.Descriptor instead.
+func (*UpdateSupplyCommitResponse) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{54}
+}
+
+type FetchSupplyCommitRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The unique identifier for the target asset group whose supply commitment
+	// is being fetched.
+	//
+	// Types that are assignable to GroupKey:
+	//
+	//	*FetchSupplyCommitRequest_GroupKeyBytes
+	//	*FetchSupplyCommitRequest_GroupKeyStr
+	GroupKey isFetchSupplyCommitRequest_GroupKey `protobuf_oneof:"group_key"`
+	// Optional: A list of issuance leaf keys. For each key in this list,
+	// the endpoint will generate and return an inclusion proof.
+	IssuanceLeafKeys [][]byte `protobuf:"bytes,3,rep,name=issuance_leaf_keys,json=issuanceLeafKeys,proto3" json:"issuance_leaf_keys,omitempty"`
+	// Optional: A list of burn leaf keys. For each key in this list,
+	// the endpoint will generate and return an inclusion proof.
+	BurnLeafKeys [][]byte `protobuf:"bytes,4,rep,name=burn_leaf_keys,json=burnLeafKeys,proto3" json:"burn_leaf_keys,omitempty"`
+	// Optional: A list of ignore leaf keys. For each key in this list, the
+	// endpoint will generate and return an inclusion proof.
+	IgnoreLeafKeys [][]byte `protobuf:"bytes,5,rep,name=ignore_leaf_keys,json=ignoreLeafKeys,proto3" json:"ignore_leaf_keys,omitempty"`
+}
+
+func (x *FetchSupplyCommitRequest) Reset() {
+	*x = FetchSupplyCommitRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[55]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FetchSupplyCommitRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FetchSupplyCommitRequest) ProtoMessage() {}
+
+func (x *FetchSupplyCommitRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[55]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FetchSupplyCommitRequest.ProtoReflect.Descriptor instead.
+func (*FetchSupplyCommitRequest) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{55}
+}
+
+func (m *FetchSupplyCommitRequest) GetGroupKey() isFetchSupplyCommitRequest_GroupKey {
+	if m != nil {
+		return m.GroupKey
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitRequest) GetGroupKeyBytes() []byte {
+	if x, ok := x.GetGroupKey().(*FetchSupplyCommitRequest_GroupKeyBytes); ok {
+		return x.GroupKeyBytes
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitRequest) GetGroupKeyStr() string {
+	if x, ok := x.GetGroupKey().(*FetchSupplyCommitRequest_GroupKeyStr); ok {
+		return x.GroupKeyStr
+	}
+	return ""
+}
+
+func (x *FetchSupplyCommitRequest) GetIssuanceLeafKeys() [][]byte {
+	if x != nil {
+		return x.IssuanceLeafKeys
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitRequest) GetBurnLeafKeys() [][]byte {
+	if x != nil {
+		return x.BurnLeafKeys
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitRequest) GetIgnoreLeafKeys() [][]byte {
+	if x != nil {
+		return x.IgnoreLeafKeys
+	}
+	return nil
+}
+
+type isFetchSupplyCommitRequest_GroupKey interface {
+	isFetchSupplyCommitRequest_GroupKey()
+}
+
+type FetchSupplyCommitRequest_GroupKeyBytes struct {
+	// The 32-byte asset group key specified as raw bytes (gRPC only).
+	GroupKeyBytes []byte `protobuf:"bytes,1,opt,name=group_key_bytes,json=groupKeyBytes,proto3,oneof"`
+}
+
+type FetchSupplyCommitRequest_GroupKeyStr struct {
+	// The 32-byte asset group key encoded as hex string (use this for
+	// REST).
+	GroupKeyStr string `protobuf:"bytes,2,opt,name=group_key_str,json=groupKeyStr,proto3,oneof"`
+}
+
+func (*FetchSupplyCommitRequest_GroupKeyBytes) isFetchSupplyCommitRequest_GroupKey() {}
+
+func (*FetchSupplyCommitRequest_GroupKeyStr) isFetchSupplyCommitRequest_GroupKey() {}
+
+type SupplyCommitSubtreeRoot struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The type of the supply commit subtree.
+	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+	// The root node of the supply commit subtree.
+	RootNode *MerkleSumNode `protobuf:"bytes,2,opt,name=root_node,json=rootNode,proto3" json:"root_node,omitempty"`
+	// The leaf key which locates the subtree leaf node in the supply commit
+	// tree.
+	SupplyTreeLeafKey []byte `protobuf:"bytes,3,opt,name=supply_tree_leaf_key,json=supplyTreeLeafKey,proto3" json:"supply_tree_leaf_key,omitempty"`
+	// The inclusion proof for the supply commit subtree root node.
+	SupplyTreeInclusionProof []byte `protobuf:"bytes,4,opt,name=supply_tree_inclusion_proof,json=supplyTreeInclusionProof,proto3" json:"supply_tree_inclusion_proof,omitempty"`
+}
+
+func (x *SupplyCommitSubtreeRoot) Reset() {
+	*x = SupplyCommitSubtreeRoot{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[56]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SupplyCommitSubtreeRoot) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SupplyCommitSubtreeRoot) ProtoMessage() {}
+
+func (x *SupplyCommitSubtreeRoot) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[56]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SupplyCommitSubtreeRoot.ProtoReflect.Descriptor instead.
+func (*SupplyCommitSubtreeRoot) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{56}
+}
+
+func (x *SupplyCommitSubtreeRoot) GetType() string {
+	if x != nil {
+		return x.Type
+	}
+	return ""
+}
+
+func (x *SupplyCommitSubtreeRoot) GetRootNode() *MerkleSumNode {
+	if x != nil {
+		return x.RootNode
+	}
+	return nil
+}
+
+func (x *SupplyCommitSubtreeRoot) GetSupplyTreeLeafKey() []byte {
+	if x != nil {
+		return x.SupplyTreeLeafKey
+	}
+	return nil
+}
+
+func (x *SupplyCommitSubtreeRoot) GetSupplyTreeInclusionProof() []byte {
+	if x != nil {
+		return x.SupplyTreeInclusionProof
+	}
+	return nil
+}
+
+type FetchSupplyCommitResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The supply commitment merkle sum root node for the specified asset.
+	SupplyCommitmentRoot *MerkleSumNode `protobuf:"bytes,1,opt,name=supply_commitment_root,json=supplyCommitmentRoot,proto3" json:"supply_commitment_root,omitempty"`
+	// The txid of the anchor transaction that commits to the supply
+	// commitment for the specified asset.
+	AnchorTxid string `protobuf:"bytes,2,opt,name=anchor_txid,json=anchorTxid,proto3" json:"anchor_txid,omitempty"`
+	// The output index of the anchor transaction that commits to the supply
+	// commitment for the specified asset.
+	AnchorTxOutIdx uint32 `protobuf:"varint,3,opt,name=anchor_tx_out_idx,json=anchorTxOutIdx,proto3" json:"anchor_tx_out_idx,omitempty"`
+	// The transaction output taproot internal key of the anchor transaction
+	// that commits to the supply commitment for the specified asset.
+	AnchorTxOutInternalKey []byte `protobuf:"bytes,4,opt,name=anchor_tx_out_internal_key,json=anchorTxOutInternalKey,proto3" json:"anchor_tx_out_internal_key,omitempty"`
+	// The height of the block at which the supply commitment was anchored.
+	BlockHeight uint32 `protobuf:"varint,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	// The hash of the block at which the supply commitment was anchored.
+	BlockHash []byte `protobuf:"bytes,6,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
+	// The index of the transaction in the block that commits to the supply
+	// commitment.
+	BlockTxIndex uint32 `protobuf:"varint,7,opt,name=block_tx_index,json=blockTxIndex,proto3" json:"block_tx_index,omitempty"`
+	// The total number of satoshis in on-chain fees paid by the supply
+	// commitment transaction.
+	TxChainFeesSats int64 `protobuf:"varint,8,opt,name=tx_chain_fees_sats,json=txChainFeesSats,proto3" json:"tx_chain_fees_sats,omitempty"`
+	// The root of the issuance tree for the specified asset.
+	IssuanceSubtreeRoot *SupplyCommitSubtreeRoot `protobuf:"bytes,9,opt,name=issuance_subtree_root,json=issuanceSubtreeRoot,proto3" json:"issuance_subtree_root,omitempty"`
+	// The root of the burn tree for the specified asset.
+	BurnSubtreeRoot *SupplyCommitSubtreeRoot `protobuf:"bytes,10,opt,name=burn_subtree_root,json=burnSubtreeRoot,proto3" json:"burn_subtree_root,omitempty"`
+	// The root of the ignore tree for the specified asset.
+	IgnoreSubtreeRoot *SupplyCommitSubtreeRoot `protobuf:"bytes,11,opt,name=ignore_subtree_root,json=ignoreSubtreeRoot,proto3" json:"ignore_subtree_root,omitempty"`
+	// Inclusion proofs for each issuance leaf key provided in the request.
+	// Each entry corresponds to the key at the same index in
+	// `issuance_leaf_keys`.
+	IssuanceLeafInclusionProofs [][]byte `protobuf:"bytes,12,rep,name=issuance_leaf_inclusion_proofs,json=issuanceLeafInclusionProofs,proto3" json:"issuance_leaf_inclusion_proofs,omitempty"`
+	// Inclusion proofs for each burn leaf key provided in the request.
+	// Each entry corresponds to the key at the same index in `burn_leaf_keys`.
+	BurnLeafInclusionProofs [][]byte `protobuf:"bytes,13,rep,name=burn_leaf_inclusion_proofs,json=burnLeafInclusionProofs,proto3" json:"burn_leaf_inclusion_proofs,omitempty"`
+	// Inclusion proofs for each ignored leaf key provided in the request.
+	// Each entry corresponds to the key at the same index in
+	// `ignore_leaf_keys`.
+	IgnoreLeafInclusionProofs [][]byte `protobuf:"bytes,14,rep,name=ignore_leaf_inclusion_proofs,json=ignoreLeafInclusionProofs,proto3" json:"ignore_leaf_inclusion_proofs,omitempty"`
+}
+
+func (x *FetchSupplyCommitResponse) Reset() {
+	*x = FetchSupplyCommitResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_universerpc_universe_proto_msgTypes[57]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FetchSupplyCommitResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FetchSupplyCommitResponse) ProtoMessage() {}
+
+func (x *FetchSupplyCommitResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_universerpc_universe_proto_msgTypes[57]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FetchSupplyCommitResponse.ProtoReflect.Descriptor instead.
+func (*FetchSupplyCommitResponse) Descriptor() ([]byte, []int) {
+	return file_universerpc_universe_proto_rawDescGZIP(), []int{57}
+}
+
+func (x *FetchSupplyCommitResponse) GetSupplyCommitmentRoot() *MerkleSumNode {
+	if x != nil {
+		return x.SupplyCommitmentRoot
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetAnchorTxid() string {
+	if x != nil {
+		return x.AnchorTxid
+	}
+	return ""
+}
+
+func (x *FetchSupplyCommitResponse) GetAnchorTxOutIdx() uint32 {
+	if x != nil {
+		return x.AnchorTxOutIdx
+	}
+	return 0
+}
+
+func (x *FetchSupplyCommitResponse) GetAnchorTxOutInternalKey() []byte {
+	if x != nil {
+		return x.AnchorTxOutInternalKey
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetBlockHeight() uint32 {
+	if x != nil {
+		return x.BlockHeight
+	}
+	return 0
+}
+
+func (x *FetchSupplyCommitResponse) GetBlockHash() []byte {
+	if x != nil {
+		return x.BlockHash
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetBlockTxIndex() uint32 {
+	if x != nil {
+		return x.BlockTxIndex
+	}
+	return 0
+}
+
+func (x *FetchSupplyCommitResponse) GetTxChainFeesSats() int64 {
+	if x != nil {
+		return x.TxChainFeesSats
+	}
+	return 0
+}
+
+func (x *FetchSupplyCommitResponse) GetIssuanceSubtreeRoot() *SupplyCommitSubtreeRoot {
+	if x != nil {
+		return x.IssuanceSubtreeRoot
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetBurnSubtreeRoot() *SupplyCommitSubtreeRoot {
+	if x != nil {
+		return x.BurnSubtreeRoot
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetIgnoreSubtreeRoot() *SupplyCommitSubtreeRoot {
+	if x != nil {
+		return x.IgnoreSubtreeRoot
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetIssuanceLeafInclusionProofs() [][]byte {
+	if x != nil {
+		return x.IssuanceLeafInclusionProofs
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetBurnLeafInclusionProofs() [][]byte {
+	if x != nil {
+		return x.BurnLeafInclusionProofs
+	}
+	return nil
+}
+
+func (x *FetchSupplyCommitResponse) GetIgnoreLeafInclusionProofs() [][]byte {
+	if x != nil {
+		return x.IgnoreLeafInclusionProofs
+	}
+	return nil
+}
+
 var File_universerpc_universe_proto protoreflect.FileDescriptor
 
 var file_universerpc_universe_proto_rawDesc = []byte{
 	0x0a, 0x1a, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2f, 0x75, 0x6e,
 	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0b, 0x75, 0x6e,
-	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x1a, 0x13, 0x74, 0x61, 0x70, 0x72, 0x6f,
-	0x6f, 0x74, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x82,
-	0x01, 0x0a, 0x15, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f,
-	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f,
-	0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75,
-	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66,
-	0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12,
-	0x32, 0x0a, 0x0c, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x5f, 0x69, 0x64, 0x73, 0x18,
-	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x0b, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63,
-	0x49, 0x64, 0x73, 0x22, 0x5d, 0x0a, 0x16, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73,
-	0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a,
-	0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x1a, 0x0f, 0x74, 0x61, 0x70, 0x63, 0x6f,
+	0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x13, 0x74, 0x61, 0x70, 0x72,
+	0x6f, 0x6f, 0x74, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
+	0x82, 0x01, 0x0a, 0x15, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f,
+	0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f,
+	0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e,
+	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f,
+	0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65,
+	0x12, 0x32, 0x0a, 0x0c, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x5f, 0x69, 0x64, 0x73,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x0b, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69,
+	0x63, 0x49, 0x64, 0x73, 0x22, 0x5d, 0x0a, 0x16, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43,
+	0x0a, 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f,
+	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e,
+	0x6f, 0x64, 0x65, 0x52, 0x0e, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52,
+	0x6f, 0x6f, 0x74, 0x22, 0xa7, 0x01, 0x0a, 0x10, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f,
+	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, 0x0a, 0x12, 0x77, 0x69, 0x74, 0x68,
+	0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x77, 0x69, 0x74, 0x68, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
+	0x73, 0x42, 0x79, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a,
+	0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69,
+	0x6d, 0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x47, 0x0a,
+	0x0d, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x1b,
+	0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x72,
+	0x6f, 0x6f, 0x74, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x72,
+	0x6f, 0x6f, 0x74, 0x53, 0x75, 0x6d, 0x22, 0xc7, 0x01, 0x0a, 0x02, 0x49, 0x44, 0x12, 0x1b, 0x0a,
+	0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48,
+	0x00, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73,
+	0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x48, 0x00, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x1d,
+	0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0c, 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a,
+	0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
+	0x53, 0x74, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70,
+	0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52,
+	0x09, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x42, 0x04, 0x0a, 0x02, 0x69, 0x64,
+	0x22, 0xae, 0x02, 0x0a, 0x0c, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f,
+	0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e,
+	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02,
+	0x69, 0x64, 0x12, 0x39, 0x0a, 0x0a, 0x6d, 0x73, 0x73, 0x6d, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
 	0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f,
-	0x64, 0x65, 0x52, 0x0e, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f,
-	0x6f, 0x74, 0x22, 0xa7, 0x01, 0x0a, 0x10, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, 0x0a, 0x12, 0x77, 0x69, 0x74, 0x68, 0x5f,
-	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x0f, 0x77, 0x69, 0x74, 0x68, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73,
-	0x42, 0x79, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05,
-	0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d,
-	0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18,
-	0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x47, 0x0a, 0x0d,
-	0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x1b, 0x0a,
-	0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
-	0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f,
-	0x6f, 0x74, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x72, 0x6f,
-	0x6f, 0x74, 0x53, 0x75, 0x6d, 0x22, 0xc7, 0x01, 0x0a, 0x02, 0x49, 0x44, 0x12, 0x1b, 0x0a, 0x08,
-	0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00,
-	0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73, 0x73,
-	0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48,
-	0x00, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x1d, 0x0a,
-	0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c,
-	0x48, 0x00, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x0d,
-	0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x53,
-	0x74, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
-	0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09,
-	0x70, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x42, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x22,
-	0xae, 0x02, 0x0a, 0x0c, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74,
+	0x64, 0x65, 0x52, 0x09, 0x6d, 0x73, 0x73, 0x6d, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x0a,
+	0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x5e, 0x0a, 0x13,
+	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74,
+	0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x75, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x52, 0x6f, 0x6f, 0x74, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73,
+	0x73, 0x65, 0x74, 0x49, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x61, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x1a, 0x43, 0x0a, 0x15,
+	0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x22, 0xca, 0x01, 0x0a, 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x0e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x31, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73,
+	0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
+	0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x52, 0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74,
+	0x73, 0x1a, 0x5b, 0x0a, 0x12, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f,
+	0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2f, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52,
+	0x6f, 0x6f, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x31,
+	0x0a, 0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79,
 	0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75,
 	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69,
-	0x64, 0x12, 0x39, 0x0a, 0x0a, 0x6d, 0x73, 0x73, 0x6d, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64,
-	0x65, 0x52, 0x09, 0x6d, 0x73, 0x73, 0x6d, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
-	0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x5e, 0x0a, 0x13, 0x61,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f,
-	0x69, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52,
-	0x6f, 0x6f, 0x74, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73,
-	0x65, 0x74, 0x49, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
-	0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x1a, 0x43, 0x0a, 0x15, 0x41,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x45,
-	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
-	0x22, 0xca, 0x01, 0x0a, 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x0e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31,
-	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73,
-	0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x55,
-	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72,
-	0x79, 0x52, 0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73,
-	0x1a, 0x5b, 0x0a, 0x12, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74,
-	0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f,
-	0x6f, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x31, 0x0a,
-	0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12,
-	0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e,
-	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64,
-	0x22, 0x93, 0x01, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e,
-	0x63, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e,
-	0x63, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3e, 0x0a, 0x0d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
-	0x65, 0x72, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
-	0x65, 0x72, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x32, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
-	0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x22, 0x14, 0x0a, 0x12, 0x44, 0x65,
-	0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x3b, 0x0a, 0x08, 0x4f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08,
-	0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x68, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0xba, 0x01,
-	0x0a, 0x08, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x17, 0x0a, 0x06, 0x6f, 0x70,
-	0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x05, 0x6f, 0x70,
-	0x53, 0x74, 0x72, 0x12, 0x27, 0x0a, 0x02, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75,
-	0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x02, 0x6f, 0x70, 0x12, 0x2a, 0x0a, 0x10,
-	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0e, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-	0x4b, 0x65, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x63, 0x72, 0x69,
-	0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
-	0x48, 0x01, 0x52, 0x0c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x72,
-	0x42, 0x0a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x42, 0x0c, 0x0a, 0x0a,
-	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0x9f, 0x01, 0x0a, 0x14, 0x41,
-	0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44,
-	0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05,
-	0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d,
-	0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18,
-	0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4c, 0x0a, 0x14,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6b, 0x65,
-	0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x52,
-	0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x46, 0x0a, 0x09, 0x41, 0x73,
-	0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x12, 0x23, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05,
-	0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f,
-	0x6f, 0x66, 0x22, 0x43, 0x0a, 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x65, 0x61, 0x76, 0x65,
-	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52,
-	0x06, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x60, 0x0a, 0x0b, 0x55, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
-	0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x30, 0x0a, 0x08, 0x6c, 0x65, 0x61, 0x66, 0x5f,
-	0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76,
+	0x64, 0x22, 0x93, 0x01, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x73, 0x73, 0x75, 0x61,
+	0x6e, 0x63, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19,
+	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x69, 0x73, 0x73, 0x75, 0x61,
+	0x6e, 0x63, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3e, 0x0a, 0x0d, 0x74, 0x72, 0x61, 0x6e, 0x73,
+	0x66, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19,
+	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x6e, 0x73,
+	0x66, 0x65, 0x72, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x32, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74,
+	0x65, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x22, 0x14, 0x0a, 0x12, 0x44,
+	0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x3b, 0x0a, 0x08, 0x4f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x19, 0x0a,
+	0x08, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x68, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65,
+	0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0xba,
+	0x01, 0x0a, 0x08, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x17, 0x0a, 0x06, 0x6f,
+	0x70, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x05, 0x6f,
+	0x70, 0x53, 0x74, 0x72, 0x12, 0x27, 0x0a, 0x02, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4f,
+	0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x02, 0x6f, 0x70, 0x12, 0x2a, 0x0a,
+	0x10, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65,
+	0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0e, 0x73, 0x63, 0x72, 0x69, 0x70,
+	0x74, 0x4b, 0x65, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x09, 0x48, 0x01, 0x52, 0x0c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x53, 0x74,
+	0x72, 0x42, 0x0a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x42, 0x0c, 0x0a,
+	0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0x9f, 0x01, 0x0a, 0x14,
+	0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49,
+	0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a,
+	0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69,
+	0x6d, 0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4c, 0x0a,
+	0x14, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6b,
+	0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76,
 	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79,
-	0x52, 0x07, 0x6c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x22, 0xb4, 0x03, 0x0a, 0x12, 0x41, 0x73,
-	0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x2a, 0x0a, 0x03, 0x72, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x03, 0x72, 0x65, 0x71, 0x12, 0x3e, 0x0a, 0x0d,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
-	0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x38, 0x0a, 0x18,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69,
-	0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f,
-	0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x35, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f,
-	0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65,
-	0x61, 0x66, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x12, 0x43, 0x0a,
-	0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
-	0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f,
-	0x64, 0x65, 0x52, 0x0e, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f,
-	0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x1a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x18, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66,
-	0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74,
-	0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61,
-	0x74, 0x61, 0x52, 0x0c, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61,
-	0x22, 0xc2, 0x01, 0x0a, 0x0c, 0x49, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61, 0x74,
-	0x61, 0x12, 0x32, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x52,
-	0x65, 0x76, 0x65, 0x61, 0x6c, 0x12, 0x3c, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
-	0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e,
-	0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65,
-	0x76, 0x65, 0x61, 0x6c, 0x52, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65, 0x76,
-	0x65, 0x61, 0x6c, 0x12, 0x40, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79,
-	0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e,
-	0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52,
-	0x65, 0x76, 0x65, 0x61, 0x6c, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52,
-	0x65, 0x76, 0x65, 0x61, 0x6c, 0x22, 0x6f, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72,
-	0x6f, 0x6f, 0x66, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55,
-	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
-	0x35, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
-	0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x09, 0x61, 0x73, 0x73,
-	0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x22, 0x7d, 0x0a, 0x10, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72,
-	0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65,
-	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65,
-	0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
-	0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64,
-	0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x06, 0x73,
-	0x65, 0x72, 0x76, 0x65, 0x72, 0x22, 0x3f, 0x0a, 0x11, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f,
-	0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65,
-	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65,
-	0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x0d, 0x0a, 0x0b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x2d, 0x0a, 0x0c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
-	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x74, 0x69,
-	0x6d, 0x65, 0x49, 0x64, 0x22, 0x2d, 0x0a, 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72, 0x67,
-	0x65, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f,
-	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52,
-	0x02, 0x69, 0x64, 0x22, 0xaa, 0x01, 0x0a, 0x0b, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f,
-	0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x75, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x09, 0x73, 0x79, 0x6e, 0x63,
-	0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x75, 0x6e,
-	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x73, 0x79, 0x6e, 0x63,
-	0x4d, 0x6f, 0x64, 0x65, 0x12, 0x3a, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x74, 0x61, 0x72,
-	0x67, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x75, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72,
-	0x67, 0x65, 0x74, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73,
-	0x22, 0xd4, 0x01, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0e, 0x6f, 0x6c, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74,
-	0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e,
-	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x6f, 0x6c, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74,
-	0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73, 0x73, 0x65,
-	0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75,
+	0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x46, 0x0a, 0x09, 0x41,
+	0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x12, 0x23, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65,
+	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63,
+	0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a,
+	0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72,
+	0x6f, 0x6f, 0x66, 0x22, 0x43, 0x0a, 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x65, 0x61, 0x76,
+	0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66,
+	0x52, 0x06, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x60, 0x0a, 0x0b, 0x55, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x30, 0x0a, 0x08, 0x6c, 0x65, 0x61, 0x66,
+	0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65,
+	0x79, 0x52, 0x07, 0x6c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x22, 0xb4, 0x03, 0x0a, 0x12, 0x41,
+	0x73, 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x2a, 0x0a, 0x03, 0x72, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18,
+	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x03, 0x72, 0x65, 0x71, 0x12, 0x3e, 0x0a,
+	0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
+	0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52,
+	0x0c, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x38, 0x0a,
+	0x18, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73,
+	0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x16, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69,
+	0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x35, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74,
+	0x5f, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c,
+	0x65, 0x61, 0x66, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x12, 0x43,
+	0x0a, 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f,
+	0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e,
+	0x6f, 0x64, 0x65, 0x52, 0x0e, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52,
+	0x6f, 0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x1a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f,
+	0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x18, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f,
+	0x66, 0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x61,
+	0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44,
+	0x61, 0x74, 0x61, 0x52, 0x0c, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61, 0x74,
+	0x61, 0x22, 0xc2, 0x01, 0x0a, 0x0c, 0x49, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61,
+	0x74, 0x61, 0x12, 0x32, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61,
+	0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63,
+	0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61,
+	0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x12, 0x3c, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+	0x73, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15,
+	0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52,
+	0x65, 0x76, 0x65, 0x61, 0x6c, 0x52, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65,
+	0x76, 0x65, 0x61, 0x6c, 0x12, 0x40, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65,
+	0x79, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16,
+	0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
+	0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
+	0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x22, 0x6f, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50,
+	0x72, 0x6f, 0x6f, 0x66, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
+	0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x35, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
+	0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x09, 0x61, 0x73,
+	0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x22, 0x7d, 0x0a, 0x10, 0x50, 0x75, 0x73, 0x68, 0x50,
+	0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b,
+	0x65, 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65,
+	0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65,
+	0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x06,
+	0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x22, 0x3f, 0x0a, 0x11, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72,
+	0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b,
+	0x65, 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x0d, 0x0a, 0x0b, 0x49, 0x6e, 0x66, 0x6f, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x2d, 0x0a, 0x0c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
+	0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x74,
+	0x69, 0x6d, 0x65, 0x49, 0x64, 0x22, 0x2d, 0x0a, 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72,
+	0x67, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44,
+	0x52, 0x02, 0x69, 0x64, 0x22, 0xaa, 0x01, 0x0a, 0x0b, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x5f, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x75, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x09, 0x73, 0x79, 0x6e,
+	0x63, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x75,
 	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73, 0x65,
-	0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x40, 0x0a, 0x10, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73, 0x73,
-	0x65, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73,
-	0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x0e, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73, 0x65,
-	0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x56, 0x0a, 0x0c, 0x53, 0x79, 0x6e, 0x63, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x63, 0x65,
-	0x64, 0x5f, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x0f,
-	0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x22,
-	0x3e, 0x0a, 0x18, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x68,
-	0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12,
-	0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x22,
-	0x1e, 0x0a, 0x1c, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22,
-	0x60, 0x0a, 0x1d, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
-	0x73, 0x22, 0x5d, 0x0a, 0x1a, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55,
-	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73,
-	0x22, 0x1d, 0x0a, 0x1b, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x60, 0x0a, 0x1d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
+	0x72, 0x73, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x73, 0x79, 0x6e,
+	0x63, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x3a, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x74, 0x61,
+	0x72, 0x67, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x61,
+	0x72, 0x67, 0x65, 0x74, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74,
+	0x73, 0x22, 0xd4, 0x01, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0e, 0x6f, 0x6c, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65,
+	0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x6f, 0x6c, 0x64, 0x41, 0x73, 0x73, 0x65,
+	0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73, 0x73,
+	0x65, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
+	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73,
+	0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x40, 0x0a, 0x10, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73,
+	0x73, 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41,
+	0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x0e, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73,
+	0x65, 0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x56, 0x0a, 0x0c, 0x53, 0x79, 0x6e, 0x63,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x63,
+	0x65, 0x64, 0x5f, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
+	0x2e, 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52,
+	0x0f, 0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73,
+	0x22, 0x3e, 0x0a, 0x18, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04,
+	0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74,
+	0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64,
+	0x22, 0x1e, 0x0a, 0x1c, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x22, 0x60, 0x0a, 0x1d, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
+	0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65,
+	0x72, 0x73, 0x22, 0x5d, 0x0a, 0x1a, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
 	0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
 	0x12, 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
 	0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
 	0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
 	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
-	0x73, 0x22, 0x20, 0x0a, 0x1e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0xb5, 0x01, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74,
-	0x61, 0x6c, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
-	0x0e, 0x6e, 0x75, 0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12,
-	0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x67, 0x72, 0x6f,
-	0x75, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x54, 0x6f,
-	0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x75, 0x6d,
-	0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x73, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x0d, 0x6e, 0x75, 0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63,
-	0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70,
-	0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75, 0x6d,
-	0x54, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0xcd, 0x02, 0x0a, 0x0f,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12,
-	0x2a, 0x0a, 0x11, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x66, 0x69,
-	0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x73, 0x73, 0x65,
-	0x74, 0x4e, 0x61, 0x6d, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, 0x61,
-	0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x46, 0x69, 0x6c,
-	0x74, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x11, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70,
-	0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c,
-	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73,
-	0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0f, 0x61, 0x73,
-	0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x34, 0x0a,
-	0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b,
+	0x73, 0x22, 0x1d, 0x0a, 0x1b, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x60, 0x0a, 0x1d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
+	0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65,
+	0x72, 0x73, 0x22, 0x20, 0x0a, 0x1e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb5, 0x01, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f,
+	0x74, 0x61, 0x6c, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73,
+	0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x54,
+	0x6f, 0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x75,
+	0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x73, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x0d, 0x6e, 0x75, 0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x79, 0x6e,
+	0x63, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f,
+	0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75,
+	0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0xcd, 0x02, 0x0a,
+	0x0f, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x12, 0x2a, 0x0a, 0x11, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x66,
+	0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x73, 0x73,
+	0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f,
+	0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x46, 0x69,
+	0x6c, 0x74, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x11, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79,
+	0x70, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73,
+	0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0f, 0x61,
+	0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x34,
+	0x0a, 0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x1b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73,
+	0x73, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x6f, 0x72, 0x74, 0x52, 0x06, 0x73, 0x6f,
+	0x72, 0x74, 0x42, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05,
+	0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d,
+	0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x02, 0x0a,
+	0x12, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
+	0x12, 0x21, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x75, 0x70,
+	0x70, 0x6c, 0x79, 0x12, 0x3f, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x61, 0x6e, 0x63,
+	0x68, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e,
+	0x63, 0x68, 0x6f, 0x72, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x41, 0x73, 0x73, 0x65,
+	0x74, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61,
+	0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74,
+	0x6f, 0x74, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74,
+	0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0xe5, 0x02, 0x0a,
+	0x0f, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x41, 0x73, 0x73, 0x65, 0x74,
+	0x12, 0x19, 0x0a, 0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x67,
+	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x6f, 0x69, 0x6e, 0x74,
+	0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70,
+	0x70, 0x6c, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d,
+	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4e, 0x61,
+	0x6d, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e,
+	0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74,
+	0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f,
+	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x67, 0x65,
+	0x6e, 0x65, 0x73, 0x69, 0x73, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x67,
+	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68,
+	0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x64,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73,
+	0x70, 0x6c, 0x61, 0x79, 0x22, 0x56, 0x0a, 0x12, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x0b, 0x61, 0x73,
+	0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73,
+	0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x62, 0x0a, 0x12,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65,
+	0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x23, 0x0a, 0x0d, 0x65,
+	0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0c, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x22, 0x51, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x55, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x06, 0x65, 0x76, 0x65,
+	0x6e, 0x74, 0x73, 0x22, 0x76, 0x0a, 0x15, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x55, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04,
+	0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65,
+	0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x73, 0x79, 0x6e, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74,
+	0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x65,
+	0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6e, 0x65, 0x77,
+	0x50, 0x72, 0x6f, 0x6f, 0x66, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xcf, 0x01, 0x0a, 0x1e,
+	0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e,
+	0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x57,
+	0x0a, 0x13, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f,
+	0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c,
+	0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f,
+	0x6e, 0x66, 0x69, 0x67, 0x52, 0x11, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x61, 0x73, 0x73, 0x65, 0x74,
+	0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x61, 0x73, 0x73,
+	0x65, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x22, 0x21, 0x0a,
+	0x1f, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79,
+	0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0xab, 0x01, 0x0a, 0x1a, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x46, 0x65, 0x64, 0x65, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12,
+	0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x70, 0x72, 0x6f,
+	0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f,
+	0x73, 0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x49, 0x6e, 0x73, 0x65,
+	0x72, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63,
+	0x5f, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61,
+	0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x94,
+	0x01, 0x0a, 0x19, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1f, 0x0a, 0x02,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2a, 0x0a,
+	0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x65,
+	0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53,
+	0x79, 0x6e, 0x63, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c,
+	0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x45,
+	0x78, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x43, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65,
+	0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66,
+	0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x22, 0xd2, 0x01, 0x0a, 0x21, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79,
+	0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x57, 0x0a, 0x13, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f,
+	0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x6c, 0x6f, 0x62,
+	0x61, 0x6c, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x11, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x79,
+	0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x61, 0x73, 0x73,
+	0x65, 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x61,
+	0x73, 0x73, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x22,
+	0x73, 0x0a, 0x1a, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x75,
+	0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a,
+	0x0f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e,
+	0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0d, 0x61,
+	0x73, 0x73, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06,
+	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x22, 0x68, 0x0a, 0x1b, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x41, 0x73,
+	0x73, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x6b, 0x65, 0x79, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x12, 0x2e,
+	0x0a, 0x04, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c,
+	0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6c, 0x65, 0x61, 0x66, 0x22, 0x78,
+	0x0a, 0x19, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f,
+	0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x0f, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
+	0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b,
+	0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b,
+	0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x72, 0x42, 0x0b, 0x0a, 0x09, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0x1c, 0x0a, 0x1a, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xf5, 0x01, 0x0a, 0x18, 0x46, 0x65, 0x74, 0x63, 0x68,
+	0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x0f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79,
+	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0d,
+	0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x24, 0x0a,
+	0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
+	0x53, 0x74, 0x72, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x5f,
+	0x6c, 0x65, 0x61, 0x66, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52,
+	0x10, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79,
+	0x73, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x75, 0x72, 0x6e, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x6b,
+	0x65, 0x79, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0c, 0x62, 0x75, 0x72, 0x6e, 0x4c,
+	0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x69, 0x67, 0x6e, 0x6f, 0x72,
+	0x65, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28,
+	0x0c, 0x52, 0x0e, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79,
+	0x73, 0x42, 0x0b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0xd6,
+	0x01, 0x0a, 0x17, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53,
+	0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79,
+	0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x37,
+	0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
+	0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x72,
+	0x6f, 0x6f, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x2f, 0x0a, 0x14, 0x73, 0x75, 0x70, 0x70, 0x6c,
+	0x79, 0x5f, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x6b, 0x65, 0x79, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x11, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x54, 0x72, 0x65,
+	0x65, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x1b, 0x73, 0x75, 0x70, 0x70,
+	0x6c, 0x79, 0x5f, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f,
+	0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x18, 0x73,
+	0x75, 0x70, 0x70, 0x6c, 0x79, 0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69,
+	0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0xcf, 0x06, 0x0a, 0x19, 0x46, 0x65, 0x74, 0x63,
+	0x68, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x16, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x5f,
+	0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64,
+	0x65, 0x52, 0x14, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d,
+	0x65, 0x6e, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f,
+	0x72, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e,
+	0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x11, 0x61, 0x6e, 0x63, 0x68,
+	0x6f, 0x72, 0x5f, 0x74, 0x78, 0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x69, 0x64, 0x78, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x4f, 0x75, 0x74,
+	0x49, 0x64, 0x78, 0x12, 0x3a, 0x0a, 0x1a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78,
+	0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65,
+	0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54,
+	0x78, 0x4f, 0x75, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12,
+	0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
+	0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73,
+	0x68, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x78, 0x5f, 0x69, 0x6e,
+	0x64, 0x65, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+	0x54, 0x78, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x2b, 0x0a, 0x12, 0x74, 0x78, 0x5f, 0x63, 0x68,
+	0x61, 0x69, 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x5f, 0x73, 0x61, 0x74, 0x73, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x78, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x46, 0x65, 0x65, 0x73,
+	0x53, 0x61, 0x74, 0x73, 0x12, 0x58, 0x0a, 0x15, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65,
+	0x5f, 0x73, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x75,
+	0x62, 0x74, 0x72, 0x65, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x13, 0x69, 0x73, 0x73, 0x75, 0x61,
+	0x6e, 0x63, 0x65, 0x53, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x50,
+	0x0a, 0x11, 0x62, 0x75, 0x72, 0x6e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x72,
+	0x6f, 0x6f, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x75, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f,
+	0x6d, 0x6d, 0x69, 0x74, 0x53, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52,
+	0x0f, 0x62, 0x75, 0x72, 0x6e, 0x53, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x52, 0x6f, 0x6f, 0x74,
+	0x12, 0x54, 0x0a, 0x13, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x72,
+	0x65, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e,
+	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x70, 0x70,
+	0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x52,
+	0x6f, 0x6f, 0x74, 0x52, 0x11, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x53, 0x75, 0x62, 0x74, 0x72,
+	0x65, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x43, 0x0a, 0x1e, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e,
+	0x63, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f,
+	0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x1b,
+	0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x61, 0x66, 0x49, 0x6e, 0x63, 0x6c,
+	0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x12, 0x3b, 0x0a, 0x1a, 0x62,
+	0x75, 0x72, 0x6e, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69,
+	0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0c, 0x52,
+	0x17, 0x62, 0x75, 0x72, 0x6e, 0x4c, 0x65, 0x61, 0x66, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69,
+	0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x12, 0x3f, 0x0a, 0x1c, 0x69, 0x67, 0x6e, 0x6f,
+	0x72, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f,
+	0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x19,
+	0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x4c, 0x65, 0x61, 0x66, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73,
+	0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x2a, 0x59, 0x0a, 0x09, 0x50, 0x72, 0x6f,
+	0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f,
+	0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44,
+	0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45,
+	0x5f, 0x49, 0x53, 0x53, 0x55, 0x41, 0x4e, 0x43, 0x45, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x50,
+	0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x46,
+	0x45, 0x52, 0x10, 0x02, 0x2a, 0x39, 0x0a, 0x10, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x53, 0x79, 0x6e, 0x63, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x59, 0x4e, 0x43,
+	0x5f, 0x49, 0x53, 0x53, 0x55, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x00,
+	0x12, 0x0d, 0x0a, 0x09, 0x53, 0x59, 0x4e, 0x43, 0x5f, 0x46, 0x55, 0x4c, 0x4c, 0x10, 0x01, 0x2a,
+	0xd1, 0x01, 0x0a, 0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x6f,
+	0x72, 0x74, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x4e, 0x4f,
+	0x4e, 0x45, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f,
+	0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10,
+	0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x49, 0x44,
+	0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x53,
+	0x53, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x03, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x4f,
+	0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, 0x5f, 0x53, 0x59, 0x4e, 0x43,
+	0x53, 0x10, 0x04, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54,
+	0x4f, 0x54, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x53, 0x10, 0x05, 0x12, 0x1a, 0x0a,
+	0x16, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x53, 0x49, 0x53,
+	0x5f, 0x48, 0x45, 0x49, 0x47, 0x48, 0x54, 0x10, 0x06, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x4f, 0x52,
+	0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4c,
+	0x59, 0x10, 0x07, 0x2a, 0x40, 0x0a, 0x0d, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52,
+	0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x53, 0x43, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13,
+	0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44,
+	0x45, 0x53, 0x43, 0x10, 0x01, 0x2a, 0x5f, 0x0a, 0x0f, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79,
+	0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x15, 0x0a, 0x11, 0x46, 0x49, 0x4c, 0x54,
+	0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12,
+	0x17, 0x0a, 0x13, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f,
+	0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x46, 0x49, 0x4c, 0x54,
+	0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x43, 0x4f, 0x4c, 0x4c, 0x45, 0x43, 0x54,
+	0x49, 0x42, 0x4c, 0x45, 0x10, 0x02, 0x32, 0xab, 0x0f, 0x0a, 0x08, 0x55, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x12, 0x59, 0x0a, 0x0e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x22, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f,
+	0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x75, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4b,
+	0x0a, 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x12, 0x1d, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74,
+	0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52,
+	0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x0f, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x12, 0x1b,
 	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73,
-	0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x6f, 0x72, 0x74, 0x52, 0x06, 0x73, 0x6f, 0x72,
-	0x74, 0x42, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x05, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c,
-	0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69,
-	0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07,
-	0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
-	0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x02, 0x0a, 0x12,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
-	0x6f, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12,
-	0x21, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x75, 0x70, 0x70,
-	0x6c, 0x79, 0x12, 0x3f, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x61, 0x6e, 0x63, 0x68,
-	0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74,
-	0x73, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e, 0x63,
-	0x68, 0x6f, 0x72, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
-	0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x41, 0x73, 0x73, 0x65, 0x74,
-	0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c,
-	0x5f, 0x73, 0x79, 0x6e, 0x63, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x6f,
-	0x74, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61,
-	0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b,
-	0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0xe5, 0x02, 0x0a, 0x0f,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12,
-	0x19, 0x0a, 0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x65,
-	0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12,
-	0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70,
-	0x6c, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4e, 0x61, 0x6d,
-	0x65, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
-	0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41,
-	0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54,
-	0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x68,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x67, 0x65, 0x6e,
-	0x65, 0x73, 0x69, 0x73, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x67, 0x65,
-	0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18,
-	0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f,
-	0x72, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61,
-	0x6e, 0x63, 0x68, 0x6f, 0x72, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65,
-	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x09, 0x20,
-	0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70,
-	0x6c, 0x61, 0x79, 0x22, 0x56, 0x0a, 0x12, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x41,
-	0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x0b, 0x61, 0x73, 0x73,
-	0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f,
+	0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x1a, 0x1e, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52,
+	0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0f, 0x44,
+	0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1c,
+	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c,
+	0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x1a, 0x1f, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74,
+	0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x55, 0x0a,
+	0x0d, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x21,
 	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73,
-	0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
-	0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x62, 0x0a, 0x12, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73,
-	0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72,
-	0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6e,
-	0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x0c, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22,
-	0x51, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
-	0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e,
-	0x74, 0x73, 0x22, 0x76, 0x0a, 0x15, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x55, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64,
-	0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x12,
-	0x1f, 0x0a, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x73, 0x79, 0x6e, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73,
-	0x12, 0x28, 0x0a, 0x10, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x65, 0x76,
-	0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6e, 0x65, 0x77, 0x50,
-	0x72, 0x6f, 0x6f, 0x66, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xcf, 0x01, 0x0a, 0x1e, 0x53,
-	0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63,
-	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x57, 0x0a,
-	0x13, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x75, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x46,
-	0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x52, 0x11, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x43,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f,
-	0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
-	0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x61, 0x73, 0x73, 0x65,
-	0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x22, 0x21, 0x0a, 0x1f,
-	0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e,
-	0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0xab, 0x01, 0x0a, 0x1a, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x35,
-	0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
-	0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6f,
-	0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73,
-	0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
-	0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x49, 0x6e, 0x73, 0x65, 0x72,
-	0x74, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f,
-	0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c,
-	0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x94, 0x01,
-	0x0a, 0x19, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1f, 0x0a, 0x02, 0x69,
-	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2a, 0x0a, 0x11,
-	0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72,
-	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79,
-	0x6e, 0x63, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f,
-	0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x45, 0x78,
-	0x70, 0x6f, 0x72, 0x74, 0x22, 0x43, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64,
-	0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69,
-	0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
-	0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x22, 0xd2, 0x01, 0x0a, 0x21, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e,
-	0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x57, 0x0a, 0x13, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x75,
-	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x6c, 0x6f, 0x62, 0x61,
-	0x6c, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x11, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x79, 0x6e,
-	0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x61, 0x73, 0x73, 0x65,
-	0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x02,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
-	0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x61, 0x73,
-	0x73, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x2a, 0x59,
-	0x0a, 0x09, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x50,
-	0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43,
-	0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x4f, 0x46,
-	0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x53, 0x53, 0x55, 0x41, 0x4e, 0x43, 0x45, 0x10, 0x01,
-	0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54,
-	0x52, 0x41, 0x4e, 0x53, 0x46, 0x45, 0x52, 0x10, 0x02, 0x2a, 0x39, 0x0a, 0x10, 0x55, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a,
-	0x12, 0x53, 0x59, 0x4e, 0x43, 0x5f, 0x49, 0x53, 0x53, 0x55, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4f,
-	0x4e, 0x4c, 0x59, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x59, 0x4e, 0x43, 0x5f, 0x46, 0x55,
-	0x4c, 0x4c, 0x10, 0x01, 0x2a, 0xd1, 0x01, 0x0a, 0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x53, 0x6f, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x4f, 0x52, 0x54, 0x5f,
-	0x42, 0x59, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52,
-	0x54, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x10,
-	0x01, 0x12, 0x14, 0x0a, 0x10, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x53, 0x53,
-	0x45, 0x54, 0x5f, 0x49, 0x44, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, 0x54, 0x5f,
-	0x42, 0x59, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x03, 0x12,
-	0x17, 0x0a, 0x13, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c,
-	0x5f, 0x53, 0x59, 0x4e, 0x43, 0x53, 0x10, 0x04, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x4f, 0x52, 0x54,
-	0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x53,
-	0x10, 0x05, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x45,
-	0x4e, 0x45, 0x53, 0x49, 0x53, 0x5f, 0x48, 0x45, 0x49, 0x47, 0x48, 0x54, 0x10, 0x06, 0x12, 0x18,
-	0x0a, 0x14, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, 0x5f,
-	0x53, 0x55, 0x50, 0x50, 0x4c, 0x59, 0x10, 0x07, 0x2a, 0x40, 0x0a, 0x0d, 0x53, 0x6f, 0x72, 0x74,
-	0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52,
-	0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x53, 0x43, 0x10,
-	0x00, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54,
-	0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x53, 0x43, 0x10, 0x01, 0x2a, 0x5f, 0x0a, 0x0f, 0x41, 0x73,
-	0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x15, 0x0a,
-	0x11, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x4f,
-	0x4e, 0x45, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41,
-	0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x1c, 0x0a,
-	0x18, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x43, 0x4f,
-	0x4c, 0x4c, 0x45, 0x43, 0x54, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x02, 0x32, 0xf6, 0x0c, 0x0a, 0x08,
-	0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x12, 0x59, 0x0a, 0x0e, 0x4d, 0x75, 0x6c, 0x74,
-	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x22, 0x2e, 0x75, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23,
-	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c,
-	0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x4b, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74,
-	0x73, 0x12, 0x1d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41,
-	0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x4e, 0x0a, 0x0f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f,
-	0x6f, 0x74, 0x73, 0x12, 0x1b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
-	0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x50, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52,
-	0x6f, 0x6f, 0x74, 0x12, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
-	0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x55, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b,
-	0x65, 0x79, 0x73, 0x12, 0x21, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
-	0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
-	0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65,
-	0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x41, 0x73, 0x73,
-	0x65, 0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x12, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61,
-	0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65,
-	0x79, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x47, 0x0a, 0x0b, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f,
-	0x66, 0x12, 0x17, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72,
-	0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x09, 0x50,
-	0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x1d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
-	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x49, 0x6e, 0x66, 0x6f, 0x12,
-	0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e,
-	0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0c, 0x53, 0x79, 0x6e, 0x63, 0x55, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x12, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
-	0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19,
-	0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e,
-	0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x15, 0x4c, 0x69, 0x73,
-	0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65,
-	0x72, 0x73, 0x12, 0x29, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
-	0x2e, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53,
-	0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e,
+	0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x21, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
+	0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61,
+	0x76, 0x65, 0x73, 0x12, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x49, 0x44, 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
+	0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f,
+	0x6f, 0x66, 0x12, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
+	0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x1a, 0x1f, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74,
+	0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a,
+	0x0b, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x17, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74,
+	0x50, 0x72, 0x6f, 0x6f, 0x66, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x09, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72,
+	0x6f, 0x6f, 0x66, 0x12, 0x1d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70,
+	0x63, 0x2e, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
+	0x2e, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x2e, 0x75, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
+	0x70, 0x63, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x43, 0x0a, 0x0c, 0x53, 0x79, 0x6e, 0x63, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x12,
+	0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79,
+	0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76,
+	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x29, 0x2e,
 	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74,
 	0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,
-	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x13, 0x41, 0x64, 0x64,
-	0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,
-	0x12, 0x27, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41,
-	0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76,
-	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x75, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x71, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64,
-	0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x2a, 0x2e,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65,
-	0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76,
-	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x75, 0x6e, 0x69, 0x76,
-	0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65,
-	0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0d, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
-	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
-	0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50,
-	0x0a, 0x0f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74,
-	0x73, 0x12, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e,
-	0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x51, 0x75, 0x65, 0x72, 0x79, 0x1a,
-	0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e,
-	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x12, 0x50, 0x0a, 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12,
-	0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x20, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x74, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2b, 0x2e,
-	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x46,
-	0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x75, 0x6e, 0x69,
-	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x13, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x27, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64,
+	0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
+	0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x71,
+	0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x2a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64,
+	0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
+	0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x46, 0x0a, 0x0d, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x12, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63,
+	0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e,
+	0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0f, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x1c, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x51, 0x75, 0x65, 0x72, 0x79, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x50, 0x0a, 0x0b, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x75, 0x6e, 0x69,
+	0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76,
+	0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x75, 0x6e,
+	0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45,
+	0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a,
+	0x17, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79,
+	0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65,
+	0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65,
 	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
-	0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72,
-	0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70,
+	0x12, 0x2d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79,
+	0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x2e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e,
+	0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x68, 0x0a, 0x13, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x75,
+	0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x27, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73,
+	0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74,
+	0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x28, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x67,
+	0x6e, 0x6f, 0x72, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e,
+	0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x12, 0x55, 0x70, 0x64,
+	0x61, 0x74, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12,
+	0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70,
+	0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x70, 0x70,
+	0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x62, 0x0a, 0x11, 0x46, 0x65, 0x74, 0x63, 0x68, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65,
+	0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x75,
+	0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68,
+	0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70,
 	0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3c, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
 	0x6f, 0x6d, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x62, 0x73,
 	0x2f, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x2d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2f,
@@ -3941,7 +4675,7 @@ func file_universerpc_universe_proto_rawDescGZIP() []byte {
 }
 
 var file_universerpc_universe_proto_enumTypes = make([]protoimpl.EnumInfo, 5)
-var file_universerpc_universe_proto_msgTypes = make([]protoimpl.MessageInfo, 53)
+var file_universerpc_universe_proto_msgTypes = make([]protoimpl.MessageInfo, 60)
 var file_universerpc_universe_proto_goTypes = []any{
 	(ProofType)(0),                            // 0: universerpc.ProofType
 	(UniverseSyncMode)(0),                     // 1: universerpc.UniverseSyncMode
@@ -3999,13 +4733,21 @@ var file_universerpc_universe_proto_goTypes = []any{
 	(*AssetFederationSyncConfig)(nil),         // 53: universerpc.AssetFederationSyncConfig
 	(*QueryFederationSyncConfigRequest)(nil),  // 54: universerpc.QueryFederationSyncConfigRequest
 	(*QueryFederationSyncConfigResponse)(nil), // 55: universerpc.QueryFederationSyncConfigResponse
-	nil,                           // 56: universerpc.UniverseRoot.AmountsByAssetIdEntry
-	nil,                           // 57: universerpc.AssetRootResponse.UniverseRootsEntry
-	(*taprpc.Asset)(nil),          // 58: taprpc.Asset
-	(*taprpc.AssetMeta)(nil),      // 59: taprpc.AssetMeta
-	(*taprpc.GenesisReveal)(nil),  // 60: taprpc.GenesisReveal
-	(*taprpc.GroupKeyReveal)(nil), // 61: taprpc.GroupKeyReveal
-	(taprpc.AssetType)(0),         // 62: taprpc.AssetType
+	(*IgnoreAssetOutPointRequest)(nil),        // 56: universerpc.IgnoreAssetOutPointRequest
+	(*IgnoreAssetOutPointResponse)(nil),       // 57: universerpc.IgnoreAssetOutPointResponse
+	(*UpdateSupplyCommitRequest)(nil),         // 58: universerpc.UpdateSupplyCommitRequest
+	(*UpdateSupplyCommitResponse)(nil),        // 59: universerpc.UpdateSupplyCommitResponse
+	(*FetchSupplyCommitRequest)(nil),          // 60: universerpc.FetchSupplyCommitRequest
+	(*SupplyCommitSubtreeRoot)(nil),           // 61: universerpc.SupplyCommitSubtreeRoot
+	(*FetchSupplyCommitResponse)(nil),         // 62: universerpc.FetchSupplyCommitResponse
+	nil,                                       // 63: universerpc.UniverseRoot.AmountsByAssetIdEntry
+	nil,                                       // 64: universerpc.AssetRootResponse.UniverseRootsEntry
+	(*taprpc.Asset)(nil),                      // 65: taprpc.Asset
+	(*taprpc.AssetMeta)(nil),                  // 66: taprpc.AssetMeta
+	(*taprpc.GenesisReveal)(nil),              // 67: taprpc.GenesisReveal
+	(*taprpc.GroupKeyReveal)(nil),             // 68: taprpc.GroupKeyReveal
+	(taprpc.AssetType)(0),                     // 69: taprpc.AssetType
+	(*taprpc.AssetOutPoint)(nil),              // 70: taprpc.AssetOutPoint
 }
 var file_universerpc_universe_proto_depIdxs = []int32{
 	0,  // 0: universerpc.MultiverseRootRequest.proof_type:type_name -> universerpc.ProofType
@@ -4015,8 +4757,8 @@ var file_universerpc_universe_proto_depIdxs = []int32{
 	0,  // 4: universerpc.ID.proof_type:type_name -> universerpc.ProofType
 	9,  // 5: universerpc.UniverseRoot.id:type_name -> universerpc.ID
 	8,  // 6: universerpc.UniverseRoot.mssmt_root:type_name -> universerpc.MerkleSumNode
-	56, // 7: universerpc.UniverseRoot.amounts_by_asset_id:type_name -> universerpc.UniverseRoot.AmountsByAssetIdEntry
-	57, // 8: universerpc.AssetRootResponse.universe_roots:type_name -> universerpc.AssetRootResponse.UniverseRootsEntry
+	63, // 7: universerpc.UniverseRoot.amounts_by_asset_id:type_name -> universerpc.UniverseRoot.AmountsByAssetIdEntry
+	64, // 8: universerpc.AssetRootResponse.universe_roots:type_name -> universerpc.AssetRootResponse.UniverseRootsEntry
 	9,  // 9: universerpc.AssetRootQuery.id:type_name -> universerpc.ID
 	10, // 10: universerpc.QueryRootResponse.issuance_root:type_name -> universerpc.UniverseRoot
 	10, // 11: universerpc.QueryRootResponse.transfer_root:type_name -> universerpc.UniverseRoot
@@ -4025,7 +4767,7 @@ var file_universerpc_universe_proto_depIdxs = []int32{
 	9,  // 14: universerpc.AssetLeafKeysRequest.id:type_name -> universerpc.ID
 	3,  // 15: universerpc.AssetLeafKeysRequest.direction:type_name -> universerpc.SortDirection
 	17, // 16: universerpc.AssetLeafKeyResponse.asset_keys:type_name -> universerpc.AssetKey
-	58, // 17: universerpc.AssetLeaf.asset:type_name -> taprpc.Asset
+	65, // 17: universerpc.AssetLeaf.asset:type_name -> taprpc.Asset
 	20, // 18: universerpc.AssetLeafResponse.leaves:type_name -> universerpc.AssetLeaf
 	9,  // 19: universerpc.UniverseKey.id:type_name -> universerpc.ID
 	17, // 20: universerpc.UniverseKey.leaf_key:type_name -> universerpc.AssetKey
@@ -4034,9 +4776,9 @@ var file_universerpc_universe_proto_depIdxs = []int32{
 	20, // 23: universerpc.AssetProofResponse.asset_leaf:type_name -> universerpc.AssetLeaf
 	8,  // 24: universerpc.AssetProofResponse.multiverse_root:type_name -> universerpc.MerkleSumNode
 	24, // 25: universerpc.AssetProofResponse.issuance_data:type_name -> universerpc.IssuanceData
-	59, // 26: universerpc.IssuanceData.meta_reveal:type_name -> taprpc.AssetMeta
-	60, // 27: universerpc.IssuanceData.genesis_reveal:type_name -> taprpc.GenesisReveal
-	61, // 28: universerpc.IssuanceData.group_key_reveal:type_name -> taprpc.GroupKeyReveal
+	66, // 26: universerpc.IssuanceData.meta_reveal:type_name -> taprpc.AssetMeta
+	67, // 27: universerpc.IssuanceData.genesis_reveal:type_name -> taprpc.GenesisReveal
+	68, // 28: universerpc.IssuanceData.group_key_reveal:type_name -> taprpc.GroupKeyReveal
 	22, // 29: universerpc.AssetProof.key:type_name -> universerpc.UniverseKey
 	20, // 30: universerpc.AssetProof.asset_leaf:type_name -> universerpc.AssetLeaf
 	22, // 31: universerpc.PushProofRequest.key:type_name -> universerpc.UniverseKey
@@ -4057,7 +4799,7 @@ var file_universerpc_universe_proto_depIdxs = []int32{
 	3,  // 46: universerpc.AssetStatsQuery.direction:type_name -> universerpc.SortDirection
 	45, // 47: universerpc.AssetStatsSnapshot.group_anchor:type_name -> universerpc.AssetStatsAsset
 	45, // 48: universerpc.AssetStatsSnapshot.asset:type_name -> universerpc.AssetStatsAsset
-	62, // 49: universerpc.AssetStatsAsset.asset_type:type_name -> taprpc.AssetType
+	69, // 49: universerpc.AssetStatsAsset.asset_type:type_name -> taprpc.AssetType
 	44, // 50: universerpc.UniverseAssetStats.asset_stats:type_name -> universerpc.AssetStatsSnapshot
 	49, // 51: universerpc.QueryEventsResponse.events:type_name -> universerpc.GroupedUniverseEvents
 	52, // 52: universerpc.SetFederationSyncConfigRequest.global_sync_configs:type_name -> universerpc.GlobalFederationSyncConfig
@@ -4067,50 +4809,63 @@ var file_universerpc_universe_proto_depIdxs = []int32{
 	9,  // 56: universerpc.QueryFederationSyncConfigRequest.id:type_name -> universerpc.ID
 	52, // 57: universerpc.QueryFederationSyncConfigResponse.global_sync_configs:type_name -> universerpc.GlobalFederationSyncConfig
 	53, // 58: universerpc.QueryFederationSyncConfigResponse.asset_sync_configs:type_name -> universerpc.AssetFederationSyncConfig
-	10, // 59: universerpc.AssetRootResponse.UniverseRootsEntry.value:type_name -> universerpc.UniverseRoot
-	5,  // 60: universerpc.Universe.MultiverseRoot:input_type -> universerpc.MultiverseRootRequest
-	7,  // 61: universerpc.Universe.AssetRoots:input_type -> universerpc.AssetRootRequest
-	12, // 62: universerpc.Universe.QueryAssetRoots:input_type -> universerpc.AssetRootQuery
-	14, // 63: universerpc.Universe.DeleteAssetRoot:input_type -> universerpc.DeleteRootQuery
-	18, // 64: universerpc.Universe.AssetLeafKeys:input_type -> universerpc.AssetLeafKeysRequest
-	9,  // 65: universerpc.Universe.AssetLeaves:input_type -> universerpc.ID
-	22, // 66: universerpc.Universe.QueryProof:input_type -> universerpc.UniverseKey
-	25, // 67: universerpc.Universe.InsertProof:input_type -> universerpc.AssetProof
-	26, // 68: universerpc.Universe.PushProof:input_type -> universerpc.PushProofRequest
-	28, // 69: universerpc.Universe.Info:input_type -> universerpc.InfoRequest
-	31, // 70: universerpc.Universe.SyncUniverse:input_type -> universerpc.SyncRequest
-	36, // 71: universerpc.Universe.ListFederationServers:input_type -> universerpc.ListFederationServersRequest
-	38, // 72: universerpc.Universe.AddFederationServer:input_type -> universerpc.AddFederationServerRequest
-	40, // 73: universerpc.Universe.DeleteFederationServer:input_type -> universerpc.DeleteFederationServerRequest
-	33, // 74: universerpc.Universe.UniverseStats:input_type -> universerpc.StatsRequest
-	43, // 75: universerpc.Universe.QueryAssetStats:input_type -> universerpc.AssetStatsQuery
-	47, // 76: universerpc.Universe.QueryEvents:input_type -> universerpc.QueryEventsRequest
-	50, // 77: universerpc.Universe.SetFederationSyncConfig:input_type -> universerpc.SetFederationSyncConfigRequest
-	54, // 78: universerpc.Universe.QueryFederationSyncConfig:input_type -> universerpc.QueryFederationSyncConfigRequest
-	6,  // 79: universerpc.Universe.MultiverseRoot:output_type -> universerpc.MultiverseRootResponse
-	11, // 80: universerpc.Universe.AssetRoots:output_type -> universerpc.AssetRootResponse
-	13, // 81: universerpc.Universe.QueryAssetRoots:output_type -> universerpc.QueryRootResponse
-	15, // 82: universerpc.Universe.DeleteAssetRoot:output_type -> universerpc.DeleteRootResponse
-	19, // 83: universerpc.Universe.AssetLeafKeys:output_type -> universerpc.AssetLeafKeyResponse
-	21, // 84: universerpc.Universe.AssetLeaves:output_type -> universerpc.AssetLeafResponse
-	23, // 85: universerpc.Universe.QueryProof:output_type -> universerpc.AssetProofResponse
-	23, // 86: universerpc.Universe.InsertProof:output_type -> universerpc.AssetProofResponse
-	27, // 87: universerpc.Universe.PushProof:output_type -> universerpc.PushProofResponse
-	29, // 88: universerpc.Universe.Info:output_type -> universerpc.InfoResponse
-	34, // 89: universerpc.Universe.SyncUniverse:output_type -> universerpc.SyncResponse
-	37, // 90: universerpc.Universe.ListFederationServers:output_type -> universerpc.ListFederationServersResponse
-	39, // 91: universerpc.Universe.AddFederationServer:output_type -> universerpc.AddFederationServerResponse
-	41, // 92: universerpc.Universe.DeleteFederationServer:output_type -> universerpc.DeleteFederationServerResponse
-	42, // 93: universerpc.Universe.UniverseStats:output_type -> universerpc.StatsResponse
-	46, // 94: universerpc.Universe.QueryAssetStats:output_type -> universerpc.UniverseAssetStats
-	48, // 95: universerpc.Universe.QueryEvents:output_type -> universerpc.QueryEventsResponse
-	51, // 96: universerpc.Universe.SetFederationSyncConfig:output_type -> universerpc.SetFederationSyncConfigResponse
-	55, // 97: universerpc.Universe.QueryFederationSyncConfig:output_type -> universerpc.QueryFederationSyncConfigResponse
-	79, // [79:98] is the sub-list for method output_type
-	60, // [60:79] is the sub-list for method input_type
-	60, // [60:60] is the sub-list for extension type_name
-	60, // [60:60] is the sub-list for extension extendee
-	0,  // [0:60] is the sub-list for field type_name
+	70, // 59: universerpc.IgnoreAssetOutPointRequest.asset_out_point:type_name -> taprpc.AssetOutPoint
+	8,  // 60: universerpc.IgnoreAssetOutPointResponse.leaf:type_name -> universerpc.MerkleSumNode
+	8,  // 61: universerpc.SupplyCommitSubtreeRoot.root_node:type_name -> universerpc.MerkleSumNode
+	8,  // 62: universerpc.FetchSupplyCommitResponse.supply_commitment_root:type_name -> universerpc.MerkleSumNode
+	61, // 63: universerpc.FetchSupplyCommitResponse.issuance_subtree_root:type_name -> universerpc.SupplyCommitSubtreeRoot
+	61, // 64: universerpc.FetchSupplyCommitResponse.burn_subtree_root:type_name -> universerpc.SupplyCommitSubtreeRoot
+	61, // 65: universerpc.FetchSupplyCommitResponse.ignore_subtree_root:type_name -> universerpc.SupplyCommitSubtreeRoot
+	10, // 66: universerpc.AssetRootResponse.UniverseRootsEntry.value:type_name -> universerpc.UniverseRoot
+	5,  // 67: universerpc.Universe.MultiverseRoot:input_type -> universerpc.MultiverseRootRequest
+	7,  // 68: universerpc.Universe.AssetRoots:input_type -> universerpc.AssetRootRequest
+	12, // 69: universerpc.Universe.QueryAssetRoots:input_type -> universerpc.AssetRootQuery
+	14, // 70: universerpc.Universe.DeleteAssetRoot:input_type -> universerpc.DeleteRootQuery
+	18, // 71: universerpc.Universe.AssetLeafKeys:input_type -> universerpc.AssetLeafKeysRequest
+	9,  // 72: universerpc.Universe.AssetLeaves:input_type -> universerpc.ID
+	22, // 73: universerpc.Universe.QueryProof:input_type -> universerpc.UniverseKey
+	25, // 74: universerpc.Universe.InsertProof:input_type -> universerpc.AssetProof
+	26, // 75: universerpc.Universe.PushProof:input_type -> universerpc.PushProofRequest
+	28, // 76: universerpc.Universe.Info:input_type -> universerpc.InfoRequest
+	31, // 77: universerpc.Universe.SyncUniverse:input_type -> universerpc.SyncRequest
+	36, // 78: universerpc.Universe.ListFederationServers:input_type -> universerpc.ListFederationServersRequest
+	38, // 79: universerpc.Universe.AddFederationServer:input_type -> universerpc.AddFederationServerRequest
+	40, // 80: universerpc.Universe.DeleteFederationServer:input_type -> universerpc.DeleteFederationServerRequest
+	33, // 81: universerpc.Universe.UniverseStats:input_type -> universerpc.StatsRequest
+	43, // 82: universerpc.Universe.QueryAssetStats:input_type -> universerpc.AssetStatsQuery
+	47, // 83: universerpc.Universe.QueryEvents:input_type -> universerpc.QueryEventsRequest
+	50, // 84: universerpc.Universe.SetFederationSyncConfig:input_type -> universerpc.SetFederationSyncConfigRequest
+	54, // 85: universerpc.Universe.QueryFederationSyncConfig:input_type -> universerpc.QueryFederationSyncConfigRequest
+	56, // 86: universerpc.Universe.IgnoreAssetOutPoint:input_type -> universerpc.IgnoreAssetOutPointRequest
+	58, // 87: universerpc.Universe.UpdateSupplyCommit:input_type -> universerpc.UpdateSupplyCommitRequest
+	60, // 88: universerpc.Universe.FetchSupplyCommit:input_type -> universerpc.FetchSupplyCommitRequest
+	6,  // 89: universerpc.Universe.MultiverseRoot:output_type -> universerpc.MultiverseRootResponse
+	11, // 90: universerpc.Universe.AssetRoots:output_type -> universerpc.AssetRootResponse
+	13, // 91: universerpc.Universe.QueryAssetRoots:output_type -> universerpc.QueryRootResponse
+	15, // 92: universerpc.Universe.DeleteAssetRoot:output_type -> universerpc.DeleteRootResponse
+	19, // 93: universerpc.Universe.AssetLeafKeys:output_type -> universerpc.AssetLeafKeyResponse
+	21, // 94: universerpc.Universe.AssetLeaves:output_type -> universerpc.AssetLeafResponse
+	23, // 95: universerpc.Universe.QueryProof:output_type -> universerpc.AssetProofResponse
+	23, // 96: universerpc.Universe.InsertProof:output_type -> universerpc.AssetProofResponse
+	27, // 97: universerpc.Universe.PushProof:output_type -> universerpc.PushProofResponse
+	29, // 98: universerpc.Universe.Info:output_type -> universerpc.InfoResponse
+	34, // 99: universerpc.Universe.SyncUniverse:output_type -> universerpc.SyncResponse
+	37, // 100: universerpc.Universe.ListFederationServers:output_type -> universerpc.ListFederationServersResponse
+	39, // 101: universerpc.Universe.AddFederationServer:output_type -> universerpc.AddFederationServerResponse
+	41, // 102: universerpc.Universe.DeleteFederationServer:output_type -> universerpc.DeleteFederationServerResponse
+	42, // 103: universerpc.Universe.UniverseStats:output_type -> universerpc.StatsResponse
+	46, // 104: universerpc.Universe.QueryAssetStats:output_type -> universerpc.UniverseAssetStats
+	48, // 105: universerpc.Universe.QueryEvents:output_type -> universerpc.QueryEventsResponse
+	51, // 106: universerpc.Universe.SetFederationSyncConfig:output_type -> universerpc.SetFederationSyncConfigResponse
+	55, // 107: universerpc.Universe.QueryFederationSyncConfig:output_type -> universerpc.QueryFederationSyncConfigResponse
+	57, // 108: universerpc.Universe.IgnoreAssetOutPoint:output_type -> universerpc.IgnoreAssetOutPointResponse
+	59, // 109: universerpc.Universe.UpdateSupplyCommit:output_type -> universerpc.UpdateSupplyCommitResponse
+	62, // 110: universerpc.Universe.FetchSupplyCommit:output_type -> universerpc.FetchSupplyCommitResponse
+	89, // [89:111] is the sub-list for method output_type
+	67, // [67:89] is the sub-list for method input_type
+	67, // [67:67] is the sub-list for extension type_name
+	67, // [67:67] is the sub-list for extension extendee
+	0,  // [0:67] is the sub-list for field type_name
 }
 
 func init() { file_universerpc_universe_proto_init() }
@@ -4731,6 +5486,90 @@ func file_universerpc_universe_proto_init() {
 				return nil
 			}
 		}
+		file_universerpc_universe_proto_msgTypes[51].Exporter = func(v any, i int) any {
+			switch v := v.(*IgnoreAssetOutPointRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_universerpc_universe_proto_msgTypes[52].Exporter = func(v any, i int) any {
+			switch v := v.(*IgnoreAssetOutPointResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_universerpc_universe_proto_msgTypes[53].Exporter = func(v any, i int) any {
+			switch v := v.(*UpdateSupplyCommitRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_universerpc_universe_proto_msgTypes[54].Exporter = func(v any, i int) any {
+			switch v := v.(*UpdateSupplyCommitResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_universerpc_universe_proto_msgTypes[55].Exporter = func(v any, i int) any {
+			switch v := v.(*FetchSupplyCommitRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_universerpc_universe_proto_msgTypes[56].Exporter = func(v any, i int) any {
+			switch v := v.(*SupplyCommitSubtreeRoot); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_universerpc_universe_proto_msgTypes[57].Exporter = func(v any, i int) any {
+			switch v := v.(*FetchSupplyCommitResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	file_universerpc_universe_proto_msgTypes[4].OneofWrappers = []any{
 		(*ID_AssetId)(nil),
@@ -4744,13 +5583,21 @@ func file_universerpc_universe_proto_init() {
 		(*AssetKey_ScriptKeyBytes)(nil),
 		(*AssetKey_ScriptKeyStr)(nil),
 	}
+	file_universerpc_universe_proto_msgTypes[53].OneofWrappers = []any{
+		(*UpdateSupplyCommitRequest_GroupKeyBytes)(nil),
+		(*UpdateSupplyCommitRequest_GroupKeyStr)(nil),
+	}
+	file_universerpc_universe_proto_msgTypes[55].OneofWrappers = []any{
+		(*FetchSupplyCommitRequest_GroupKeyBytes)(nil),
+		(*FetchSupplyCommitRequest_GroupKeyStr)(nil),
+	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_universerpc_universe_proto_rawDesc,
 			NumEnums:      5,
-			NumMessages:   53,
+			NumMessages:   60,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/taprpc/universerpc/universe.pb.gw.go b/taprpc/universerpc/universe.pb.gw.go
index cd8d3721..05c8820a 100644
--- a/taprpc/universerpc/universe.pb.gw.go
+++ b/taprpc/universerpc/universe.pb.gw.go
@@ -1585,6 +1585,182 @@ func local_request_Universe_QueryFederationSyncConfig_0(ctx context.Context, mar
 
 }
 
+func request_Universe_IgnoreAssetOutPoint_0(ctx context.Context, marshaler runtime.Marshaler, client UniverseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq IgnoreAssetOutPointRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.IgnoreAssetOutPoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Universe_IgnoreAssetOutPoint_0(ctx context.Context, marshaler runtime.Marshaler, server UniverseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq IgnoreAssetOutPointRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.IgnoreAssetOutPoint(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Universe_UpdateSupplyCommit_0(ctx context.Context, marshaler runtime.Marshaler, client UniverseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq UpdateSupplyCommitRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["group_key_str"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "group_key_str")
+	}
+
+	if protoReq.GroupKey == nil {
+		protoReq.GroupKey = &UpdateSupplyCommitRequest_GroupKeyStr{}
+	} else if _, ok := protoReq.GroupKey.(*UpdateSupplyCommitRequest_GroupKeyStr); !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *UpdateSupplyCommitRequest_GroupKeyStr, but: %t\n", protoReq.GroupKey)
+	}
+	protoReq.GroupKey.(*UpdateSupplyCommitRequest_GroupKeyStr).GroupKeyStr, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "group_key_str", err)
+	}
+
+	msg, err := client.UpdateSupplyCommit(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Universe_UpdateSupplyCommit_0(ctx context.Context, marshaler runtime.Marshaler, server UniverseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq UpdateSupplyCommitRequest
+	var metadata runtime.ServerMetadata
+
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["group_key_str"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "group_key_str")
+	}
+
+	if protoReq.GroupKey == nil {
+		protoReq.GroupKey = &UpdateSupplyCommitRequest_GroupKeyStr{}
+	} else if _, ok := protoReq.GroupKey.(*UpdateSupplyCommitRequest_GroupKeyStr); !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *UpdateSupplyCommitRequest_GroupKeyStr, but: %t\n", protoReq.GroupKey)
+	}
+	protoReq.GroupKey.(*UpdateSupplyCommitRequest_GroupKeyStr).GroupKeyStr, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "group_key_str", err)
+	}
+
+	msg, err := server.UpdateSupplyCommit(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Universe_FetchSupplyCommit_0 = &utilities.DoubleArray{Encoding: map[string]int{"group_key_str": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Universe_FetchSupplyCommit_0(ctx context.Context, marshaler runtime.Marshaler, client UniverseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq FetchSupplyCommitRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["group_key_str"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "group_key_str")
+	}
+
+	if protoReq.GroupKey == nil {
+		protoReq.GroupKey = &FetchSupplyCommitRequest_GroupKeyStr{}
+	} else if _, ok := protoReq.GroupKey.(*FetchSupplyCommitRequest_GroupKeyStr); !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *FetchSupplyCommitRequest_GroupKeyStr, but: %t\n", protoReq.GroupKey)
+	}
+	protoReq.GroupKey.(*FetchSupplyCommitRequest_GroupKeyStr).GroupKeyStr, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "group_key_str", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Universe_FetchSupplyCommit_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.FetchSupplyCommit(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Universe_FetchSupplyCommit_0(ctx context.Context, marshaler runtime.Marshaler, server UniverseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq FetchSupplyCommitRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["group_key_str"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "group_key_str")
+	}
+
+	if protoReq.GroupKey == nil {
+		protoReq.GroupKey = &FetchSupplyCommitRequest_GroupKeyStr{}
+	} else if _, ok := protoReq.GroupKey.(*FetchSupplyCommitRequest_GroupKeyStr); !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *FetchSupplyCommitRequest_GroupKeyStr, but: %t\n", protoReq.GroupKey)
+	}
+	protoReq.GroupKey.(*FetchSupplyCommitRequest_GroupKeyStr).GroupKeyStr, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "group_key_str", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Universe_FetchSupplyCommit_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.FetchSupplyCommit(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterUniverseHandlerServer registers the http handlers for service Universe to "mux".
 // UnaryRPC     :call UniverseServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -2216,6 +2392,81 @@ func RegisterUniverseHandlerServer(ctx context.Context, mux *runtime.ServeMux, s
 
 	})
 
+	mux.Handle("POST", pattern_Universe_IgnoreAssetOutPoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/universerpc.Universe/IgnoreAssetOutPoint", runtime.WithHTTPPathPattern("/v1/taproot-assets/universe/supply/ignore"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Universe_IgnoreAssetOutPoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Universe_IgnoreAssetOutPoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("POST", pattern_Universe_UpdateSupplyCommit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/universerpc.Universe/UpdateSupplyCommit", runtime.WithHTTPPathPattern("/v1/taproot-assets/universe/supply/{group_key_str}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Universe_UpdateSupplyCommit_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Universe_UpdateSupplyCommit_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Universe_FetchSupplyCommit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/universerpc.Universe/FetchSupplyCommit", runtime.WithHTTPPathPattern("/v1/taproot-assets/universe/supply/{group_key_str}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Universe_FetchSupplyCommit_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Universe_FetchSupplyCommit_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -2807,6 +3058,72 @@ func RegisterUniverseHandlerClient(ctx context.Context, mux *runtime.ServeMux, c
 
 	})
 
+	mux.Handle("POST", pattern_Universe_IgnoreAssetOutPoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/universerpc.Universe/IgnoreAssetOutPoint", runtime.WithHTTPPathPattern("/v1/taproot-assets/universe/supply/ignore"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Universe_IgnoreAssetOutPoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Universe_IgnoreAssetOutPoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("POST", pattern_Universe_UpdateSupplyCommit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/universerpc.Universe/UpdateSupplyCommit", runtime.WithHTTPPathPattern("/v1/taproot-assets/universe/supply/{group_key_str}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Universe_UpdateSupplyCommit_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Universe_UpdateSupplyCommit_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Universe_FetchSupplyCommit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/universerpc.Universe/FetchSupplyCommit", runtime.WithHTTPPathPattern("/v1/taproot-assets/universe/supply/{group_key_str}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Universe_FetchSupplyCommit_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Universe_FetchSupplyCommit_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -2860,6 +3177,12 @@ var (
 	pattern_Universe_SetFederationSyncConfig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "universe", "sync", "config"}, ""))
 
 	pattern_Universe_QueryFederationSyncConfig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "universe", "sync", "config"}, ""))
+
+	pattern_Universe_IgnoreAssetOutPoint_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "universe", "supply", "ignore"}, ""))
+
+	pattern_Universe_UpdateSupplyCommit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "universe", "supply", "group_key_str"}, ""))
+
+	pattern_Universe_FetchSupplyCommit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "universe", "supply", "group_key_str"}, ""))
 )
 
 var (
@@ -2912,4 +3235,10 @@ var (
 	forward_Universe_SetFederationSyncConfig_0 = runtime.ForwardResponseMessage
 
 	forward_Universe_QueryFederationSyncConfig_0 = runtime.ForwardResponseMessage
+
+	forward_Universe_IgnoreAssetOutPoint_0 = runtime.ForwardResponseMessage
+
+	forward_Universe_UpdateSupplyCommit_0 = runtime.ForwardResponseMessage
+
+	forward_Universe_FetchSupplyCommit_0 = runtime.ForwardResponseMessage
 )
diff --git a/taprpc/universerpc/universe.pb.json.go b/taprpc/universerpc/universe.pb.json.go
index e49af65f..26ea7642 100644
--- a/taprpc/universerpc/universe.pb.json.go
+++ b/taprpc/universerpc/universe.pb.json.go
@@ -495,4 +495,79 @@ func RegisterUniverseJSONCallbacks(registry map[string]func(ctx context.Context,
 		}
 		callback(string(respBytes), nil)
 	}
+
+	registry["universerpc.Universe.IgnoreAssetOutPoint"] = func(ctx context.Context,
+		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
+
+		req := &IgnoreAssetOutPointRequest{}
+		err := marshaler.Unmarshal([]byte(reqJSON), req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		client := NewUniverseClient(conn)
+		resp, err := client.IgnoreAssetOutPoint(ctx, req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		respBytes, err := marshaler.Marshal(resp)
+		if err != nil {
+			callback("", err)
+			return
+		}
+		callback(string(respBytes), nil)
+	}
+
+	registry["universerpc.Universe.UpdateSupplyCommit"] = func(ctx context.Context,
+		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
+
+		req := &UpdateSupplyCommitRequest{}
+		err := marshaler.Unmarshal([]byte(reqJSON), req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		client := NewUniverseClient(conn)
+		resp, err := client.UpdateSupplyCommit(ctx, req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		respBytes, err := marshaler.Marshal(resp)
+		if err != nil {
+			callback("", err)
+			return
+		}
+		callback(string(respBytes), nil)
+	}
+
+	registry["universerpc.Universe.FetchSupplyCommit"] = func(ctx context.Context,
+		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
+
+		req := &FetchSupplyCommitRequest{}
+		err := marshaler.Unmarshal([]byte(reqJSON), req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		client := NewUniverseClient(conn)
+		resp, err := client.FetchSupplyCommit(ctx, req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		respBytes, err := marshaler.Marshal(resp)
+		if err != nil {
+			callback("", err)
+			return
+		}
+		callback(string(respBytes), nil)
+	}
 }
diff --git a/taprpc/universerpc/universe.proto b/taprpc/universerpc/universe.proto
index e27da195..44718264 100644
--- a/taprpc/universerpc/universe.proto
+++ b/taprpc/universerpc/universe.proto
@@ -1,5 +1,6 @@
 syntax = "proto3";
 
+import "tapcommon.proto";
 import "taprootassets.proto";
 
 package universerpc;
@@ -154,6 +155,28 @@ service Universe {
     */
     rpc QueryFederationSyncConfig (QueryFederationSyncConfigRequest)
         returns (QueryFederationSyncConfigResponse);
+
+    /* tapcli: `universe ignoreoutpoint`
+    IgnoreAssetOutPoint allows an asset issuer to mark a specific asset outpoint
+    as ignored. An ignored outpoint will be included in the next universe supply
+    commitment transaction that is published.
+    */
+    rpc IgnoreAssetOutPoint (IgnoreAssetOutPointRequest)
+        returns (IgnoreAssetOutPointResponse);
+
+    /* tapcli: `universe updatesupplycommit`
+    UpdateSupplyCommit updates the on-chain supply commitment for a specific
+    asset group.
+    */
+    rpc UpdateSupplyCommit (UpdateSupplyCommitRequest)
+        returns (UpdateSupplyCommitResponse);
+
+    /* tapcli: `universe fetchsupplycommit`
+    FetchSupplyCommit fetches the on-chain supply commitment for a specific
+    asset group.
+    */
+    rpc FetchSupplyCommit (FetchSupplyCommitRequest)
+        returns (FetchSupplyCommitResponse);
 }
 
 message MultiverseRootRequest {
@@ -663,3 +686,130 @@ message QueryFederationSyncConfigResponse {
 
     repeated AssetFederationSyncConfig asset_sync_configs = 2;
 }
+
+message IgnoreAssetOutPointRequest {
+    // The outpoint of the asset to ignore.
+    taprpc.AssetOutPoint asset_out_point = 1;
+
+    // The amount of asset units at the associated asset outpoint.
+    uint64 amount = 2;
+}
+
+message IgnoreAssetOutPointResponse {
+    // The key identifying the signed ignore outpoint leaf in the ignore supply
+    // commitment subtree.
+    bytes leaf_key = 1;
+
+    // The signed ignore outpoint leaf in the ignore supply commitment tree.
+    MerkleSumNode leaf = 2;
+}
+
+message UpdateSupplyCommitRequest {
+    // The unique identifier for the target asset group whose supply commitment
+    // is being updated.
+    oneof group_key {
+        // The 32-byte asset group key specified as raw bytes (gRPC only).
+        bytes group_key_bytes = 1;
+
+        // The 32-byte asset group key encoded as hex string (use this for
+        // REST).
+        string group_key_str = 2;
+    }
+}
+
+message UpdateSupplyCommitResponse {
+}
+
+message FetchSupplyCommitRequest {
+    // The unique identifier for the target asset group whose supply commitment
+    // is being fetched.
+    oneof group_key {
+        // The 32-byte asset group key specified as raw bytes (gRPC only).
+        bytes group_key_bytes = 1;
+
+        // The 32-byte asset group key encoded as hex string (use this for
+        // REST).
+        string group_key_str = 2;
+    }
+
+    // Optional: A list of issuance leaf keys. For each key in this list,
+    // the endpoint will generate and return an inclusion proof.
+    repeated bytes issuance_leaf_keys = 3;
+
+    // Optional: A list of burn leaf keys. For each key in this list,
+    // the endpoint will generate and return an inclusion proof.
+    repeated bytes burn_leaf_keys = 4;
+
+    // Optional: A list of ignore leaf keys. For each key in this list, the
+    // endpoint will generate and return an inclusion proof.
+    repeated bytes ignore_leaf_keys = 5;
+}
+
+message SupplyCommitSubtreeRoot {
+    // The type of the supply commit subtree.
+    string type = 1;
+
+    // The root node of the supply commit subtree.
+    MerkleSumNode root_node = 2;
+
+    // The leaf key which locates the subtree leaf node in the supply commit
+    // tree.
+    bytes supply_tree_leaf_key = 3;
+
+    // The inclusion proof for the supply commit subtree root node.
+    bytes supply_tree_inclusion_proof = 4;
+}
+
+message FetchSupplyCommitResponse {
+    // The supply commitment merkle sum root node for the specified asset.
+    MerkleSumNode supply_commitment_root = 1;
+
+    // The txid of the anchor transaction that commits to the supply
+    // commitment for the specified asset.
+    string anchor_txid = 2;
+
+    // The output index of the anchor transaction that commits to the supply
+    // commitment for the specified asset.
+    uint32 anchor_tx_out_idx = 3;
+
+    // The transaction output taproot internal key of the anchor transaction
+    // that commits to the supply commitment for the specified asset.
+    bytes anchor_tx_out_internal_key = 4;
+
+    // The height of the block at which the supply commitment was anchored.
+    uint32 block_height = 5;
+
+    // The hash of the block at which the supply commitment was anchored.
+    bytes block_hash = 6;
+
+    // The index of the transaction in the block that commits to the supply
+    // commitment.
+    uint32 block_tx_index = 7;
+
+    // The total number of satoshis in on-chain fees paid by the supply
+    // commitment transaction.
+    int64 tx_chain_fees_sats = 8;
+
+    // The root of the issuance tree for the specified asset.
+    SupplyCommitSubtreeRoot issuance_subtree_root = 9;
+
+    // The root of the burn tree for the specified asset.
+    SupplyCommitSubtreeRoot burn_subtree_root = 10;
+
+    // The root of the ignore tree for the specified asset.
+    SupplyCommitSubtreeRoot ignore_subtree_root = 11;
+
+    // Inclusion proofs for each issuance leaf key provided in the request.
+    // Each entry corresponds to the key at the same index in
+    // `issuance_leaf_keys`.
+    repeated bytes issuance_leaf_inclusion_proofs = 12;
+
+    // Inclusion proofs for each burn leaf key provided in the request.
+    // Each entry corresponds to the key at the same index in `burn_leaf_keys`.
+    repeated bytes burn_leaf_inclusion_proofs = 13;
+
+    // Inclusion proofs for each ignored leaf key provided in the request.
+    // Each entry corresponds to the key at the same index in
+    // `ignore_leaf_keys`.
+    repeated bytes ignore_leaf_inclusion_proofs = 14;
+}
\ No newline at end of file
diff --git a/taprpc/universerpc/universe.swagger.json b/taprpc/universerpc/universe.swagger.json
index 13a731d5..331d3fc9 100644
--- a/taprpc/universerpc/universe.swagger.json
+++ b/taprpc/universerpc/universe.swagger.json
@@ -1332,6 +1332,153 @@
         ]
       }
     },
+    "/v1/taproot-assets/universe/supply/ignore": {
+      "post": {
+        "summary": "tapcli: `universe ignoreoutpoint`\nIgnoreAssetOutPoint allows an asset issuer to mark a specific asset outpoint\nas ignored. An ignored outpoint will be included in the next universe supply\ncommitment transaction that is published.",
+        "operationId": "Universe_IgnoreAssetOutPoint",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/universerpcIgnoreAssetOutPointResponse"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/universerpcIgnoreAssetOutPointRequest"
+            }
+          }
+        ],
+        "tags": [
+          "Universe"
+        ]
+      }
+    },
+    "/v1/taproot-assets/universe/supply/{group_key_str}": {
+      "get": {
+        "summary": "tapcli: `universe fetchsupplycommit`\nFetchSupplyCommit fetches the on-chain supply commitment for a specific\nasset group.",
+        "operationId": "Universe_FetchSupplyCommit",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/universerpcFetchSupplyCommitResponse"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "group_key_str",
+            "description": "The 32-byte asset group key encoded as hex string (use this for\nREST).",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "group_key_bytes",
+            "description": "The 32-byte asset group key specified as raw bytes (gRPC only).",
+            "in": "query",
+            "required": false,
+            "type": "string",
+            "format": "byte"
+          },
+          {
+            "name": "issuance_leaf_keys",
+            "description": "Optional: A list of issuance leaf keys. For each key in this list,\nthe endpoint will generate and return an inclusion proof.",
+            "in": "query",
+            "required": false,
+            "type": "array",
+            "items": {
+              "type": "string",
+              "format": "byte"
+            },
+            "collectionFormat": "multi"
+          },
+          {
+            "name": "burn_leaf_keys",
+            "description": "Optional: A list of burn leaf keys. For each key in this list,\nthe endpoint will generate and return an inclusion proof.",
+            "in": "query",
+            "required": false,
+            "type": "array",
+            "items": {
+              "type": "string",
+              "format": "byte"
+            },
+            "collectionFormat": "multi"
+          },
+          {
+            "name": "ignore_leaf_keys",
+            "description": "Optional: A list of ignore leaf keys. For each key in this list, the\nendpoint will generate and return an inclusion proof.",
+            "in": "query",
+            "required": false,
+            "type": "array",
+            "items": {
+              "type": "string",
+              "format": "byte"
+            },
+            "collectionFormat": "multi"
+          }
+        ],
+        "tags": [
+          "Universe"
+        ]
+      },
+      "post": {
+        "summary": "tapcli: `universe updatesupplycommit`\nUpdateSupplyCommit updates the on-chain supply commitment for a specific\nasset group.",
+        "operationId": "Universe_UpdateSupplyCommit",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/universerpcUpdateSupplyCommitResponse"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "group_key_str",
+            "description": "The 32-byte asset group key encoded as hex string (use this for\nREST).",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/UniverseUpdateSupplyCommitBody"
+            }
+          }
+        ],
+        "tags": [
+          "Universe"
+        ]
+      }
+    },
     "/v1/taproot-assets/universe/sync": {
       "post": {
         "summary": "tapcli: `universe sync`\nSyncUniverse takes host information for a remote Universe server, then\nattempts to synchronize either only the set of specified asset_ids, or all\nassets if none are specified. The sync process will attempt to query for\nthe latest known root for each asset, performing tree based reconciliation\nto arrive at a new shared root.",
@@ -1535,6 +1682,16 @@
         }
       }
     },
+    "UniverseUpdateSupplyCommitBody": {
+      "type": "object",
+      "properties": {
+        "group_key_bytes": {
+          "type": "string",
+          "format": "byte",
+          "description": "The 32-byte asset group key specified as raw bytes (gRPC only)."
+        }
+      }
+    },
     "protobufAny": {
       "type": "object",
       "properties": {
@@ -1750,6 +1907,26 @@
       "default": "META_TYPE_OPAQUE",
       "description": " - META_TYPE_OPAQUE: Opaque is used for asset meta blobs that have no true structure and instead\nshould be interpreted as opaque blobs.\n - META_TYPE_JSON: JSON is used for asset meta blobs that are to be interpreted as valid JSON\nstrings."
     },
+    "taprpcAssetOutPoint": {
+      "type": "object",
+      "properties": {
+        "anchor_out_point": {
+          "type": "string",
+          "description": "The outpoint of the asset anchor, represented as a string in the\nformat \"\u003ctxid\u003e:\u003cvout\u003e\". The \u003ctxid\u003e is the transaction ID of the UTXO,\nhex-encoded and byte-reversed (i.e., the internal little-endian\n32-byte value is reversed to big-endian hex format) to match standard\nBitcoin RPC and UI conventions."
+        },
+        "asset_id": {
+          "type": "string",
+          "format": "byte",
+          "description": "The asset ID of the asset anchored at the outpoint."
+        },
+        "script_key": {
+          "type": "string",
+          "format": "byte",
+          "description": "The script key of the asset. This is the taproot output key that the\nasset is locked to."
+        }
+      },
+      "description": "A transaction outpoint annotated with TAP-level asset metadata. It uniquely\nidentifies an asset anchored at a specific outpoint."
+    },
     "taprpcAssetType": {
       "type": "string",
       "enum": [
@@ -2131,6 +2308,85 @@
     "universerpcDeleteRootResponse": {
       "type": "object"
     },
+    "universerpcFetchSupplyCommitResponse": {
+      "type": "object",
+      "properties": {
+        "supply_commitment_root": {
+          "$ref": "#/definitions/universerpcMerkleSumNode",
+          "description": "The supply commitment merkle sum root node for the specified asset."
+        },
+        "anchor_txid": {
+          "type": "string",
+          "description": "The txid of the anchor transaction that commits to the supply\ncommitment for the specified asset."
+        },
+        "anchor_tx_out_idx": {
+          "type": "integer",
+          "format": "int64",
+          "description": "The output index of the anchor transaction that commits to the supply\ncommitment for the specified asset."
+        },
+        "anchor_tx_out_internal_key": {
+          "type": "string",
+          "format": "byte",
+          "description": "The transaction output taproot internal key of the anchor transaction\nthat commits to the supply commitment for the specified asset."
+        },
+        "block_height": {
+          "type": "integer",
+          "format": "int64",
+          "description": "The height of the block at which the supply commitment was anchored."
+        },
+        "block_hash": {
+          "type": "string",
+          "format": "byte",
+          "description": "The hash of the block at which the supply commitment was anchored."
+        },
+        "block_tx_index": {
+          "type": "integer",
+          "format": "int64",
+          "description": "The index of the transaction in the block that commits to the supply\ncommitment."
+        },
+        "tx_chain_fees_sats": {
+          "type": "string",
+          "format": "int64",
+          "description": "The total number of satoshis in on-chain fees paid by the supply\ncommitment transaction."
+        },
+        "issuance_subtree_root": {
+          "$ref": "#/definitions/universerpcSupplyCommitSubtreeRoot",
+          "description": "The root of the issuance tree for the specified asset."
+        },
+        "burn_subtree_root": {
+          "$ref": "#/definitions/universerpcSupplyCommitSubtreeRoot",
+          "description": "The root of the burn tree for the specified asset."
+        },
+        "ignore_subtree_root": {
+          "$ref": "#/definitions/universerpcSupplyCommitSubtreeRoot",
+          "description": "The root of the ignore tree for the specified asset."
+        },
+        "issuance_leaf_inclusion_proofs": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "byte"
+          },
+          "description": "Inclusion proofs for each issuance leaf key provided in the request.\nEach entry corresponds to the key at the same index in\n`issuance_leaf_keys`."
+        },
+        "burn_leaf_inclusion_proofs": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "byte"
+          },
+          "description": "Inclusion proofs for each burn leaf key provided in the request.\nEach entry corresponds to the key at the same index in `burn_leaf_keys`."
+        },
+        "ignore_leaf_inclusion_proofs": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "byte"
+          },
+          "description": "Inclusion proofs for each ignored leaf key provided in the request.\nEach entry corresponds to the key at the same index in\n`ignore_leaf_keys`."
+        }
+      }
+    },
     "universerpcGlobalFederationSyncConfig": {
       "type": "object",
       "properties": {
@@ -2192,6 +2448,34 @@
         }
       }
     },
+    "universerpcIgnoreAssetOutPointRequest": {
+      "type": "object",
+      "properties": {
+        "asset_out_point": {
+          "$ref": "#/definitions/taprpcAssetOutPoint",
+          "description": "The outpoint of the asset to ignore."
+        },
+        "amount": {
+          "type": "string",
+          "format": "uint64",
+          "description": "The amount of asset units at the associated asset outpoint."
+        }
+      }
+    },
+    "universerpcIgnoreAssetOutPointResponse": {
+      "type": "object",
+      "properties": {
+        "leaf_key": {
+          "type": "string",
+          "format": "byte",
+          "description": "The key identifying the signed ignore outpoint leaf in the ignore supply\ncommitment subtree."
+        },
+        "leaf": {
+          "$ref": "#/definitions/universerpcMerkleSumNode",
+          "description": "The signed ignore outpoint leaf in the ignore supply commitment tree."
+        }
+      }
+    },
     "universerpcInfoResponse": {
       "type": "object",
       "properties": {
@@ -2399,6 +2683,29 @@
         }
       }
     },
+    "universerpcSupplyCommitSubtreeRoot": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "The type of the supply commit subtree."
+        },
+        "root_node": {
+          "$ref": "#/definitions/universerpcMerkleSumNode",
+          "description": "The root node of the supply commit subtree."
+        },
+        "supply_tree_leaf_key": {
+          "type": "string",
+          "format": "byte",
+          "description": "The leaf key which locates the subtree leaf node in the supply commit\ntree."
+        },
+        "supply_tree_inclusion_proof": {
+          "type": "string",
+          "format": "byte",
+          "description": "The inclusion proof for the supply commit subtree root node."
+        }
+      }
+    },
     "universerpcSyncRequest": {
       "type": "object",
       "properties": {
@@ -2531,6 +2838,9 @@
       ],
       "default": "SYNC_ISSUANCE_ONLY",
       "description": " - SYNC_ISSUANCE_ONLY: A sync node that indicates that only new asset creation (minting) proofs\nshould be synced.\n - SYNC_FULL: A syncing mode that indicates that all asset proofs should be synced.\nThis includes normal transfers as well."
+    },
+    "universerpcUpdateSupplyCommitResponse": {
+      "type": "object"
     }
   }
 }
diff --git a/taprpc/universerpc/universe.yaml b/taprpc/universerpc/universe.yaml
index c45a04d7..f3b124bf 100644
--- a/taprpc/universerpc/universe.yaml
+++ b/taprpc/universerpc/universe.yaml
@@ -79,3 +79,14 @@ http:
 
     - selector: universerpc.Universe.QueryEvents
       get: "/v1/taproot-assets/universe/stats/events"
+
+    - selector: universerpc.Universe.IgnoreAssetOutPoint
+      post: "/v1/taproot-assets/universe/supply/ignore"
+      body: "*"
+
+    - selector: universerpc.Universe.UpdateSupplyCommit
+      post: "/v1/taproot-assets/universe/supply/{group_key_str}"
+      body: "*"
+
+    - selector: universerpc.Universe.FetchSupplyCommit
+      get: "/v1/taproot-assets/universe/supply/{group_key_str}"
\ No newline at end of file
diff --git a/taprpc/universerpc/universe_grpc.pb.go b/taprpc/universerpc/universe_grpc.pb.go
index bc802a19..a117e9b9 100644
--- a/taprpc/universerpc/universe_grpc.pb.go
+++ b/taprpc/universerpc/universe_grpc.pb.go
@@ -115,6 +115,19 @@ type UniverseClient interface {
 	// QueryFederationSyncConfig queries the universe federation sync configuration
 	// settings.
 	QueryFederationSyncConfig(ctx context.Context, in *QueryFederationSyncConfigRequest, opts ...grpc.CallOption) (*QueryFederationSyncConfigResponse, error)
+	// tapcli: `universe ignoreoutpoint`
+	// IgnoreAssetOutPoint allows an asset issuer to mark a specific asset outpoint
+	// as ignored. An ignored outpoint will be included in the next universe supply
+	// commitment transaction that is published.
+	IgnoreAssetOutPoint(ctx context.Context, in *IgnoreAssetOutPointRequest, opts ...grpc.CallOption) (*IgnoreAssetOutPointResponse, error)
+	// tapcli: `universe updatesupplycommit`
+	// UpdateSupplyCommit updates the on-chain supply commitment for a specific
+	// asset group.
+	UpdateSupplyCommit(ctx context.Context, in *UpdateSupplyCommitRequest, opts ...grpc.CallOption) (*UpdateSupplyCommitResponse, error)
+	// tapcli: `universe fetchsupplycommit`
+	// FetchSupplyCommit fetches the on-chain supply commitment for a specific
+	// asset group.
+	FetchSupplyCommit(ctx context.Context, in *FetchSupplyCommitRequest, opts ...grpc.CallOption) (*FetchSupplyCommitResponse, error)
 }
 
 type universeClient struct {
@@ -296,6 +309,33 @@ func (c *universeClient) QueryFederationSyncConfig(ctx context.Context, in *Quer
 	return out, nil
 }
 
+func (c *universeClient) IgnoreAssetOutPoint(ctx context.Context, in *IgnoreAssetOutPointRequest, opts ...grpc.CallOption) (*IgnoreAssetOutPointResponse, error) {
+	out := new(IgnoreAssetOutPointResponse)
+	err := c.cc.Invoke(ctx, "/universerpc.Universe/IgnoreAssetOutPoint", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *universeClient) UpdateSupplyCommit(ctx context.Context, in *UpdateSupplyCommitRequest, opts ...grpc.CallOption) (*UpdateSupplyCommitResponse, error) {
+	out := new(UpdateSupplyCommitResponse)
+	err := c.cc.Invoke(ctx, "/universerpc.Universe/UpdateSupplyCommit", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *universeClient) FetchSupplyCommit(ctx context.Context, in *FetchSupplyCommitRequest, opts ...grpc.CallOption) (*FetchSupplyCommitResponse, error) {
+	out := new(FetchSupplyCommitResponse)
+	err := c.cc.Invoke(ctx, "/universerpc.Universe/FetchSupplyCommit", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // UniverseServer is the server API for Universe service.
 // All implementations must embed UnimplementedUniverseServer
 // for forward compatibility
@@ -397,6 +437,19 @@ type UniverseServer interface {
 	// QueryFederationSyncConfig queries the universe federation sync configuration
 	// settings.
 	QueryFederationSyncConfig(context.Context, *QueryFederationSyncConfigRequest) (*QueryFederationSyncConfigResponse, error)
+	// tapcli: `universe ignoreoutpoint`
+	// IgnoreAssetOutPoint allows an asset issuer to mark a specific asset outpoint
+	// as ignored. An ignored outpoint will be included in the next universe supply
+	// commitment transaction that is published.
+	IgnoreAssetOutPoint(context.Context, *IgnoreAssetOutPointRequest) (*IgnoreAssetOutPointResponse, error)
+	// tapcli: `universe updatesupplycommit`
+	// UpdateSupplyCommit updates the on-chain supply commitment for a specific
+	// asset group.
+	UpdateSupplyCommit(context.Context, *UpdateSupplyCommitRequest) (*UpdateSupplyCommitResponse, error)
+	// tapcli: `universe fetchsupplycommit`
+	// FetchSupplyCommit fetches the on-chain supply commitment for a specific
+	// asset group.
+	FetchSupplyCommit(context.Context, *FetchSupplyCommitRequest) (*FetchSupplyCommitResponse, error)
 	mustEmbedUnimplementedUniverseServer()
 }
 
@@ -461,6 +514,15 @@ func (UnimplementedUniverseServer) SetFederationSyncConfig(context.Context, *Set
 func (UnimplementedUniverseServer) QueryFederationSyncConfig(context.Context, *QueryFederationSyncConfigRequest) (*QueryFederationSyncConfigResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method QueryFederationSyncConfig not implemented")
 }
+func (UnimplementedUniverseServer) IgnoreAssetOutPoint(context.Context, *IgnoreAssetOutPointRequest) (*IgnoreAssetOutPointResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method IgnoreAssetOutPoint not implemented")
+}
+func (UnimplementedUniverseServer) UpdateSupplyCommit(context.Context, *UpdateSupplyCommitRequest) (*UpdateSupplyCommitResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateSupplyCommit not implemented")
+}
+func (UnimplementedUniverseServer) FetchSupplyCommit(context.Context, *FetchSupplyCommitRequest) (*FetchSupplyCommitResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method FetchSupplyCommit not implemented")
+}
 func (UnimplementedUniverseServer) mustEmbedUnimplementedUniverseServer() {}
 
 // UnsafeUniverseServer may be embedded to opt out of forward compatibility for this service.
@@ -816,6 +878,60 @@ func _Universe_QueryFederationSyncConfig_Handler(srv interface{}, ctx context.Co
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Universe_IgnoreAssetOutPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(IgnoreAssetOutPointRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(UniverseServer).IgnoreAssetOutPoint(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/universerpc.Universe/IgnoreAssetOutPoint",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(UniverseServer).IgnoreAssetOutPoint(ctx, req.(*IgnoreAssetOutPointRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Universe_UpdateSupplyCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateSupplyCommitRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(UniverseServer).UpdateSupplyCommit(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/universerpc.Universe/UpdateSupplyCommit",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(UniverseServer).UpdateSupplyCommit(ctx, req.(*UpdateSupplyCommitRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Universe_FetchSupplyCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FetchSupplyCommitRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(UniverseServer).FetchSupplyCommit(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/universerpc.Universe/FetchSupplyCommit",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(UniverseServer).FetchSupplyCommit(ctx, req.(*FetchSupplyCommitRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Universe_ServiceDesc is the grpc.ServiceDesc for Universe service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -899,6 +1015,18 @@ var Universe_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "QueryFederationSyncConfig",
 			Handler:    _Universe_QueryFederationSyncConfig_Handler,
 		},
+		{
+			MethodName: "IgnoreAssetOutPoint",
+			Handler:    _Universe_IgnoreAssetOutPoint_Handler,
+		},
+		{
+			MethodName: "UpdateSupplyCommit",
+			Handler:    _Universe_UpdateSupplyCommit_Handler,
+		},
+		{
+			MethodName: "FetchSupplyCommit",
+			Handler:    _Universe_FetchSupplyCommit_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "universerpc/universe.proto",
diff --git a/universe/ignore_records.go b/universe/ignore_records.go
index b39d2a10..51f55931 100644
--- a/universe/ignore_records.go
+++ b/universe/ignore_records.go
@@ -2,14 +2,20 @@ package universe
 
 import (
 	"bytes"
+	"context"
 	"crypto/sha256"
+
+	"fmt"
 	"io"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/mssmt"
+	"github.com/lightningnetwork/lnd/keychain"
+	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/tlv"
 )
 
@@ -92,6 +98,88 @@ func (i *IgnoreTuple) Record() tlv.Record {
 	)
 }
 
+// Encode serializes the IgnoreTuple to the given io.Writer.
+func (i *IgnoreTuple) Encode(w io.Writer) error {
+	stream, err := tlv.NewStream(i.Record())
+	if err != nil {
+		return err
+	}
+
+	return stream.Encode(w)
+}
+
+// Bytes returns the serialized IgnoreTuple.
+func (i *IgnoreTuple) Bytes() ([]byte, error) {
+	var buf bytes.Buffer
+	err := i.Encode(&buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// Digest returns the SHA256 digest of the TLV serialized IgnoreTuple.
+func (i *IgnoreTuple) Digest() ([sha256.Size]byte, error) {
+	var zero [sha256.Size]byte
+
+	ignoreBytes, err := i.Bytes()
+	if err != nil {
+		return zero, err
+	}
+
+	digest := sha256.Sum256(ignoreBytes)
+	return digest, nil
+}
+
+// GenSignedIgnore generates a Schnorr signature over the IgnoreTuple using the
+// provided SignerClient and key locator.
+func (i *IgnoreTuple) GenSignedIgnore(ctx context.Context,
+	signer lndclient.SignerClient,
+	key keychain.KeyLocator) (SignedIgnoreTuple, error) {
+
+	var zero SignedIgnoreTuple
+
+	// Formulate the digest of the IgnoreTuple from its TLV
+	// serialization.
+	digest, err := i.Digest()
+	if err != nil {
+		return zero, err
+	}
+
+	// Sign the digest using the provided key locator.
+	sigBytes, err := signer.SignMessage(
+		ctx, digest[:], key, lndclient.SignSchnorr(nil),
+	)
+	if err != nil {
+		return zero, err
+	}
+
+	// Convert the signature bytes to a Schnorr signature.
+	lnwireSig, err := lnwire.NewSigFromSchnorrRawSignature(sigBytes)
+	if err != nil {
+		return zero, err
+	}
+
+	sigPtr, err := lnwireSig.ToSignature()
+	if err != nil {
+		return zero, err
+	}
+
+	sig, ok := sigPtr.(*schnorr.Signature)
+	if !ok {
+		return zero, fmt.Errorf("failed to cast sig to " +
+			"*schnorr.Signature")
+	}
+
+	// Create the IgnoreSig from the Schnorr signature.
+	ignoreSig := IgnoreSig{
+		Signature: *sig,
+	}
+
+	return NewSignedIgnoreTuple(*i, ignoreSig), nil
+}
+
 // IgnoreTuples is a slice of IgnoreTuple.
 type IgnoreTuples = []*IgnoreTuple
 
diff --git a/universe/supplycommit/env.go b/universe/supplycommit/env.go
index c31c0cad..a0a5328b 100644
--- a/universe/supplycommit/env.go
+++ b/universe/supplycommit/env.go
@@ -9,9 +9,11 @@ import (
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapgarden"
@@ -143,6 +145,26 @@ func (p *PreCommitment) TxIn() *wire.TxIn {
 // PreCommits is a slice of pre-commitments.
 type PreCommits = []PreCommitment
 
+// CommitmentBlock captures the finalized on-chain state of a supply commitment
+// transaction after it has been mined. It records block-level metadata and the
+// actual fee paid to anchor the commitment.
+type CommitmentBlock struct {
+	// Height is the block height of the block that contains the
+	// commitment.
+	Height uint32
+
+	// Hash is the hash of the block that contains the commitment.
+	Hash chainhash.Hash
+
+	// TxIndex is the index of the supply commitment transaction within
+	// the block.
+	TxIndex uint32
+
+	// ChainFees is the amount in sats paid in on-chain fees for the
+	// supply commitment transaction.
+	ChainFees int64
+}
+
 // RootCommitment is the root commitment that contains the commitment to the the
 // sub-supply trees for a given asset.
 type RootCommitment struct {
@@ -164,6 +186,11 @@ type RootCommitment struct {
 	// sub-commitments. The sum value of this tree is the outstanding supply
 	// value.
 	SupplyRoot *mssmt.BranchNode
+
+	// CommitmentBlock is the block that contains the commitment to the
+	// asset supply. This may be None if the commitment has not yet
+	// been mined.
+	CommitmentBlock fn.Option[CommitmentBlock]
 }
 
 // TxIn returns the transaction input that corresponds to the root commitment.



Test patch:
diff --git a/internal/test/mock.go b/internal/test/mock.go
index a1cca7b9..08406bb5 100644
--- a/internal/test/mock.go
+++ b/internal/test/mock.go
@@ -37,7 +37,11 @@ type MockSigner struct {
 
 	SignOutputRawChannel chan SignOutputRawRequest
 
-	Signature    []byte
+	Signature []byte
+
+	// SignMessageErr holds the error returned by SignMessage, if any.
+	SignMessageErr error
+
 	SignatureMsg string
 }
 
@@ -66,6 +70,10 @@ func (s *MockSigner) SignMessage(_ context.Context, _ []byte,
 	_ keychain.KeyLocator, _ ...lndclient.SignMessageOption) ([]byte,
 	error) {
 
+	if s.SignMessageErr != nil {
+		return nil, s.SignMessageErr
+	}
+
 	return s.Signature, nil
 }
 
diff --git a/itest/psbt_test.go b/itest/psbt_test.go
index 72e2bbdf..c89cdec1 100644
--- a/itest/psbt_test.go
+++ b/itest/psbt_test.go
@@ -3619,10 +3619,19 @@ func sendToTapscriptAddr(ctx context.Context, t *harnessTest, alice,
 	AssertSendEventsComplete(t.t, bobAddr.ScriptKey, sendEvents)
 }
 
+// sendAssetAndAssertResponse is a struct that holds the response of a
+// sendAssetsToAddr call.
+type sendAssetAndAssertResponse struct {
+	// RpcResp is the response message returned by the SendAsset RPC
+	// endpoint.
+	RpcResp *taprpc.SendAssetResponse
+}
+
 func sendAssetAndAssert(ctx context.Context, t *harnessTest, alice,
 	bob *tapdHarness, numUnits, change uint64,
 	genInfo *taprpc.GenesisInfo, mintedAsset *taprpc.Asset,
-	outTransferIdx, numOutTransfers, numInTransfers int) {
+	outTransferIdx, numOutTransfers,
+	numInTransfers int) sendAssetAndAssertResponse {
 
 	// And finally, we make sure that we can send out one of the asset UTXOs
 	// that shared the anchor output and the other one is treated as a
@@ -3645,6 +3654,10 @@ func sendAssetAndAssert(ctx context.Context, t *harnessTest, alice,
 	// appear in that RPC output).
 	AssertNonInteractiveRecvComplete(t.t, bob, numInTransfers)
 	AssertSendEventsComplete(t.t, bobAddr.ScriptKey, sendEvents)
+
+	return sendAssetAndAssertResponse{
+		RpcResp: sendResp,
+	}
 }
 
 func signPacket(t *testing.T, lnd *node.HarnessNode,
diff --git a/itest/supply_commit_test.go b/itest/supply_commit_test.go
index d58cc397..60e2a944 100644
--- a/itest/supply_commit_test.go
+++ b/itest/supply_commit_test.go
@@ -3,13 +3,18 @@ package itest
 import (
 	"bytes"
 	"context"
+	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/fn"
+	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/taprpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/mintrpc"
+	unirpc "github.com/lightninglabs/taproot-assets/taprpc/universerpc"
+	"github.com/lightninglabs/taproot-assets/universe/supplycommit"
 	"github.com/stretchr/testify/require"
 )
 
@@ -132,3 +137,282 @@ func testPreCommitOutput(t *harnessTest) {
 	// Ensure that the second tranche asset is part of the same group.
 	require.EqualValues(t.t, tweakedGroupKey, secondAssetGroupKey)
 }
+
+// testSupplyCommitIgnoreAsset verifies that universe supply commitments
+// correctly account for ignored asset outpoints. It:
+//
+//  1. Mints an asset group with universe supply commitments enabled.
+//  2. Transfers a portion of the asset to a secondary node.
+//  3. Instructs the primary node to ignore the outpoint now owned by the
+//     secondary node.
+//  4. Updates the asset group’s supply commitment, which should now include
+//     the ignored outpoint in the “ignore” subtree.
+//  5. Mines the commitment transaction.
+//  6. Retrieves the updated supply commitment transaction and asserts that the
+//     ignored subtree contains the expected outpoint.
+func testSupplyCommitIgnoreAsset(t *harnessTest) {
+	ctxb := context.Background()
+
+	t.Log("Minting asset group with a single normal asset and " +
+		"universe/supply commitments enabled")
+	mintReq := issuableAssets[0]
+	mintReq.Asset.UniverseCommitments = true
+	rpcAssets := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner().Client, t.tapd,
+		[]*mintrpc.MintAssetRequest{mintReq},
+	)
+	require.Len(t.t, rpcAssets, 1, "expected one minted asset")
+	rpcAsset := rpcAssets[0]
+
+	// Send some of the asset to a secondary node. We will then use the
+	// primary node to ignore the asset outpoint owned by the secondary
+	// node.
+	t.Log("Setting up secondary node as recipient of asset")
+	secondLnd := t.lndHarness.NewNodeWithCoins("SecondLnd", nil)
+	secondTapd := setupTapdHarness(t.t, t, secondLnd, t.universeServer)
+	defer func() {
+		require.NoError(t.t, secondTapd.stop(!*noDelete))
+	}()
+
+	t.Log("Sending asset to secondary node")
+	sendAssetAmount := uint64(10)
+	sendChangeAmount := rpcAsset.Amount - sendAssetAmount
+
+	sendResp := sendAssetAndAssert(
+		ctxb, t, t.tapd, secondTapd, sendAssetAmount, sendChangeAmount,
+		rpcAsset.AssetGenesis, rpcAsset, 0, 1, 1,
+	)
+	require.Len(t.t, sendResp.RpcResp.Transfer.Outputs, 2)
+	t.Log("Asset transfer completed successfully")
+
+	// Parse the group key from the minted asset.
+	groupKeyBytes := rpcAsset.AssetGroup.TweakedGroupKey
+	require.NotNil(t.t, groupKeyBytes)
+
+	// Ignore the asset outpoint owned by the secondary node.
+	t.Log("Registering supply commitment asset ignore for asset outpoint " +
+		"owned by secondary node")
+
+	// Determine the transfer output owned by the secondary node.
+	// This is the output that we will ignore.
+	transferOutput := sendResp.RpcResp.Transfer.Outputs[0]
+	if sendResp.RpcResp.Transfer.Outputs[1].Amount == sendAssetAmount {
+		transferOutput = sendResp.RpcResp.Transfer.Outputs[1]
+	}
+
+	// Ignore the asset outpoint owned by the secondary node.
+	ignoreReq := &unirpc.IgnoreAssetOutPointRequest{
+		AssetOutPoint: &taprpc.AssetOutPoint{
+			AnchorOutPoint: transferOutput.Anchor.Outpoint,
+			AssetId:        rpcAsset.AssetGenesis.AssetId,
+			ScriptKey:      transferOutput.ScriptKey,
+		},
+		Amount: sendAssetAmount,
+	}
+	respIgnore, err := t.tapd.IgnoreAssetOutPoint(ctxb, ignoreReq)
+	require.NoError(t.t, err)
+	require.NotNil(t.t, respIgnore)
+	require.EqualValues(t.t, sendAssetAmount, respIgnore.Leaf.RootSum)
+
+	// Assert that the mempool is empty.
+	mempool := t.lndHarness.Miner().GetRawMempool()
+	require.Empty(t.t, mempool)
+
+	// At this point, the supply commitment should not yet exist, as we
+	// haven't created it after ignoring the asset outpoint.
+	//
+	// nolint: lll
+	fetchRespNil, err := t.tapd.FetchSupplyCommit(
+		ctxb, &unirpc.FetchSupplyCommitRequest{
+			GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
+				GroupKeyBytes: groupKeyBytes,
+			},
+			IgnoreLeafKeys: [][]byte{
+				respIgnore.LeafKey,
+			},
+		},
+	)
+	require.Nil(t.t, fetchRespNil)
+	require.ErrorContains(t.t, err, "supply commitment not found for "+
+		"asset group with key")
+
+	t.Log("Update on-chain supply commitment for asset group")
+
+	// nolint: lll
+	respUpdate, err := t.tapd.UpdateSupplyCommit(
+		ctxb, &unirpc.UpdateSupplyCommitRequest{
+			GroupKey: &unirpc.UpdateSupplyCommitRequest_GroupKeyBytes{
+				GroupKeyBytes: groupKeyBytes,
+			},
+		},
+	)
+	require.NoError(t.t, err)
+	require.NotNil(t.t, respUpdate)
+
+	t.Log("Mining supply commitment tx")
+	minedBlocks := MineBlocks(t.t, t.lndHarness.Miner().Client, 1, 1)
+
+	t.Log("Fetch updated supply commitment")
+	// Ensure that the supply commitment reflects the ignored asset
+	// outpoint owned by the secondary node.
+	var fetchResp *unirpc.FetchSupplyCommitResponse
+	require.Eventually(t.t, func() bool {
+		// nolint: lll
+		fetchResp, err = t.tapd.FetchSupplyCommit(
+			ctxb, &unirpc.FetchSupplyCommitRequest{
+				GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
+					GroupKeyBytes: groupKeyBytes,
+				},
+				IgnoreLeafKeys: [][]byte{
+					respIgnore.LeafKey,
+				},
+			},
+		)
+		require.NoError(t.t, err)
+
+		// If the fetch response has no block height or hash,
+		// it means that the supply commitment transaction has not
+		// been mined yet, so we should retry.
+		if fetchResp.BlockHeight == 0 || len(fetchResp.BlockHash) == 0 {
+			return false
+		}
+
+		// Once the ignore tree includes the ignored asset outpoint, we
+		// know that the supply commitment has been updated.
+		return fetchResp.IgnoreSubtreeRoot.RootNode.RootSum ==
+			int64(sendAssetAmount)
+	}, defaultWaitTimeout, time.Second)
+
+	// Verify that the supply commitment tree commits to the ignore subtree.
+	supplyCommitRootHash := fn.ToArray[[32]byte](
+		fetchResp.SupplyCommitmentRoot.RootHash,
+	)
+
+	// Formulate the ignore leaf node as it should appear in the supply
+	// tree.
+	supplyTreeIgnoreLeafNode := mssmt.NewLeafNode(
+		fetchResp.IgnoreSubtreeRoot.RootNode.RootHash,
+		uint64(fetchResp.IgnoreSubtreeRoot.RootNode.RootSum),
+	)
+
+	ignoreRootLeafKey := fn.ToArray[[32]byte](
+		fetchResp.IgnoreSubtreeRoot.SupplyTreeLeafKey,
+	)
+
+	AssertInclusionProof(
+		t, supplyCommitRootHash,
+		fetchResp.IgnoreSubtreeRoot.SupplyTreeInclusionProof,
+		ignoreRootLeafKey, supplyTreeIgnoreLeafNode,
+	)
+
+	// Unmarshal ignore tree leaf inclusion proof to verify that the
+	// ignored asset outpoint is included in the ignore tree.
+	require.Len(t.t, fetchResp.IgnoreLeafInclusionProofs, 1)
+	inclusionProofBytes := fetchResp.IgnoreLeafInclusionProofs[0]
+
+	// Verify that the ignore tree root can be computed from the ignore leaf
+	// inclusion proof.
+	expectedIgnoreSubtreeRootHash := fn.ToArray[[32]byte](
+		fetchResp.IgnoreSubtreeRoot.RootNode.RootHash,
+	)
+
+	ignoreLeafKey := fn.ToArray[[32]byte](respIgnore.LeafKey)
+	ignoreLeaf := unmarshalMerkleSumNode(respIgnore.Leaf)
+
+	AssertInclusionProof(
+		t, expectedIgnoreSubtreeRootHash, inclusionProofBytes,
+		ignoreLeafKey, ignoreLeaf,
+	)
+
+	// Verify that the mined supply commitment transaction commits to the
+	// supply commitment tree.
+	require.Len(t.t, minedBlocks, 1)
+
+	block := minedBlocks[0]
+	expectedBlockHash := block.BlockHash()
+
+	// Get block height for block.
+	blockHash, blockHeight := t.lndHarness.Miner().GetBestBlock()
+	require.True(t.t, blockHash.IsEqual(&expectedBlockHash))
+
+	// Ensure that the block hash and height matches the values in the fetch
+	// response.
+	fetchBlockHash, err := chainhash.NewHash(fetchResp.BlockHash)
+	require.NoError(t.t, err)
+	require.True(t.t, fetchBlockHash.IsEqual(blockHash))
+
+	require.EqualValues(t.t, blockHeight, fetchResp.BlockHeight)
+
+	// We expect two transactions in the block:
+	// 1. The supply commitment transaction.
+	// 2. The coinbase transaction.
+	require.Len(t.t, block.Transactions, 2)
+
+	internalKey, err := btcec.ParsePubKey(fetchResp.AnchorTxOutInternalKey)
+	require.NoError(t.t, err)
+
+	expectedTxOut, _, err := supplycommit.RootCommitTxOut(
+		internalKey, nil, supplyCommitRootHash,
+	)
+	require.NoError(t.t, err)
+
+	foundCommitTxOut := false
+	actualBlockTxIndex := 0
+	for idx := range block.Transactions {
+		tx := block.Transactions[idx]
+
+		for idxOut := range tx.TxOut {
+			txOut := tx.TxOut[idxOut]
+
+			pkScriptMatch := bytes.Equal(
+				txOut.PkScript, expectedTxOut.PkScript,
+			)
+			if txOut.Value == expectedTxOut.Value && pkScriptMatch {
+				// Ensure that the target tx out is only present
+				// once.
+				if foundCommitTxOut {
+					t.Fatalf("found multiple supply " +
+						"commitment tx outputs in " +
+						"block")
+				}
+
+				foundCommitTxOut = true
+				actualBlockTxIndex = idx
+			}
+		}
+	}
+
+	require.True(t.t, foundCommitTxOut)
+	require.EqualValues(t.t, actualBlockTxIndex, fetchResp.BlockTxIndex)
+
+	// If we try to ignore the same asset outpoint using the secondary
+	// node, it should fail because the secondary node does not have access
+	// to the supply commitment delegation key for signing.
+	_, err = secondTapd.IgnoreAssetOutPoint(ctxb, ignoreReq)
+	require.ErrorContains(t.t, err, "delegation key locator not found")
+}
+
+// AssertInclusionProof checks that the inclusion proof for a given leaf key
+// and leaf node matches the expected root hash.
+func AssertInclusionProof(t *harnessTest, expectedRootHash [32]byte,
+	inclusionProofBytes []byte, leafKey [32]byte, leafNode mssmt.Node) {
+
+	// Decode the inclusion proof bytes into a compressed proof.
+	var compressedProof mssmt.CompressedProof
+	err := compressedProof.Decode(bytes.NewReader(inclusionProofBytes))
+	require.NoError(t.t, err)
+
+	// Decompress the inclusion proof to get the full proof structure.
+	inclusionProof, err := compressedProof.Decompress()
+	require.NoError(t.t, err)
+
+	// Derive the root from the inclusion proof and the leaf node.
+	derivedRoot := inclusionProof.Root(leafKey, leafNode)
+	derivedRootHash := fn.ByteSlice(derivedRoot.NodeHash())
+
+	// Verify that the derived root hash matches the expected root hash.
+	if !bytes.Equal(expectedRootHash[:], derivedRootHash) {
+		t.t.Fatalf("expected root hash %x, got %x",
+			expectedRootHash[:], derivedRootHash)
+	}
+}
diff --git a/itest/test_list_on_test.go b/itest/test_list_on_test.go
index 812d6f52..fa85d285 100644
--- a/itest/test_list_on_test.go
+++ b/itest/test_list_on_test.go
@@ -347,6 +347,10 @@ var allTestCases = []*testCase{
 		name: "pre commit output",
 		test: testPreCommitOutput,
 	},
+	{
+		name: "supply commit ignore asset",
+		test: testSupplyCommitIgnoreAsset,
+	},
 	{
 		name: "auth mailbox message store and fetch",
 		test: testAuthMailboxStoreAndFetchMessage,
diff --git a/universe/ignore_records_test.go b/universe/ignore_records_test.go
index 04a5dd64..1886fbd5 100644
--- a/universe/ignore_records_test.go
+++ b/universe/ignore_records_test.go
@@ -2,10 +2,14 @@ package universe
 
 import (
 	"bytes"
+	"context"
+	"fmt"
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/internal/test"
+	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/stretchr/testify/require"
 	"pgregory.net/rapid"
 )
@@ -113,3 +117,84 @@ func TestSignedIgnoreTupleEncodeDecode(t *testing.T) {
 		require.Equal(t, origTuple, decodedTuple)
 	})
 }
+
+// TestGenSignedIgnore tests the GenSignedIgnore method of IgnoreTuple using a
+// table-driven style.
+func TestGenSignedIgnore(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name      string
+		tuple     IgnoreTuple
+		signature []byte
+		keyLoc    keychain.KeyLocator
+		expectErr bool
+	}{
+		{
+			name: "valid signature",
+			tuple: IgnoreTuple{
+				PrevID: asset.PrevID{
+					OutPoint:  test.RandOp(t),
+					ID:        asset.RandID(t),
+					ScriptKey: asset.RandSerializedKey(t),
+				},
+				Amount: 42,
+			},
+			signature: bytes.Repeat(
+				[]byte{0x01}, schnorr.SignatureSize,
+			),
+			keyLoc:    test.RandKeyLoc(),
+			expectErr: false,
+		},
+		{
+			name: "signer returns error",
+			tuple: IgnoreTuple{
+				PrevID: asset.PrevID{
+					OutPoint:  test.RandOp(t),
+					ID:        asset.RandID(t),
+					ScriptKey: asset.RandSerializedKey(t),
+				},
+				Amount: 99,
+			},
+			signature: nil,
+			keyLoc:    test.RandKeyLoc(),
+			expectErr: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			mockSigner := test.NewMockSigner()
+			mockSigner.Signature = tc.signature
+
+			if tc.expectErr {
+				mockSigner.SignMessageErr = fmt.Errorf(
+					"mock signer error",
+				)
+			}
+
+			signed, err := tc.tuple.GenSignedIgnore(
+				context.Background(), mockSigner, tc.keyLoc,
+			)
+
+			if tc.expectErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// Check that the signature matches what the mock signer
+			// produced.
+			require.Equal(
+				t, tc.signature,
+				signed.Sig.Val.Signature.Serialize(),
+			)
+
+			// Check that the tuple matches.
+			require.Equal(t, tc.tuple, signed.IgnoreTuple.Val)
+		})
+	}
+}