diff --git a/.gitignore b/.gitignore index 2c177133b..f5951e684 100644 --- a/.gitignore +++ b/.gitignore @@ -13,6 +13,7 @@ cmd/tapd/tapd /itest/lnd-itest /itest/btcd-itest +/itest/chantools /itest/regtest/* /itest/*.log /itest/.backendlogs/* diff --git a/Makefile b/Makefile index b33843957..607229ec4 100644 --- a/Makefile +++ b/Makefile @@ -92,6 +92,15 @@ build: $(GOBUILD) -tags="$(DEV_TAGS)" -o tapcli-debug $(DEV_GCFLAGS) $(DEV_LDFLAGS) $(PKG)/cmd/tapcli build-itest: + @if ! command -v chantools > /dev/null; then \ + $(call print, "Building itest chantools."); \ + rm -rf itest/chantools; \ + git clone --depth 1 --branch v0.13.5 https://github.com/lightninglabs/chantools.git itest/chantools; \ + cd itest/chantools && make install; \ + else \ + $(call print, "Chantools is already installed and available in PATH."); \ + fi + @$(call print, "Building itest btcd.") CGO_ENABLED=0 $(GOBUILD) -tags="integration" -o itest/btcd-itest $(BTCD_PKG) diff --git a/asset/asset.go b/asset/asset.go index ae89b71ef..bb72632a4 100644 --- a/asset/asset.go +++ b/asset/asset.go @@ -18,10 +18,12 @@ import ( "github.com/btcsuite/btcd/blockchain" "github.com/btcsuite/btcd/btcec/v2" "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcutil/hdkeychain" "github.com/btcsuite/btcd/btcutil/psbt" "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" + "github.com/btcsuite/btcwallet/waddrmgr" "github.com/decred/dcrd/dcrec/secp256k1/v4" "github.com/lightninglabs/lndclient" "github.com/lightninglabs/taproot-assets/fn" @@ -90,6 +92,30 @@ const ( V1 Version = 1 ) +// GroupKeyVersion denotes the version of the group key construction. +type GroupKeyVersion uint8 + +const ( + // GroupKeyV0 is the initial version of the group key where the group + // internal key is tweaked with the group anchor's asset ID. + GroupKeyV0 GroupKeyVersion = 0 + + // GroupKeyV1 is the version of the group key that uses a construction + // that is compatible with PSBT signing where the group anchor's asset + // ID is appended as a sibling to any user-provided tapscript tree. + GroupKeyV1 GroupKeyVersion = 1 +) + +// NewGroupKeyVersion creates a new GroupKeyVersion from an int32. This +// function is useful for decoding GroupKeyVersions from the SQL database. +func NewGroupKeyVersion(v int32) (GroupKeyVersion, error) { + if v > math.MaxUint8 { + return 0, fmt.Errorf("invalid group key version: %d", v) + } + + return GroupKeyVersion(v), nil +} + // EncodeType is used to denote the type of encoding used for an asset. type EncodeType uint8 @@ -847,10 +873,128 @@ type AssetGroup struct { *GroupKey } +// ExternalKey represents an external key used for deriving and managing +// hierarchical deterministic (HD) wallet addresses according to BIP-86. +type ExternalKey struct { + // XPub is the extended public key derived at depth 3 of the BIP-86 + // hierarchy (e.g., m/86'/0'/0'). This key serves as the parent key for + // deriving child public keys and addresses. + XPub hdkeychain.ExtendedKey + + // MasterFingerprint is the fingerprint of the master key, derived from + // the first 4 bytes of the hash160 of the master public key. It is used + // to identify the master key in BIP-86 derivation schemes. + MasterFingerprint uint32 + + // DerivationPath specifies the extended BIP-86 derivation path used to + // derive a child key from the XPub. Starting from the base path of the + // XPub (e.g., m/86'/0'/0'), this path must contain exactly 5 components + // in total (e.g., m/86'/0'/0'/0/0), with the additional components + // defining specific child keys, such as individual addresses. + DerivationPath []uint32 +} + +// Validate ensures that the ExternalKey's fields conform to the expected +// requirements for a BIP-86 key structure. +func (e *ExternalKey) Validate() error { + if e.XPub.IsPrivate() { + return fmt.Errorf("xpub must be public key only") + } + + if e.XPub.Depth() != 3 { + return fmt.Errorf("xpub must be derived at depth 3") + } + + if len(e.DerivationPath) != 5 { + return fmt.Errorf("derivation path must have exactly 5 " + + "components") + } + + bip86Purpose := waddrmgr.KeyScopeBIP0086.Purpose + + hdkeychain.HardenedKeyStart + if e.DerivationPath[0] != bip86Purpose { + return fmt.Errorf("xpub must be derived from BIP-0086 " + + "(Taproot) derivation path") + } + + return nil +} + +// PubKey derives and returns the public key corresponding to the final index in +// the ExternalKey's BIP-86 derivation path. +// +// The method assumes the ExternalKey's XPub was derived at depth 3 +// (e.g., m/86'/0'/0') and uses the fourth and fifth components of the +// DerivationPath to derive a child key, typically representing an address or +// output key. +func (e *ExternalKey) PubKey() (btcec.PublicKey, error) { + err := e.Validate() + if err != nil { + return btcec.PublicKey{}, err + } + + internalExternalFlag := e.DerivationPath[3] + index := e.DerivationPath[4] + + changeKey, err := e.XPub.Derive(internalExternalFlag) + if err != nil { + return btcec.PublicKey{}, err + } + + indexKey, err := changeKey.Derive(index) + if err != nil { + return btcec.PublicKey{}, err + } + + pubKey, err := indexKey.ECPubKey() + if err != nil { + return btcec.PublicKey{}, err + } + + return *pubKey, nil +} + +// NewGroupKeyV1FromExternal creates a new V1 group key from an external key and +// asset ID. The customRootHash is optional and can be used to specify a custom +// tapscript root. +func NewGroupKeyV1FromExternal(externalKey ExternalKey, assetID ID, + customRoot fn.Option[chainhash.Hash]) (btcec.PublicKey, chainhash.Hash, + error) { + + var ( + zeroHash chainhash.Hash + zeroPubKey btcec.PublicKey + ) + + internalKey, err := externalKey.PubKey() + if err != nil { + return zeroPubKey, zeroHash, fmt.Errorf("cannot derive group "+ + "internal key from provided external key "+ + "(e.g. xpub): %w", err) + } + + root, err := NewGroupKeyTapscriptRoot(assetID, customRoot) + if err != nil { + return zeroPubKey, zeroHash, fmt.Errorf("cannot derive group "+ + "key reveal tapscript root: %w", err) + } + + groupPubKey, err := GroupPubKeyV1(&internalKey, root, assetID) + if err != nil { + return zeroPubKey, zeroHash, fmt.Errorf("cannot derive group "+ + "public key: %w", err) + } + + return *groupPubKey, root.root, nil +} + // GroupKey is the tweaked public key that is used to associate assets together // across distinct asset IDs, allowing further issuance of the asset to be made // possible. type GroupKey struct { + // Version is the version of the group key construction. + Version GroupKeyVersion + // RawKey is the raw group key before the tweak with the genesis point // has been applied. RawKey keychain.KeyDescriptor @@ -863,13 +1007,23 @@ type GroupKey struct { // tweakedGroupKey = TapTweak(internalKey, tapTweak) GroupPubKey btcec.PublicKey - // TapscriptRoot is the root of the Tapscript tree that commits to all - // script spend conditions for the group key. Instead of spending an - // asset, these scripts are used to define witnesses more complex than - // a Schnorr signature for reissuing assets. A group key with an empty - // Tapscript root can only authorize reissuance with a signature. + // TapscriptRoot represents the root of the Tapscript tree that commits + // to all script spend conditions associated with the group key. Instead + // of simply authorizing asset spending, these scripts enable more + // complex witness mechanisms beyond a Schnorr signature, allowing for + // reissuance of assets. A group key with an empty Tapscript root can + // only authorize reissuance using a signature. + // + // In the V1 group key construction, this root is never empty. It always + // includes two layers of script leaves that commit to the group + // anchor's (genesis) asset ID, ensuring any user-provided Tapscript + // root is positioned at level 2. TapscriptRoot []byte + // CustomTapscriptRoot is an optional tapscript root to graft at the + // second level of the tapscript tree, if specified. + CustomTapscriptRoot fn.Option[chainhash.Hash] + // Witness is a stack of witness elements that authorizes the membership // of an asset in a particular asset group. The witness can be a single // signature or a script from the tapscript tree committed to with the @@ -879,10 +1033,19 @@ type GroupKey struct { // GroupKeyRequest contains the essential fields used to derive a group key. type GroupKeyRequest struct { + // Version is the version of the group key construction. + Version GroupKeyVersion + // RawKey is the raw group key before the tweak with the genesis point // has been applied. RawKey keychain.KeyDescriptor + // ExternalKey specifies a public key that, when provided, is used to + // externally sign the group virtual transaction outside of tapd. + // + // If this field is set, RawKey is not used. + ExternalKey fn.Option[ExternalKey] + // AnchorGen is the genesis of the group anchor, which is the asset used // to derive the single tweak for the group key. For a new group key, // this will be the genesis of the new asset. @@ -890,9 +1053,15 @@ type GroupKeyRequest struct { // TapscriptRoot is the root of a Tapscript tree that includes script // spend conditions for the group key. A group key with an empty - // Tapscript root can only authorize reissuance with a signature. + // Tapscript root can only authorize re-issuance with a signature. This + // is the root of any user-defined scripts. For a V1 group key + // construction the final tapscript root will never be empty. TapscriptRoot []byte + // CustomTapscriptRoot is an optional tapscript root to graft at the + // second level of the tapscript tree, if specified. + CustomTapscriptRoot fn.Option[chainhash.Hash] + // NewAsset is the asset which we are requesting group membership for. // A successful request will produce a witness that authorizes this // asset to be a member of this asset group. @@ -1040,7 +1209,7 @@ func NewGKRCustomSubtreeRootRecord(root *chainhash.Hash) tlv.Record { // hash may represent either a single leaf or the root hash of an entire // subtree. // -// If `custom_root_hash` is not provided, it defaults to a bare `[OP_RETURN` as +// If `custom_root_hash` is not provided, it defaults to a bare `[OP_RETURN]` as // well. In this case, no valid script spending path can correspond to the // custom subtree root hash due to the pre-image resistance of SHA-256. // @@ -1182,6 +1351,11 @@ func (g *GroupKeyRevealTapscript) Validate(assetID ID) error { return nil } +// Root returns the final tapscript root hash of the group key reveal tapscript. +func (g *GroupKeyRevealTapscript) Root() chainhash.Hash { + return g.root +} + // GroupKeyRevealV1 is a version 1 group key reveal type for representing the // data used to derive and verify the tweaked key used to identify an asset // group. @@ -1202,6 +1376,34 @@ type GroupKeyRevealV1 struct { // Ensure that GroupKeyRevealV1 implements the GroupKeyReveal interface. var _ GroupKeyReveal = (*GroupKeyRevealV1)(nil) +// NewGroupKeyReveal creates a new group key reveal instance from the given +// group key and genesis asset ID. +func NewGroupKeyReveal(groupKey GroupKey, genesisAssetID ID) (GroupKeyReveal, + error) { + + switch groupKey.Version { + case GroupKeyV1: + gkr, err := NewGroupKeyRevealV1( + *groupKey.RawKey.PubKey, genesisAssetID, + groupKey.CustomTapscriptRoot, + ) + if err != nil { + return nil, err + } + + return &gkr, nil + + case GroupKeyV0: + rawKey := ToSerialized(groupKey.RawKey.PubKey) + gkr := NewGroupKeyRevealV0(rawKey, groupKey.TapscriptRoot) + return gkr, nil + + default: + return nil, fmt.Errorf("unsupported group key version: %d", + groupKey.Version) + } +} + // NewGroupKeyRevealV1 creates a new version 1 group key reveal instance. func NewGroupKeyRevealV1(internalKey btcec.PublicKey, genesisAssetID ID, @@ -1852,14 +2054,27 @@ func NewScriptKeyBip86(rawKey keychain.KeyDescriptor) ScriptKey { } // NewGroupKeyRequest constructs and validates a group key request. -func NewGroupKeyRequest(internalKey keychain.KeyDescriptor, anchorGen Genesis, - newAsset *Asset, scriptRoot []byte) (*GroupKeyRequest, error) { +func NewGroupKeyRequest(internalKey keychain.KeyDescriptor, + externalKey fn.Option[ExternalKey], anchorGen Genesis, + newAsset *Asset, tapscriptRoot []byte, + customTapscriptRoot fn.Option[chainhash.Hash]) (*GroupKeyRequest, + error) { + + // Specify the group key version based on the presence of an external + // key. + var version GroupKeyVersion + if externalKey.IsSome() { + version = GroupKeyV1 + } req := &GroupKeyRequest{ - RawKey: internalKey, - AnchorGen: anchorGen, - NewAsset: newAsset, - TapscriptRoot: scriptRoot, + Version: version, + RawKey: internalKey, + ExternalKey: externalKey, + AnchorGen: anchorGen, + NewAsset: newAsset, + TapscriptRoot: tapscriptRoot, + CustomTapscriptRoot: customTapscriptRoot, } err := req.Validate() @@ -1904,14 +2119,75 @@ func (req *GroupKeyRequest) Validate() error { sha256.Size) } + // Version 1 specific checks. + if req.Version == GroupKeyV1 { + tapscriptRoot, err := chainhash.NewHash(req.TapscriptRoot) + if err != nil { + return fmt.Errorf("version 1 group key request " + + "tapscript root must be a valid hash") + } + + if tapscriptRoot.IsEqual(&chainhash.Hash{}) { + return fmt.Errorf("version 1 group key request " + + "tapscript root must not be all zeros") + } + } + + if req.ExternalKey.IsSome() && req.Version != GroupKeyV1 { + return fmt.Errorf("external key can only be specified for " + + "version 1 group key request") + } + return nil } +// NewGroupPubKey derives a group key for the asset group based on the group key +// request and the genesis asset ID. +func (req *GroupKeyRequest) NewGroupPubKey(genesisAssetID ID) (btcec.PublicKey, + error) { + + // If the external key is not specified, we will construct a version 0 + // group key. + if req.ExternalKey.IsNone() { + // Compute the tweaked group key and set it in the asset before + // creating the virtual minting transaction. + groupPubKey, err := GroupPubKeyV0( + req.RawKey.PubKey, genesisAssetID[:], req.TapscriptRoot, + ) + if err != nil { + return btcec.PublicKey{}, fmt.Errorf("cannot tweak "+ + "group key: %w", err) + } + + return *groupPubKey, nil + } + + // At this point, the external key should be specified. We will now + // construct a new version 1 group key. + externalKey, err := req.ExternalKey.UnwrapOrErr( + fmt.Errorf("unexpected nil external key"), + ) + if err != nil { + return btcec.PublicKey{}, err + } + + groupPubKey, _, err := NewGroupKeyV1FromExternal( + externalKey, genesisAssetID, req.CustomTapscriptRoot, + ) + if err != nil { + return btcec.PublicKey{}, fmt.Errorf("cannot derive group "+ + "key: %w", err) + } + + return groupPubKey, nil +} + // BuildGroupVirtualTx derives the tweaked group key for group key request, // and constructs the group virtual TX needed to construct a sign descriptor and // produce an asset group witness. func (req *GroupKeyRequest) BuildGroupVirtualTx(genBuilder GenesisTxBuilder) ( *GroupVirtualTx, error) { + // First, perform the final checks on the asset being authorized for // group membership. err := req.Validate() @@ -1919,23 +2195,20 @@ func (req *GroupKeyRequest) BuildGroupVirtualTx(genBuilder GenesisTxBuilder) ( return nil, err } - // Compute the tweaked group key and set it in the asset before - // creating the virtual minting transaction. - genesisTweak := req.AnchorGen.ID() - tweakedGroupKey, err := GroupPubKeyV0( - req.RawKey.PubKey, genesisTweak[:], req.TapscriptRoot, - ) + // Construct an asset group pub key. + genesisAssetID := req.AnchorGen.ID() + groupPubKey, err := req.NewGroupPubKey(genesisAssetID) if err != nil { - return nil, fmt.Errorf("cannot tweak group key: %w", err) + return nil, fmt.Errorf("cannot derive group key: %w", err) } + // Build the virtual transaction that represents the minting of the new + // asset, which will be signed to generate the group witness. assetWithGroup := req.NewAsset.Copy() assetWithGroup.GroupKey = &GroupKey{ - GroupPubKey: *tweakedGroupKey, + GroupPubKey: groupPubKey, } - // Build the virtual transaction that represents the minting of the new - // asset, which will be signed to generate the group witness. genesisTx, prevOut, err := genBuilder.BuildGenesisTx(assetWithGroup) if err != nil { return nil, fmt.Errorf("cannot build virtual tx: %w", err) @@ -1944,8 +2217,8 @@ func (req *GroupKeyRequest) BuildGroupVirtualTx(genBuilder GenesisTxBuilder) ( return &GroupVirtualTx{ Tx: *genesisTx, PrevOut: *prevOut, - GenID: genesisTweak, - TweakedKey: *tweakedGroupKey, + GenID: genesisAssetID, + TweakedKey: groupPubKey, }, nil } @@ -1985,6 +2258,12 @@ func DeriveGroupKey(genSigner GenesisSigner, genTx GroupVirtualTx, req GroupKeyRequest, tapLeaf *psbt.TaprootTapLeafScript) (*GroupKey, error) { + // Cannot derive the group key witness for an external key. + if req.ExternalKey.IsSome() { + return nil, fmt.Errorf("cannot derive group key witness for " + + "group key with external key") + } + // Populate the signing descriptor needed to sign the virtual minting // transaction. signDesc := &lndclient.SignDescriptor{ @@ -2035,6 +2314,7 @@ func DeriveGroupKey(genSigner GenesisSigner, genTx GroupVirtualTx, } return &GroupKey{ + Version: GroupKeyV0, RawKey: signDesc.KeyDesc, GroupPubKey: genTx.TweakedKey, TapscriptRoot: signDesc.TapTweak, diff --git a/asset/asset_test.go b/asset/asset_test.go index 39b92f8cd..5944576d5 100644 --- a/asset/asset_test.go +++ b/asset/asset_test.go @@ -10,6 +10,7 @@ import ( "github.com/btcsuite/btcd/blockchain" "github.com/btcsuite/btcd/btcec/v2" "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/taproot-assets/fn" @@ -887,7 +888,10 @@ func TestAssetGroupKey(t *testing.T) { // TweakTaprootPrivKey modifies the private key that is passed in! We // need to provide a copy to arrive at the same result. protoAsset := NewAssetNoErr(t, g, 1, 0, 0, fakeScriptKey, nil) - groupReq := NewGroupKeyRequestNoErr(t, fakeKeyDesc, g, protoAsset, nil) + groupReq := NewGroupKeyRequestNoErr( + t, fakeKeyDesc, fn.None[ExternalKey](), g, protoAsset, nil, + fn.None[chainhash.Hash](), + ) genTx, err := groupReq.BuildGroupVirtualTx(&genBuilder) require.NoError(t, err) @@ -905,7 +909,8 @@ func TestAssetGroupKey(t *testing.T) { tweakedKey = txscript.TweakTaprootPrivKey(*internalKey, tapTweak) groupReq = NewGroupKeyRequestNoErr( - t, test.PubToKeyDesc(privKey.PubKey()), g, protoAsset, tapTweak, + t, test.PubToKeyDesc(privKey.PubKey()), fn.None[ExternalKey](), + g, protoAsset, tapTweak, fn.None[chainhash.Hash](), ) genTx, err = groupReq.BuildGroupVirtualTx(&genBuilder) require.NoError(t, err) diff --git a/asset/mock.go b/asset/mock.go index 5abd61c8e..90e2309f6 100644 --- a/asset/mock.go +++ b/asset/mock.go @@ -11,9 +11,11 @@ import ( "github.com/btcsuite/btcd/btcec/v2" "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/lndclient" + "github.com/lightninglabs/taproot-assets/fn" "github.com/lightninglabs/taproot-assets/internal/test" "github.com/lightninglabs/taproot-assets/mssmt" "github.com/lightningnetwork/lnd/input" @@ -615,9 +617,14 @@ func NewAssetNoErr(t testing.TB, gen Genesis, amt, locktime, relocktime uint64, } func NewGroupKeyRequestNoErr(t testing.TB, internalKey keychain.KeyDescriptor, - gen Genesis, newAsset *Asset, scriptRoot []byte) *GroupKeyRequest { + externalKey fn.Option[ExternalKey], gen Genesis, newAsset *Asset, + scriptRoot []byte, + customTapscriptRoot fn.Option[chainhash.Hash]) *GroupKeyRequest { - req, err := NewGroupKeyRequest(internalKey, gen, newAsset, scriptRoot) + req, err := NewGroupKeyRequest( + internalKey, externalKey, gen, newAsset, scriptRoot, + customTapscriptRoot, + ) require.NoError(t, err) return req diff --git a/cmd/tapcli/assets.go b/cmd/tapcli/assets.go index a477457dc..62954ce3e 100644 --- a/cmd/tapcli/assets.go +++ b/cmd/tapcli/assets.go @@ -6,6 +6,7 @@ import ( "math" "os" "strconv" + "strings" taprootassets "github.com/lightninglabs/taproot-assets" "github.com/lightninglabs/taproot-assets/tapcfg" @@ -138,6 +139,21 @@ var mintAssetCommand = cli.Command{ "in order to avoid printing a large amount " + "of data in case of large batches", }, + cli.StringFlag{ + Name: "group_key_xpub", + Usage: "the xpub of the group key to use to mint the " + + "asset", + }, + cli.StringFlag{ + Name: "group_key_derivation_path", + Usage: "the derivation path that was used to derive " + + "the group key xpub", + }, + cli.StringFlag{ + Name: "group_key_fingerprint", + Usage: "the master fingerprint of the key the xpub " + + "was derived from", + }, }, Action: mintAsset, Subcommands: []cli.Command{ @@ -326,6 +342,32 @@ func mintAsset(ctx *cli.Context) error { client, cleanUp := getMintClient(ctx) defer cleanUp() + gkXPub := ctx.String("group_key_xpub") + gkPath := ctx.String("group_key_derivation_path") + gkFingerprint := ctx.String("group_key_fingerprint") + + var externalKey *taprpc.ExternalKey + switch { + case (gkXPub != "" || gkPath != "" || gkFingerprint != "") && + (gkXPub == "" || gkPath == "" || gkFingerprint == ""): + + return fmt.Errorf("group key xpub, derivation path, and " + + "fingerprint must all be set or all be empty") + + case gkXPub != "" && gkPath != "" && gkFingerprint != "": + fingerPrintBytes, err := hex.DecodeString(gkFingerprint) + if err != nil { + return fmt.Errorf("cannot hex decode group key "+ + "fingerprint: %w", err) + } + + externalKey = &taprpc.ExternalKey{ + Xpub: gkXPub, + MasterFingerprint: fingerPrintBytes, + DerivationPath: gkPath, + } + } + resp, err := client.MintAsset(ctxc, &mintrpc.MintAssetRequest{ Asset: &mintrpc.MintAsset{ AssetType: assetType, @@ -340,6 +382,7 @@ func mintAsset(ctx *cli.Context) error { AssetVersion: taprpc.AssetVersion( ctx.Uint64(assetVersionName), ), + ExternalGroupKey: externalKey, }, ShortResponse: ctx.Bool(shortResponseName), }) @@ -415,6 +458,11 @@ var sealBatchCommand = cli.Command{ "in order to avoid printing a large amount " + "of data in case of large batches", }, + cli.StringSliceFlag{ + Name: "group_signatures", + Usage: "the asset ID and signature, separated by a " + + "colon", + }, }, Hidden: true, Action: sealBatch, @@ -425,9 +473,37 @@ func sealBatch(ctx *cli.Context) error { client, cleanUp := getMintClient(ctx) defer cleanUp() - resp, err := client.SealBatch(ctxc, &mintrpc.SealBatchRequest{ + req := &mintrpc.SealBatchRequest{ ShortResponse: ctx.Bool(shortResponseName), - }) + } + + // TODO(guggero): Actually just ask for the signed PSBT back and extract + // the signature from there. We can query the pending batch to get the + // asset ID of each PSBT (can match by the unsigned transaction's input + // prev out). + sigs := ctx.StringSlice("group_signatures") + for _, witness := range sigs { + parts := strings.Split(witness, ":") + assetIDHex, sigHex := parts[0], parts[1] + assetIDBytes, err := hex.DecodeString(assetIDHex) + if err != nil { + return fmt.Errorf("invalid asset ID") + } + + sigBytes, err := hex.DecodeString(sigHex) + if err != nil { + return fmt.Errorf("invalid signature") + } + + req.GroupWitnesses = append( + req.GroupWitnesses, &taprpc.GroupWitness{ + GenesisId: assetIDBytes, + Witness: [][]byte{sigBytes}, + }, + ) + } + + resp, err := client.SealBatch(ctxc, req) if err != nil { return fmt.Errorf("unable to seal batch: %w", err) } @@ -511,6 +587,9 @@ var listBatchesCommand = cli.Command{ Name: batchKeyName, Usage: "if set, the batch key for a specific batch", }, + cli.BoolFlag{ + Name: "verbose", + }, }, Action: listBatches, } @@ -536,6 +615,7 @@ func listBatches(ctx *cli.Context) error { Filter: &mintrpc.ListBatchRequest_BatchKey{ BatchKey: batchKey, }, + Verbose: ctx.Bool("verbose"), }) if err != nil { return fmt.Errorf("unable to list batches: %w", err) diff --git a/commitment/commitment_test.go b/commitment/commitment_test.go index 46031fb9e..25fe3163b 100644 --- a/commitment/commitment_test.go +++ b/commitment/commitment_test.go @@ -149,8 +149,8 @@ func TestNewAssetCommitment(t *testing.T) { genTxBuilder := asset.MockGroupTxBuilder{} group1Priv, group1Pub := btcec.PrivKeyFromBytes(group1PrivBytes) group1ReissuedGroupReq := asset.NewGroupKeyRequestNoErr( - t, test.PubToKeyDesc(group1Pub), genesis1, genesis2ProtoAsset, - nil, + t, test.PubToKeyDesc(group1Pub), fn.None[asset.ExternalKey](), + genesis1, genesis2ProtoAsset, nil, fn.None[chainhash.Hash](), ) group1ReissuedGenTx, err := group1ReissuedGroupReq.BuildGroupVirtualTx( &genTxBuilder, @@ -1021,7 +1021,8 @@ func TestUpdateAssetCommitment(t *testing.T) { genTxBuilder := asset.MockGroupTxBuilder{} group1Priv, group1Pub := btcec.PrivKeyFromBytes(group1PrivBytes) group1ReissuedGroupReq := asset.NewGroupKeyRequestNoErr( - t, test.PubToKeyDesc(group1Pub), genesis1, group1Reissued, nil, + t, test.PubToKeyDesc(group1Pub), fn.None[asset.ExternalKey](), + genesis1, group1Reissued, nil, fn.None[chainhash.Hash](), ) group1ReissuedGenTx, err := group1ReissuedGroupReq.BuildGroupVirtualTx( &genTxBuilder, diff --git a/docs/external-group-key.md b/docs/external-group-key.md new file mode 100644 index 000000000..b39cbf708 --- /dev/null +++ b/docs/external-group-key.md @@ -0,0 +1,439 @@ +# How to use an external group key + +This document describes how we can mint an asset with a group key that is +external to the `lnd` node/wallet that `tapd` is connected to. + +This theoretically means the key used to prove ownership of an asset group could +be fully cold (stored in a hardware wallet only). But because at this time none +of the popular hardware wallets support signing for a Taproot output with +non-standard leaves in the Tapscript tree, we are going to use +[`chantools`](https://github.com/lightninglabs/chantools) to create the +signature. +**Make sure to use the latest version (`v0.13.5`)!** + +`chantools` can be used completely offline on any computer, for example running +off of a USB drive with the Tails operating system, to make sure no data is +stored permanently on the device. + +## Step 1 (optional): Create persistent wallet + +This step is purely for ease of use (during testing for example) and is fully +optional, especially if the goal is to never store the seed on a device. +If you want to use `chantools` without a persistent wallet, just don't specify +the `--walletdbdir` flag for any of the later commands, which will cause the +tool to ask for the full seed (and passphrase if available) instead. Make sure +to use the `--bip39` flag instead though, otherwise `chantools` by default +expects the seed to be in the `lnd`/`aezeed` format. + +```shell +$ chantools --regtest createwallet --bip39 --walletdbdir /tmp + +2024-12-27 12:37:01.863 [INF] CHAN: chantools version v0.13.5 commit +Input your 12 to 24 word mnemonic separated by spaces: dismiss sugar enhance impose unique treat message party list throw blame field + +Input your cipher seed passphrase (press enter if your seed doesn't have a passphrase): +Please choose passphrase mode: + 0 - Default BIP39 + 1 - Passphrase to hex + 2 - Digital Bitbox (extra round of PBKDF2) + +Choice [default 0]: 0 + + + +The wallet password is used to encrypt the wallet.db file itself and is unrelated to the seed. +Input new wallet password: +Confirm new wallet password: +Wallet created successfully at /tmp +``` + +We're going to use the following example seed in all examples: +`dismiss sugar enhance impose unique treat message party list throw blame field` + +## Step 2: Derive the `xpub` and master root key + +We'll need this information during the asset mint process later. Make sure to +replace the path `m/86'/1'/0'` with `m/86'/0'/0'` on **mainnet**! + +```shell +$ chantools --regtest derivekey --walletdb /tmp/wallet.db --path "m/86'/1'/0'" --neuter + +2024-12-27 12:50:52.788 [INF] CHAN: chantools version v0.13.5 commit +Input wallet password: + +Path: m/86'/1'/0' +Network: regtest +Master Fingerprint: 10608bb9 +Public key: 039186e157f8b7a8a56fb5f4c0b679d8a883aa8f84f01420e6606b2b1be2ffdadb +Extended public key (xpub): tpubDD2EgfmrtDs51w46DHDa87yiwiidEYC3ECXXyFp72ESAt5SV661R19kGAMiQMPm8No438YmW5yeYLKUJYuDByAkJvfxA13n2u79ZeDvryHb +Address: bcrt1quqynp6q9lusp48f0lx0sdt8ygaacfmdcqwccd4 +Legacy address: n1wYfdRFwi5123ELa37eeMX5KkxMSQWTos +Taproot address: bcrt1pymsfzl8rxxx6uq2a88pgtlatfn4ztwlaaxc9eh3hcnmf5d4ku85sq8ksaj +Private key (WIF): n/a +Extended private key (xprv): n/a +``` + +Alternative when not using a persistent wallet: +```shell +$ chantools --regtest derivekey --bip39 --path "m/86'/1'/0'" --neuter +``` + +## Step 3: Mint an asset + +With the `xpub`, derivation path and master fingerprint obtained, we can now +start the mint process. **NOTE** that we're adding `/0/0` to the derivation +path, as the key that should be used for the actual group internal key should +be the key at index `0` of the external (`0`) branch. +When creating more, distinct asset groups from the same key, the last number can +be incremented to derive/use a different key. + +```shell +$ tapcli assets mint --type normal --name usdt --supply 500000000 --new_grouped_asset \ + --group_key_xpub tpubDD2EgfmrtDs51w46DHDa87yiwiidEYC3ECXXyFp72ESAt5SV661R19kGAMiQMPm8No438YmW5yeYLKUJYuDByAkJvfxA13n2u79ZeDvryHb \ + --group_key_derivation_path "m/86'/1'/0'/0/0" --group_key_fingerprint 10608bb9 + +{ + "pending_batch": { + "batch_key": "031cad33f9c2d11ba1955c86d30e99414010a3d8db3cf005cdfd7b5947884d152b", + "batch_txid": "", + "state": "BATCH_STATE_PENDING", + "assets": [ + { + "asset_version": "ASSET_VERSION_V0", + "asset_type": "NORMAL", + "name": "usdt", + "asset_meta": null, + "amount": "500000000", + "new_grouped_asset": true, + "group_key": "", + "group_anchor": "", + "group_internal_key": { + "raw_key_bytes": "03a6553ff1aa8bb1dc91b35e1f8428f99e6dfc3a66e39945ad9c0c22fffec677ff", + "key_loc": { + "key_family": 0, + "key_index": 0 + } + }, + "group_tapscript_root": "", + "script_key": { + "pub_key": "ff3608f3e5e608317011201b104bf87352655f4ea47c14edad0cabe6d69ff5b4", + "key_desc": { + "raw_key_bytes": "03a0fc40fd7d5ecbc34cfd479aa44320af064a9df7a3c9d1940ebe2fc9bcd8f1a9", + "key_loc": { + "key_family": 212, + "key_index": 15 + } + }, + "tap_tweak": "" + } + } + ], + "created_at": "1735303474", + "height_hint": 157, + "batch_psbt": "" + } +} +``` + +This creates a pending batch with a single asset. More assets can be added now, +if desired. + +## Step 4: Fund the batch + +Funding the batch means reserving a BTC on-chain output that will be used to +fund the minting transaction. The very first input used will also serve as the +unique randomness to the asset ID of each asset in the batch. So this step is +necessary to obtain the asset IDs in the first place. + +```shell +$ tapcli assets mint fund --sat_per_vbyte 20 + +{ + "batch": { + "batch": { + "batch_key": "031cad33f9c2d11ba1955c86d30e99414010a3d8db3cf005cdfd7b5947884d152b", + "batch_txid": "", + "state": "BATCH_STATE_PENDING", + "assets": [], + "created_at": "1735303474", + "height_hint": 157, + "batch_psbt": "70736274ff010089020000000193267bc4203fbcd503f52ebf10e57cb1bea854617ac27b07df36d6feae38407100000000000000000002e803000000000000225120000000000000000000000000000000000000000000000000000000000000000039d0f50500000000225120b57e85d54f10ff813207ebb49e0c1a174813946516ca0e1c0b06191ba6b2667400000000000100de02000000000101049ea356718188c25b111a07f293158e6fbff2c0780643aa8731d392ac3b5b180100000000fdffffff0200e1f50500000000160014dd2f53994b70a2c43b72bb7f66b63d8b8e629a5cd05b93d600000000160014c10699dfa395cc2d48d7ed5fc697c5efddd18fe60247304402202d46b3fc55d7ca7140ac38a3847c1c1df9984f8c2abbdbcdb8779208810199b00220134869b61fee2a09fcbd4a5bc6b2ce813f1f785b692d8971ee30f6dd2a172ce20121028a0bda7fde65fc310d5a2540aee5f20c2693faab85331c3161063b842611e2d98c00000001011f00e1f50500000000160014dd2f53994b70a2c43b72bb7f66b63d8b8e629a5c010304010000002206020b76f7e4cb9de0a39697e085815ec8c32ad3124f693bf6cfe2ae44477f4c23ed180000000054000080000000800000008000000000010000000000220203b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f21718000000005600008000000080000000800100000007000000010520b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f2172107b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f217190000000000560000800000008000000080010000000700000000" + }, + "unsealed_assets": [ + { + "asset": { + "asset_version": "ASSET_VERSION_V0", + "asset_type": "NORMAL", + "name": "usdt", + "asset_meta": null, + "amount": "500000000", + "new_grouped_asset": true, + "group_key": "", + "group_anchor": "", + "group_internal_key": { + "raw_key_bytes": "03a6553ff1aa8bb1dc91b35e1f8428f99e6dfc3a66e39945ad9c0c22fffec677ff", + "key_loc": { + "key_family": 0, + "key_index": 0 + } + }, + "group_tapscript_root": "", + "script_key": { + "pub_key": "ff3608f3e5e608317011201b104bf87352655f4ea47c14edad0cabe6d69ff5b4", + "key_desc": { + "raw_key_bytes": "03a0fc40fd7d5ecbc34cfd479aa44320af064a9df7a3c9d1940ebe2fc9bcd8f1a9", + "key_loc": { + "key_family": 212, + "key_index": 15 + } + }, + "tap_tweak": "" + } + }, + "group_key_request": { + "raw_key": { + "raw_key_bytes": "03a6553ff1aa8bb1dc91b35e1f8428f99e6dfc3a66e39945ad9c0c22fffec677ff", + "key_loc": { + "key_family": 0, + "key_index": 0 + } + }, + "anchor_genesis": { + "genesis_point": "714038aefed636df077bc27a6154a8beb17ce510bf2ef503d5bc3f20c47b2693:0", + "name": "usdt", + "meta_hash": "0000000000000000000000000000000000000000000000000000000000000000", + "asset_id": "c4b0771c1bd1334bf20df5204c162702a6dc765a9cb15b1bc9e3c91e0282061b", + "asset_type": "NORMAL", + "output_index": 0 + }, + "tapscript_root": "93ece4efce6d317e9ecb74d1bfc26c2eadb43080ff38aa21069dc81379defd8d", + "new_asset": "000100024e93267bc4203fbcd503f52ebf10e57cb1bea854617ac27b07df36d6feae384071000000000475736474000000000000000000000000000000000000000000000000000000000000000000000000000401000605fe1dcd65000b690167016500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e020000102102ff3608f3e5e608317011201b104bf87352655f4ea47c14edad0cabe6d69ff5b4", + "external_key": { + "xpub": "tpubDD2EgfmrtDs51w46DHDa87yiwiidEYC3ECXXyFp72ESAt5SV661R19kGAMiQMPm8No438YmW5yeYLKUJYuDByAkJvfxA13n2u79ZeDvryHb", + "master_fingerprint": "10608bb9", + "derivation_path": "m/86'/1'/0'/0/0" + } + }, + "group_virtual_tx": { + "transaction": "02000000013299ae8f8a4a3aa0e1842f1346ea0426d6ba28b77a428076e7ce1a8e7b2fc970000000000000000000010065cd1d00000000225120c684a933ce8fcaefdb0912a139cebfd932d70c65e75275e7ebd150a83f20c3b700000000", + "prev_out": { + "value": "500000000", + "pk_script": "5120a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704" + }, + "genesis_id": "c4b0771c1bd1334bf20df5204c162702a6dc765a9cb15b1bc9e3c91e0282061b", + "tweaked_key": "02a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704" + }, + "group_virtual_psbt": "cHNidP8BAF4CAAAAATKZro+KSjqg4YQvE0bqBCbWuii3ekKAdufOGo57L8lwAAAAAAAAAAAAAQBlzR0AAAAAIlEgxoSpM86Pyu/bCRKhOc6/2TLXDGXnUnXn69FQqD8gw7cAAAAAAAEBKwBlzR0AAAAAIlEgqUflbsA2uA/P2qYe6qclsUox7koFCR3h1xkwh4+M1wQiBgOmVT/xqoux3JGzXh+EKPmebfw6ZuOZRa2cDCL//sZ3/xgQYIu5VgAAgAEAAIAAAACAAAAAAAAAAAAhFqZVP/Gqi7HckbNeH4Qo+Z5t/Dpm45lFrZwMIv/+xnf/GQAQYIu5VgAAgAEAAIAAAACAAAAAAAAAAAABFyCmVT/xqoux3JGzXh+EKPmebfw6ZuOZRa2cDCL//sZ3/wEYIJPs5O/ObTF+nst00b/CbC6ttDCA/ziqIQadyBN53v2NAAA=" + } + ] + } +} +``` + +We now got the `group_virtual_psbt`, which is the Taproot Asset VM transaction +that is going to be signed in the next step to prove ownership of the group key. + +## Step 5: Sign the group PSBT + +We now copy the `group_virtual_psbt` from the previous step and sign it with +`chantools`: + +```shell +$ chantools --regtest signpsbt --walletdb /tmp/wallet.db \ + --psbt cHNidP8BAF4CAAAAATKZro+KSjqg4YQvE0bqBCbWuii3ekKAdufOGo57L8lwAAAAAAAAAAAAAQBlzR0AAAAAIlEgxoSpM86Pyu/bCRKhOc6/2TLXDGXnUnXn69FQqD8gw7cAAAAAAAEBKwBlzR0AAAAAIlEgqUflbsA2uA/P2qYe6qclsUox7koFCR3h1xkwh4+M1wQiBgOmVT/xqoux3JGzXh+EKPmebfw6ZuOZRa2cDCL//sZ3/xgQYIu5VgAAgAEAAIAAAACAAAAAAAAAAAAhFqZVP/Gqi7HckbNeH4Qo+Z5t/Dpm45lFrZwMIv/+xnf/GQAQYIu5VgAAgAEAAIAAAACAAAAAAAAAAAABFyCmVT/xqoux3JGzXh+EKPmebfw6ZuOZRa2cDCL//sZ3/wEYIJPs5O/ObTF+nst00b/CbC6ttDCA/ziqIQadyBN53v2NAAA= + +2024-12-27 13:45:06.344 [INF] CHAN: chantools version v0.13.5 commit +Input wallet password: +Successfully signed PSBT: + +cHNidP8BAF4CAAAAATKZro+KSjqg4YQvE0bqBCbWuii3ekKAdufOGo57L8lwAAAAAAAAAAAAAQBlzR0AAAAAIlEgxoSpM86Pyu/bCRKhOc6/2TLXDGXnUnXn69FQqD8gw7cAAAAAAAEBKwBlzR0AAAAAIlEgqUflbsA2uA/P2qYe6qclsUox7koFCR3h1xkwh4+M1wQBCEIBQAv/X4PJqGyO2YzL2uJgIK+gDFGCTIFkzAq29ThWcBuW5mFIc7aQX1CBtxHSXiF8/jn+F5sWeL0pve1ZKxY7L4EAAA== +``` + +## Step 5b: Extract the signature from the PSBT + +TODO(guggero/ffranr): Replace this step by allowing the CLI to take the signed +PSBT instead. We can list the batch to get the asset ID of each pending asset +and match the PSBT's input previous output to find out what signed PSBT belongs +to what asset (in case there are multiple). + +```shell +$ bitcoin-cli decodepsbt cHNidP8BAF4CAAAAATKZro+KSjqg4YQvE0bqBCbWuii3ekKAdufOGo57L8lwAAAAAAAAAAAAAQBlzR0AAAAAIlEgxoSpM86Pyu/bCRKhOc6/2TLXDGXnUnXn69FQqD8gw7cAAAAAAAEBKwBlzR0AAAAAIlEgqUflbsA2uA/P2qYe6qclsUox7koFCR3h1xkwh4+M1wQBCEIBQAv/X4PJqGyO2YzL2uJgIK+gDFGCTIFkzAq29ThWcBuW5mFIc7aQX1CBtxHSXiF8/jn+F5sWeL0pve1ZKxY7L4EAAA== + +{ + "tx": { + "txid": "1994e0f5e6beee0a58f76b2f806894f94d93ea0a21c6e380b7634f76c358c38a", + "hash": "1994e0f5e6beee0a58f76b2f806894f94d93ea0a21c6e380b7634f76c358c38a", + "version": 2, + "size": 94, + "vsize": 94, + "weight": 376, + "locktime": 0, + "vin": [ + { + "txid": "70c92f7b8e1acee77680427ab728bad62604ea46132f84e1a03a4a8a8fae9932", + "vout": 0, + "scriptSig": { + "asm": "", + "hex": "" + }, + "sequence": 0 + } + ], + "vout": [ + { + "value": 5.00000000, + "n": 0, + "scriptPubKey": { + "asm": "1 c684a933ce8fcaefdb0912a139cebfd932d70c65e75275e7ebd150a83f20c3b7", + "desc": "addr(bcrt1pc6z2jv7w3l9wlkcfz2snnn4lmyedwrr9uaf8telt69g2s0eqcwmsnuxkp4)#ramnsz8q", + "hex": "5120c684a933ce8fcaefdb0912a139cebfd932d70c65e75275e7ebd150a83f20c3b7", + "address": "bcrt1pc6z2jv7w3l9wlkcfz2snnn4lmyedwrr9uaf8telt69g2s0eqcwmsnuxkp4", + "type": "witness_v1_taproot" + } + } + ] + }, + "global_xpubs": [ + ], + "psbt_version": 0, + "proprietary": [ + ], + "unknown": { + }, + "inputs": [ + { + "witness_utxo": { + "amount": 5.00000000, + "scriptPubKey": { + "asm": "1 a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704", + "desc": "rawtr(a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704)#fnjmj6gz", + "hex": "5120a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704", + "address": "bcrt1p49r72mkqx6uqln765c0w4fe9k99rrmj2q5y3mcwhrycg0ruv6uzqgnfa6h", + "type": "witness_v1_taproot" + } + }, + "final_scriptwitness": [ + "0bff5f83c9a86c8ed98ccbdae26020afa00c51824c8164cc0ab6f53856701b96e6614873b6905f5081b711d25e217cfe39fe179b1678bd29bded592b163b2f81" + ] + } + ], + "outputs": [ + { + } + ], + "fee": 0.00000000 +} + +``` + +We'll take the witness as the signature for the next step: + +```json +"final_scriptwitness": [ +"0bff5f83c9a86c8ed98ccbdae26020afa00c51824c8164cc0ab6f53856701b96e6614873b6905f5081b711d25e217cfe39fe179b1678bd29bded592b163b2f81" +] +``` + +## Step 6: Seal the batch with the signature + +TODO(guggero/ffranr): Use signed PSBT instead, currently it's +`--group_signatures :`, but should be +`--signed_group_psbt` or something like that. + +```shell +$ tapcli assets mint seal --group_signatures c4b0771c1bd1334bf20df5204c162702a6dc765a9cb15b1bc9e3c91e0282061b:0bff5f83c9a86c8ed98ccbdae26020afa00c51824c8164cc0ab6f53856701b96e6614873b6905f5081b711d25e217cfe39fe179b1678bd29bded592b163b2f81 + +{ + "batch": { + "batch_key": "031cad33f9c2d11ba1955c86d30e99414010a3d8db3cf005cdfd7b5947884d152b", + "batch_txid": "", + "state": "BATCH_STATE_PENDING", + "assets": [ + { + "asset_version": "ASSET_VERSION_V0", + "asset_type": "NORMAL", + "name": "usdt", + "asset_meta": null, + "amount": "500000000", + "new_grouped_asset": true, + "group_key": "02a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704", + "group_anchor": "", + "group_internal_key": { + "raw_key_bytes": "03a6553ff1aa8bb1dc91b35e1f8428f99e6dfc3a66e39945ad9c0c22fffec677ff", + "key_loc": { + "key_family": 0, + "key_index": 0 + } + }, + "group_tapscript_root": "", + "script_key": { + "pub_key": "ff3608f3e5e608317011201b104bf87352655f4ea47c14edad0cabe6d69ff5b4", + "key_desc": { + "raw_key_bytes": "03a0fc40fd7d5ecbc34cfd479aa44320af064a9df7a3c9d1940ebe2fc9bcd8f1a9", + "key_loc": { + "key_family": 212, + "key_index": 15 + } + }, + "tap_tweak": "" + } + } + ], + "created_at": "1735303474", + "height_hint": 157, + "batch_psbt": "70736274ff010089020000000193267bc4203fbcd503f52ebf10e57cb1bea854617ac27b07df36d6feae38407100000000000000000002e803000000000000225120000000000000000000000000000000000000000000000000000000000000000039d0f50500000000225120b57e85d54f10ff813207ebb49e0c1a174813946516ca0e1c0b06191ba6b2667400000000000100de02000000000101049ea356718188c25b111a07f293158e6fbff2c0780643aa8731d392ac3b5b180100000000fdffffff0200e1f50500000000160014dd2f53994b70a2c43b72bb7f66b63d8b8e629a5cd05b93d600000000160014c10699dfa395cc2d48d7ed5fc697c5efddd18fe60247304402202d46b3fc55d7ca7140ac38a3847c1c1df9984f8c2abbdbcdb8779208810199b00220134869b61fee2a09fcbd4a5bc6b2ce813f1f785b692d8971ee30f6dd2a172ce20121028a0bda7fde65fc310d5a2540aee5f20c2693faab85331c3161063b842611e2d98c00000001011f00e1f50500000000160014dd2f53994b70a2c43b72bb7f66b63d8b8e629a5c010304010000002206020b76f7e4cb9de0a39697e085815ec8c32ad3124f693bf6cfe2ae44477f4c23ed180000000054000080000000800000008000000000010000000000220203b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f21718000000005600008000000080000000800100000007000000010520b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f2172107b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f217190000000000560000800000008000000080010000000700000000" + } +} +``` + +## Step 7: Finalize the batch + +If the step above didn't result in an error, the minting batch is ready to be +finalized: + +```shell +$ tapcli assets mint finalize + +{ + "batch": { + "batch_key": "031cad33f9c2d11ba1955c86d30e99414010a3d8db3cf005cdfd7b5947884d152b", + "batch_txid": "07be90fa33795ddb4d20c397ddfb07827c898b8096df75a12871e25ae8f7653a", + "state": "BATCH_STATE_BROADCAST", + "assets": [ + { + "asset_version": "ASSET_VERSION_V0", + "asset_type": "NORMAL", + "name": "usdt", + "asset_meta": null, + "amount": "500000000", + "new_grouped_asset": false, + "group_key": "02a947e56ec036b80fcfdaa61eeaa725b14a31ee4a05091de1d71930878f8cd704", + "group_anchor": "", + "group_internal_key": { + "raw_key_bytes": "03a6553ff1aa8bb1dc91b35e1f8428f99e6dfc3a66e39945ad9c0c22fffec677ff", + "key_loc": { + "key_family": 0, + "key_index": 0 + } + }, + "group_tapscript_root": "93ece4efce6d317e9ecb74d1bfc26c2eadb43080ff38aa21069dc81379defd8d", + "script_key": { + "pub_key": "ff3608f3e5e608317011201b104bf87352655f4ea47c14edad0cabe6d69ff5b4", + "key_desc": { + "raw_key_bytes": "03a0fc40fd7d5ecbc34cfd479aa44320af064a9df7a3c9d1940ebe2fc9bcd8f1a9", + "key_loc": { + "key_family": 212, + "key_index": 15 + } + }, + "tap_tweak": "" + } + } + ], + "created_at": "1735303474", + "height_hint": 157, + "batch_psbt": "70736274ff010089020000000193267bc4203fbcd503f52ebf10e57cb1bea854617ac27b07df36d6feae38407100000000000000000002e8030000000000002251208e7e9e413a2ed27bee7bd378720589005d310e24814449e16f39d0a3087eba5439d0f50500000000225120b57e85d54f10ff813207ebb49e0c1a174813946516ca0e1c0b06191ba6b2667400000000000100de02000000000101049ea356718188c25b111a07f293158e6fbff2c0780643aa8731d392ac3b5b180100000000fdffffff0200e1f50500000000160014dd2f53994b70a2c43b72bb7f66b63d8b8e629a5cd05b93d600000000160014c10699dfa395cc2d48d7ed5fc697c5efddd18fe60247304402202d46b3fc55d7ca7140ac38a3847c1c1df9984f8c2abbdbcdb8779208810199b00220134869b61fee2a09fcbd4a5bc6b2ce813f1f785b692d8971ee30f6dd2a172ce20121028a0bda7fde65fc310d5a2540aee5f20c2693faab85331c3161063b842611e2d98c00000001011f00e1f50500000000160014dd2f53994b70a2c43b72bb7f66b63d8b8e629a5c01086b02473044022004d32c69c7fbb54d2f4278d0f2b2f3506dc1d273a252b8b487c8a425693240a502203e2682d58292fc1339857fd0321b1c8555e63ce4f117dfdded8b8b418333b0d50121020b76f7e4cb9de0a39697e085815ec8c32ad3124f693bf6cfe2ae44477f4c23ed0000220203b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f21718000000005600008000000080000000800100000007000000010520b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f2172107b59023dd9a58fb64dad00948ad44fe5c194cf2e36b2e104bd8ef255bc480f217190000000000560000800000008000000080010000000700000000" + } +} + +``` diff --git a/itest/chantools_harness.go b/itest/chantools_harness.go new file mode 100644 index 000000000..139ae6e34 --- /dev/null +++ b/itest/chantools_harness.go @@ -0,0 +1,160 @@ +package itest + +import ( + "bytes" + "os" + "os/exec" + "path/filepath" + "regexp" + "strings" + "testing" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/stretchr/testify/require" +) + +// chantoolsCmdBuilder is a helper function that creates a new exec.Cmd instance +// for the chantools binary. +func chantoolsCmdBuilder(binPath string, workingDir string, + args ...string) exec.Cmd { + + cmd := exec.Command(binPath, args...) + + // Set the working directory so that any log files are handled + // gracefully. + cmd.Dir = workingDir + + // Set the wallet password. + cmd.Env = append(os.Environ(), "WALLET_PASSWORD=-") + + // Set the seed generation passphrase. + cmd.Env = append(cmd.Env, "AEZEED_PASSPHRASE=-") + + return *cmd +} + +// ChantoolsHarness is a helper struct that provides a way to interact with +// the chantools binary. +type ChantoolsHarness struct { + // path is the path to the chantools binary. + path string + + // workingDir is the chantools harness working directory. + workingDir string + + // walletDbPath is the path to the wallet.db file created by chantools. + walletDbPath string +} + +// NewChantoolsHarness creates a new instance of the ChantoolsHarness struct. +func NewChantoolsHarness(t *testing.T) ChantoolsHarness { + path, err := exec.LookPath("chantools") + require.NoError(t, err, "chantools is not installed or not in PATH") + + t.Logf("Using chantools binary at: %v", path) + + // Create a temporary directory to store the log file and wallet.db + // file. + workingDir, err := os.MkdirTemp("", "itest-tapd-chantools") + require.NoError(t, err, "failed to create chantools working directory") + + // Assert that the version of chantools is as expected. + cmd := chantoolsCmdBuilder(path, workingDir, "--version") + versionOut, err := cmd.CombinedOutput() + require.NoError(t, err, "failed to get chantools version") + + versionOutStr := string(versionOut) + if !strings.Contains(versionOutStr, "chantools version v0.13.5") { + t.Fatalf("unexpected chantools version: %v", versionOutStr) + } + + return ChantoolsHarness{ + path: path, + workingDir: workingDir, + walletDbPath: filepath.Join(workingDir, "wallet.db"), + } +} + +// buildCmd is a helper method that creates a new exec.Cmd instance for the +// chantools binary. +func (c *ChantoolsHarness) buildCmd(args ...string) exec.Cmd { + return chantoolsCmdBuilder(c.path, c.workingDir, args...) +} + +// CreateWallet creates a new wallet using the chantools binary. +func (c *ChantoolsHarness) CreateWallet(t *testing.T) { + cmd := c.buildCmd( + "--regtest", "createwallet", "--bip39", + "--generateseed", "--walletdbdir", c.workingDir, + ) + + cmdOut, err := cmd.CombinedOutput() + require.NoError(t, err) + + t.Logf("Chantools createwallet output: %v", string(cmdOut)) +} + +// DeriveKey derives a new key using the chantools binary. +func (c *ChantoolsHarness) DeriveKey(t *testing.T) (string, string) { + cmd := c.buildCmd( + "--regtest", "derivekey", "--walletdb", c.walletDbPath, + "--path", "m/86'/1'/0'", "--neuter", + ) + + cmdOut, err := cmd.CombinedOutput() + require.NoError(t, err) + + cmdOutStr := string(cmdOut) + t.Logf("Chantools derivekey output: %v", cmdOutStr) + + // Parsing for xpub. + xpubPattern := `Extended public key \(xpub\):\s+([a-zA-Z0-9]+)` + xpubRegex := regexp.MustCompile(xpubPattern) + matches := xpubRegex.FindStringSubmatch(cmdOutStr) + require.Len(t, matches, 2) + + xpub := matches[1] + require.NotEmpty(t, xpub) + + // Parsing for master fingerprint. + fingerprintPattern := `Master Fingerprint:\s+([a-f0-9]+)` + fingerprintRegex := regexp.MustCompile(fingerprintPattern) + matches = fingerprintRegex.FindStringSubmatch(cmdOutStr) + require.Len(t, matches, 2) + + masterFingerprint := matches[1] + require.Len(t, masterFingerprint, 8) + + return xpub, masterFingerprint +} + +// SignPsbt signs a PSBT using the chantools binary. +func (c *ChantoolsHarness) SignPsbt(t *testing.T, psbtStr string) psbt.Packet { + cmd := c.buildCmd( + "--regtest", "signpsbt", "--walletdb", c.walletDbPath, + "--psbt", psbtStr, + ) + + cmdOut, err := cmd.CombinedOutput() + require.NoError(t, err) + + cmdOutStr := string(cmdOut) + t.Logf("Chantools signpsbt output: %v", cmdOutStr) + + // Extract the signed PSBT. + psbtPattern := `Successfully signed PSBT:\n\n([a-zA-Z0-9+/=]+)` + psbtRegex := regexp.MustCompile(psbtPattern) + matches := psbtRegex.FindStringSubmatch(cmdOutStr) + require.Len(t, matches, 2) + + signedPsbtStr := matches[1] + require.NotEmpty(t, signedPsbtStr) + + // Parse the signed PSBT. + signedPsbt, err := psbt.NewFromRawBytes(bytes.NewReader( + []byte(signedPsbtStr)), true, + ) + require.NoError(t, err) + + return *signedPsbt +} diff --git a/itest/mint_fund_seal_test.go b/itest/mint_fund_seal_test.go index 34d74c573..6936dc7e5 100644 --- a/itest/mint_fund_seal_test.go +++ b/itest/mint_fund_seal_test.go @@ -3,6 +3,7 @@ package itest import ( "bytes" "context" + "encoding/base64" "encoding/hex" "math" "testing" @@ -149,9 +150,9 @@ func testMintFundSealAssets(t *harnessTest) { require.NotEmpty(t.t, fundResp.Batch) require.Equal( t.t, mintrpc.BatchState_BATCH_STATE_PENDING, - fundResp.Batch.State, + fundResp.Batch.Batch.State, ) - require.NotEmpty(t.t, fundResp.Batch.BatchPsbt) + require.NotEmpty(t.t, fundResp.Batch.Batch.BatchPsbt) // Now we can add all the asset requests created above. BuildMintingBatch(t.t, aliceTapd, assetReqs) @@ -500,6 +501,91 @@ func testMintFundSealAssets(t *harnessTest) { }) } +// testMintExternalGroupKeyChantools tests that we're able to mint an asset +// using an external asset signing group key derived and managed by chantools. +func testMintExternalGroupKeyChantools(t *harnessTest) { + chantools := NewChantoolsHarness(t.t) + + // Use chantools to create a new wallet and derive a new key. + chantools.CreateWallet(t.t) + groupKeyXpub, groupKeyFingerprint := chantools.DeriveKey(t.t) + + t.Logf("Extended public key (xpub): %v", groupKeyXpub) + t.Logf("Master Fingerprint: %v", groupKeyFingerprint) + + // Formulate the external group key which will be used in the asset + // minting request. + fingerPrintBytes, err := hex.DecodeString(groupKeyFingerprint) + require.NoError(t.t, err) + + externalGroupKey := &taprpc.ExternalKey{ + Xpub: groupKeyXpub, + MasterFingerprint: fingerPrintBytes, + DerivationPath: "m/86'/1'/0'/0/0", + } + + // Now we will use the external group key to mint. + // + // Construct external signer callback to sign the group virtual PSBT. + signerCallback := func( + unsealedAsset []*mintrpc.UnsealedAsset) []ExternalSigRes { + + var res []ExternalSigRes + for idx := range unsealedAsset { + unsealedA := unsealedAsset[idx] + + t.Logf("Unsigned group virtual PSBT: %v", + unsealedA.GroupVirtualPsbt) + + signedPsbt := chantools.SignPsbt( + t.t, unsealedA.GroupVirtualPsbt, + ) + t.Logf("Signed group virtual PSBT: %v", signedPsbt) + + var assetID asset.ID + copy( + assetID[:], + unsealedA.GroupKeyRequest.AnchorGenesis.AssetId, + ) + + res = append(res, ExternalSigRes{ + SignedPsbt: signedPsbt, + AssetID: assetID, + }) + } + + return res + } + + // Mint assets with the external signer. + // + // Add asset mint request to mint batch. + mintReq := CopyRequest(issuableAssets[0]) + mintReq.Asset.ExternalGroupKey = externalGroupKey + + assetReqs := []*mintrpc.MintAssetRequest{mintReq} + + batchAssets := MintAssetExternalSigner( + t, t.tapd, assetReqs, signerCallback, + ) + t.Logf("First batch asset: %v", batchAssets) + + // Formulate a second asset mint request with the same external group + // key. This will ensure that we can mint two different tranches into + // the same group. + mintReq2 := CopyRequest(issuableAssets[0]) + mintReq2.Asset.Name = "itestbuxx-money-printer-brrr-tranche-2" + mintReq2.Asset.ExternalGroupKey = externalGroupKey + + assetReqs2 := []*mintrpc.MintAssetRequest{mintReq2} + + // Mint assets with the external signer. + batchAssets2 := MintAssetExternalSigner( + t, t.tapd, assetReqs2, signerCallback, + ) + t.Logf("Second batch asset: %v", batchAssets2) +} + // Derive a random key on an LND node, with a key family not matching the // Taproot Assets key family. func deriveRandomKey(t *testing.T, ctxt context.Context, @@ -618,6 +704,22 @@ func unmarshalPendingAssetGroup(t *testing.T, virtualTx, err := taprpc.UnmarshalGroupVirtualTx(a.GroupVirtualTx) require.NoError(t, err) + // Ensure that the group virtual tx is the same as the grouped virtual + // PSBT. + groupVirtualPsbt, err := base64.StdEncoding.DecodeString( + a.GroupVirtualPsbt, + ) + require.NoError(t, err) + + groupVmPsbt, err := psbt.NewFromRawBytes( + bytes.NewReader(groupVirtualPsbt), false, + ) + require.NoError(t, err) + require.NotNil(t, groupVmPsbt) + + require.Equal(t, *groupVmPsbt.UnsignedTx, virtualTx.Tx) + + // Unmarshal group key request. require.NotNil(t, a.GroupKeyRequest) keyReq, err := taprpc.UnmarshalGroupKeyRequest(a.GroupKeyRequest) require.NoError(t, err) diff --git a/itest/test_list_on_test.go b/itest/test_list_on_test.go index 7a5a661dc..02f6dd0a0 100644 --- a/itest/test_list_on_test.go +++ b/itest/test_list_on_test.go @@ -37,6 +37,10 @@ var testCases = []*testCase{ name: "mint fund seal assets", test: testMintFundSealAssets, }, + { + name: "mint external group key chantools", + test: testMintExternalGroupKeyChantools, + }, { name: "mint asset decimal display", test: testMintAssetWithDecimalDisplayMetaField, diff --git a/itest/utils.go b/itest/utils.go index 761e9ed99..c93957969 100644 --- a/itest/utils.go +++ b/itest/utils.go @@ -3,6 +3,8 @@ package itest import ( "bytes" "context" + "fmt" + "log" "testing" "time" @@ -30,6 +32,7 @@ import ( "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lntest/node" "github.com/lightningnetwork/lnd/lnwallet/chainfee" + "github.com/lightningnetwork/lnd/tlv" "github.com/stretchr/testify/require" "google.golang.org/grpc" "google.golang.org/protobuf/proto" @@ -735,6 +738,151 @@ func ManualMintSimpleAsset(t *harnessTest, lndNode *node.HarnessNode, return mintedAsset[0], &importReq } +// ExternalSigRes is a helper struct that holds the signed PSBT and the +// corresponding asset ID. +type ExternalSigRes struct { + SignedPsbt psbt.Packet + AssetID asset.ID +} + +// ExternalSigCallback is a callback function that is called to sign the group +// virtual PSBT with external signers. +type ExternalSigCallback func([]*mintrpc.UnsealedAsset) []ExternalSigRes + +// MintAssetExternalSigner is a helper function that mints a batch of assets and +// calls the external signer callback to sign the group virtual PSBT. +func MintAssetExternalSigner(t *harnessTest, tapNode *tapdHarness, + assetReqs []*mintrpc.MintAssetRequest, + externalSignerCallback ExternalSigCallback) []*taprpc.Asset { + + BuildMintingBatch(t.t, tapNode, assetReqs) + + // Fund mint batch with BTC. + ctxb := context.Background() + ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout) + + fundResp, err := tapNode.FundBatch(ctxt, &mintrpc.FundBatchRequest{}) + require.NoError(t.t, err) + + // Cancel the context for the fund request call. + cancel() + + require.NotEmpty(t.t, fundResp.Batch) + require.Equal( + t.t, mintrpc.BatchState_BATCH_STATE_PENDING, + fundResp.Batch.Batch.State, + ) + require.Len(t.t, fundResp.Batch.UnsealedAssets, 1) + + // Pass unsealed assets to external signer callback to sign the group + // virtual PSBT. + callbackRes := externalSignerCallback(fundResp.Batch.UnsealedAssets) + + // Extract group witness from signed PSBTs. + var groupWitnesses []*taprpc.GroupWitness + for idx := range callbackRes { + res := callbackRes[idx] + signedPsbt := res.SignedPsbt + genesisAssetID := res.AssetID + + // Sanity check signed PSBT. + require.Len(t.t, signedPsbt.Inputs, 1) + require.Len(t.t, signedPsbt.Outputs, 1) + + // Extract witness from signed PSBT. + witnessStack, err := DeserializeWitnessStack( + signedPsbt.Inputs[0].FinalScriptWitness, + ) + if err != nil { + log.Fatalf("Failed to deserialize witness stack: %v", + err) + } + + groupWitness := taprpc.GroupWitness{ + GenesisId: genesisAssetID[:], + Witness: witnessStack, + } + + groupWitnesses = append(groupWitnesses, &groupWitness) + } + + // Seal the batch with the group witnesses. + ctxt, cancel = context.WithTimeout(ctxb, defaultWaitTimeout) + + sealReq := mintrpc.SealBatchRequest{ + GroupWitnesses: groupWitnesses, + } + sealResp, err := tapNode.SealBatch(ctxt, &sealReq) + require.NoError(t.t, err) + + // Cancel the context for the seal request call. + cancel() + + require.NotEmpty(t.t, sealResp.Batch) + + // With the batch sealed successfully, we can now finalize it and + // broadcast the anchor TX. + ctxt, cancel = context.WithCancel(context.Background()) + defer cancel() + stream, err := tapNode.SubscribeMintEvents( + ctxt, &mintrpc.SubscribeMintEventsRequest{}, + ) + require.NoError(t.t, err) + sub := &EventSubscription[*mintrpc.MintEvent]{ + ClientEventStream: stream, + Cancel: cancel, + } + + batchTXID, batchKey := FinalizeBatchUnconfirmed( + t.t, t.lndHarness.Miner().Client, tapNode, assetReqs, + ) + batchAssets := ConfirmBatch( + t.t, t.lndHarness.Miner().Client, tapNode, assetReqs, sub, + batchTXID, batchKey, + ) + + return batchAssets +} + +// DeserializeWitnessStack deserializes a serialized witness stack into a +// [][]byte. +// +// TODO(ffranr): Reconcile this function with asset.TxWitnessDecoder. +func DeserializeWitnessStack(serialized []byte) ([][]byte, error) { + var ( + // buf is a general scratch buffer used when reading. + buf [8]byte + + stack [][]byte + ) + reader := bytes.NewReader(serialized) + + // Read the number of witness elements (compact size integer) + count, err := tlv.ReadVarInt(reader, &buf) + if err != nil { + return nil, fmt.Errorf("failed to read witness count: %w", err) + } + + // Read each witness element + for i := uint64(0); i < count; i++ { + elementSize, err := tlv.ReadVarInt(reader, &buf) + if err != nil { + return nil, fmt.Errorf("failed to read witness "+ + "element size: %w", err) + } + + // Read the witness element data + element := make([]byte, elementSize) + if _, err := reader.Read(element); err != nil { + return nil, fmt.Errorf("failed to read witness "+ + "element data: %w", err) + } + stack = append(stack, element) + } + + return stack, nil +} + // SyncUniverses syncs the universes of two tapd instances and waits until they // are in sync. func SyncUniverses(ctx context.Context, t *testing.T, clientTapd, diff --git a/proof/mint.go b/proof/mint.go index e77d3b9c5..fbe00c244 100644 --- a/proof/mint.go +++ b/proof/mint.go @@ -386,13 +386,21 @@ func committedProofs(baseProof *Proof, tapTreeRoot *commitment.TapCommitment, if newAsset.GroupKey != nil { groupKey := newAsset.GroupKey + // Check if the asset is the group anchor. err := groupAnchorVerifier(&newAsset.Genesis, groupKey) if err == nil { - rawKey := asset.ToSerialized( - groupKey.RawKey.PubKey, + // At this point, we know that the asset is the + // group anchor. We'll now create the group key + // reveal for this asset. + groupReveal, err := asset.NewGroupKeyReveal( + *groupKey, newAsset.Genesis.ID(), ) - groupReveal := asset.NewGroupKeyRevealV0( - rawKey, groupKey.TapscriptRoot) + if err != nil { + return nil, fmt.Errorf("unable to "+ + "create group key reveal: %w", + err) + } + assetProof.GroupKeyReveal = groupReveal } } diff --git a/rpcserver.go b/rpcserver.go index f47604a1a..9035a2b7f 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "crypto/sha256" + "encoding/base64" "encoding/hex" "encoding/json" "errors" @@ -20,6 +21,7 @@ import ( "github.com/btcsuite/btcd/btcec/v2/schnorr" "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/wire" "github.com/btcsuite/btcwallet/wtxmgr" @@ -581,6 +583,13 @@ func (r *rpcServer) MintAsset(ctx context.Context, groupTapscriptRoot = bytes.Clone(req.Asset.GroupTapscriptRoot) } + if req.Asset.ExternalGroupKey != nil && + req.Asset.GroupInternalKey != nil { + + return nil, fmt.Errorf("cannot set both external group key " + + "and group internal key descriptor") + } + seedling := &tapgarden.Seedling{ AssetVersion: assetVersion, AssetType: asset.Type(req.Asset.AssetType), @@ -606,6 +615,31 @@ func (r *rpcServer) MintAsset(ctx context.Context, seedling.GroupTapscriptRoot = groupTapscriptRoot } + if req.Asset.ExternalGroupKey != nil { + externalKey, err := taprpc.UnmarshalExternalKey( + req.Asset.ExternalGroupKey, + ) + if err != nil { + return nil, fmt.Errorf("unable to parse external key: "+ + "%w", err) + } + + if err := externalKey.Validate(); err != nil { + return nil, fmt.Errorf("invalid external key: %w", err) + } + + internalKey, err := externalKey.PubKey() + if err != nil { + return nil, fmt.Errorf("unable to derive internal "+ + "group key from xpub: %w", err) + } + + seedling.ExternalKey = fn.Some(externalKey) + seedling.GroupInternalKey = &keychain.KeyDescriptor{ + PubKey: &internalKey, + } + } + switch { // If a group key is provided, parse the provided group public key // before creating the asset seedling. @@ -628,7 +662,7 @@ func (r *rpcServer) MintAsset(ctx context.Context, }, } - // If a group anchor is provided, propoate the name to the seedling. + // If a group anchor is provided, propagate the name to the seedling. // We cannot do any name validation from outside the minter. case specificGroupAnchor: seedling.GroupAnchor = &req.Asset.GroupAnchor @@ -715,22 +749,23 @@ func (r *rpcServer) FundBatch(ctx context.Context, return nil, err } - batch, err := r.cfg.AssetMinter.FundBatch( - tapgarden.FundParams{ - FeeRate: feeRateOpt, - SiblingTapTree: tapTreeOpt, - }, - ) + fundBatchResp, err := r.cfg.AssetMinter.FundBatch(tapgarden.FundParams{ + FeeRate: feeRateOpt, + SiblingTapTree: tapTreeOpt, + }) if err != nil { return nil, fmt.Errorf("unable to fund batch: %w", err) } // If there was no batch to fund, return an empty response. - if batch == nil { + if fundBatchResp.Batch == nil { return &mintrpc.FundBatchResponse{}, nil } - rpcBatch, err := marshalMintingBatch(batch, req.ShortResponse) + rpcBatch, err := marshalVerboseBatch( + *r.cfg.ChainParams.Params, fundBatchResp.Batch, + !req.ShortResponse, req.ShortResponse, + ) if err != nil { return nil, err } @@ -887,7 +922,10 @@ func (r *rpcServer) ListBatches(_ context.Context, batches, func(b *tapgarden.VerboseBatch) (*mintrpc.VerboseBatch, error) { - return marshalVerboseBatch(b, req.Verbose, false) + return marshalVerboseBatch( + *r.cfg.ChainParams.Params, b, req.Verbose, + false, + ) }, ) if err != nil { @@ -4072,8 +4110,8 @@ func marshalSendEvent(event fn.Event) (*taprpc.SendEvent, error) { } // marshalVerboseBatch marshals a minting batch into the RPC counterpart. -func marshalVerboseBatch(batch *tapgarden.VerboseBatch, verbose bool, - skipSeedlings bool) (*mintrpc.VerboseBatch, error) { +func marshalVerboseBatch(params chaincfg.Params, batch *tapgarden.VerboseBatch, + verbose bool, skipSeedlings bool) (*mintrpc.VerboseBatch, error) { rpcMintingBatch, err := marshalMintingBatch( batch.MintingBatch, skipSeedlings, @@ -4095,7 +4133,7 @@ func marshalVerboseBatch(batch *tapgarden.VerboseBatch, verbose bool, // We only need to convert the seedlings to unsealed seedlings. if len(batch.UnsealedSeedlings) > 0 { rpcBatch.UnsealedAssets, err = marshalUnsealedSeedlings( - verbose, batch.UnsealedSeedlings, + params, verbose, batch.UnsealedSeedlings, ) if err != nil { return nil, err @@ -4242,13 +4280,14 @@ func marshalSeedling(seedling *tapgarden.Seedling) (*mintrpc.PendingAsset, // marshalUnsealedSeedling marshals an unsealed seedling into the RPC // counterpart. -func marshalUnsealedSeedling(verbose bool, +func marshalUnsealedSeedling(params chaincfg.Params, verbose bool, seedling *tapgarden.UnsealedSeedling) (*mintrpc.UnsealedAsset, error) { var ( - groupVirtualTx *taprpc.GroupVirtualTx - groupReq *taprpc.GroupKeyRequest - err error + groupVirtualTx *taprpc.GroupVirtualTx + groupReq *taprpc.GroupKeyRequest + groupVirtualPsbt string + err error ) rpcSeedling, err := marshalSeedling(seedling.Seedling) @@ -4270,12 +4309,34 @@ func marshalUnsealedSeedling(verbose bool, if err != nil { return nil, err } + + // Generate PSBT equivalent of the group virtual tx. + groupVirtualPacket, err := seedling.PendingAssetGroup.PSBT( + params, + ) + if err != nil { + return nil, fmt.Errorf("error getting group virtual "+ + "PSBT for unsealed seedling: %w", err) + } + + // Serialize PSBT to bytes. + var psbtBuf bytes.Buffer + err = groupVirtualPacket.Serialize(&psbtBuf) + if err != nil { + return nil, fmt.Errorf("error serializing group "+ + "virtual PSBT for unsealed seedling: %w", err) + } + + groupVirtualPsbt = base64.StdEncoding.EncodeToString( + psbtBuf.Bytes(), + ) } return &mintrpc.UnsealedAsset{ - Asset: rpcSeedling, - GroupVirtualTx: groupVirtualTx, - GroupKeyRequest: groupReq, + Asset: rpcSeedling, + GroupVirtualTx: groupVirtualTx, + GroupVirtualPsbt: groupVirtualPsbt, + GroupKeyRequest: groupReq, }, nil } @@ -4289,13 +4350,15 @@ func marshalSeedlings( // marshalUnsealedSeedlings marshals the unsealed seedlings into the RPC // counterpart. -func marshalUnsealedSeedlings(verbose bool, +func marshalUnsealedSeedlings(params chaincfg.Params, verbose bool, seedlings map[string]*tapgarden.UnsealedSeedling) ( []*mintrpc.UnsealedAsset, error) { rpcAssets := make([]*mintrpc.UnsealedAsset, 0, len(seedlings)) for _, seedling := range seedlings { - nextSeedling, err := marshalUnsealedSeedling(verbose, seedling) + nextSeedling, err := marshalUnsealedSeedling( + params, verbose, seedling, + ) if err != nil { return nil, err } diff --git a/tapdb/addrs.go b/tapdb/addrs.go index 654821444..3a79d250c 100644 --- a/tapdb/addrs.go +++ b/tapdb/addrs.go @@ -1097,9 +1097,10 @@ func (t *TapAddressBook) QueryAssetGroup(ctx context.Context, } assetGroup.GroupKey, err = parseGroupKeyInfo( - groupInfo.TweakedGroupKey, groupInfo.RawKey, - groupInfo.WitnessStack, groupInfo.TapscriptRoot, - groupInfo.KeyFamily, groupInfo.KeyIndex, + groupInfo.Version, groupInfo.TweakedGroupKey, + groupInfo.RawKey, groupInfo.WitnessStack, + groupInfo.TapscriptRoot, groupInfo.KeyFamily, + groupInfo.KeyIndex, groupInfo.CustomSubtreeRoot, ) return err diff --git a/tapdb/asset_minting_test.go b/tapdb/asset_minting_test.go index e647b5aea..9d2ef0d87 100644 --- a/tapdb/asset_minting_test.go +++ b/tapdb/asset_minting_test.go @@ -132,7 +132,8 @@ func storeGroupGenesis(t *testing.T, ctx context.Context, initGen asset.Genesis, t, assetGen, nil, asset.RandScriptKey(t), ) groupReq := asset.NewGroupKeyRequestNoErr( - t, privDesc, initGen, genProtoAsset, nil, + t, privDesc, fn.None[asset.ExternalKey](), initGen, + genProtoAsset, nil, fn.None[chainhash.Hash](), ) genTx, err := groupReq.BuildGroupVirtualTx(&genTxBuilder) require.NoError(t, err) @@ -671,8 +672,10 @@ func seedlingsToAssetRoot(t *testing.T, genesisPoint wire.OutPoint, if groupInfo != nil { groupReq := asset.NewGroupKeyRequestNoErr( t, groupInfo.GroupKey.RawKey, + fn.None[asset.ExternalKey](), *groupInfo.Genesis, protoAsset, groupInfo.GroupKey.TapscriptRoot, + fn.None[chainhash.Hash](), ) genTx, err := groupReq.BuildGroupVirtualTx( &genTxBuilder, @@ -690,8 +693,10 @@ func seedlingsToAssetRoot(t *testing.T, genesisPoint wire.OutPoint, groupKeyRaw, newGroupPriv := test.RandKeyDesc(t) genSigner := asset.NewMockGenesisSigner(newGroupPriv) groupReq := asset.NewGroupKeyRequestNoErr( - t, groupKeyRaw, assetGen, protoAsset, + t, groupKeyRaw, fn.None[asset.ExternalKey](), + assetGen, protoAsset, seedling.GroupTapscriptRoot, + fn.None[chainhash.Hash](), ) genTx, err := groupReq.BuildGroupVirtualTx( &genTxBuilder, diff --git a/tapdb/assets_common.go b/tapdb/assets_common.go index 921716700..81e39105a 100644 --- a/tapdb/assets_common.go +++ b/tapdb/assets_common.go @@ -12,8 +12,10 @@ import ( "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/proof" "github.com/lightninglabs/taproot-assets/tapdb/sqlc" + lfn "github.com/lightningnetwork/lnd/fn" "github.com/lightningnetwork/lnd/keychain" ) @@ -83,6 +85,10 @@ type UpsertAssetStore interface { // updated asset's database ID is returned. SetAssetSpent(ctx context.Context, arg SetAssetSpentParams) (int64, error) + + // UpsertTapscriptTreeRootHash inserts a new tapscript tree root hash. + UpsertTapscriptTreeRootHash(ctx context.Context, + arg TapscriptTreeRootHash) (int64, error) } var ( @@ -327,11 +333,37 @@ func upsertGroupKey(ctx context.Context, groupKey *asset.GroupKey, return nullID, ErrTapscriptRootSize } + // Upsert the custom tapscript root if set. We will pass the returned ID + // to the group key upsert. + rootID, err := fn.MapOptionZ( + groupKey.CustomTapscriptRoot, + func(root chainhash.Hash) lfn.Result[sql.NullInt32] { + id, err := q.UpsertTapscriptTreeRootHash( + ctx, TapscriptTreeRootHash{ + RootHash: root[:], + BranchOnly: false, + }, + ) + if err != nil { + return lfn.Err[sql.NullInt32](err) + } + + return lfn.Ok(sqlInt32(id)) + }, + ).Unpack() + if err != nil { + return nullID, fmt.Errorf("failed to upsert custom tapscript "+ + "root: %w", err) + } + + // Upsert the group key itself. groupID, err := q.UpsertAssetGroupKey(ctx, AssetGroupKey{ - TweakedGroupKey: tweakedKeyBytes, - TapscriptRoot: groupKey.TapscriptRoot, - InternalKeyID: keyID, - GenesisPointID: genesisPointID, + Version: int32(groupKey.Version), + TweakedGroupKey: tweakedKeyBytes, + TapscriptRoot: groupKey.TapscriptRoot, + InternalKeyID: keyID, + GenesisPointID: genesisPointID, + CustomSubtreeRootID: rootID, }) if err != nil { return nullID, fmt.Errorf("%w: %w", ErrUpsertGroupKey, err) @@ -541,9 +573,10 @@ func fetchGroupByGenesis(ctx context.Context, q GroupStore, } groupKey, err := parseGroupKeyInfo( - groupInfo.TweakedGroupKey, groupInfo.RawKey, + groupInfo.Version, groupInfo.TweakedGroupKey, groupInfo.RawKey, groupInfo.WitnessStack, groupInfo.TapscriptRoot, groupInfo.KeyFamily, groupInfo.KeyIndex, + groupInfo.CustomSubtreeRoot, ) if err != nil { return nil, err @@ -575,8 +608,10 @@ func fetchGroupByGroupKey(ctx context.Context, q GroupStore, } groupKey, err := parseGroupKeyInfo( - groupKeyQuery, groupInfo.RawKey, groupInfo.WitnessStack, - groupInfo.TapscriptRoot, groupInfo.KeyFamily, groupInfo.KeyIndex, + groupInfo.Version, groupKeyQuery, groupInfo.RawKey, + groupInfo.WitnessStack, groupInfo.TapscriptRoot, + groupInfo.KeyFamily, groupInfo.KeyIndex, + groupInfo.CustomSubtreeRoot, ) if err != nil { return nil, err @@ -589,8 +624,9 @@ func fetchGroupByGroupKey(ctx context.Context, q GroupStore, } // parseGroupKeyInfo maps information on a group key into a GroupKey. -func parseGroupKeyInfo(tweakedKey, rawKey, witness, tapscriptRoot []byte, - keyFamily, keyIndex int32) (*asset.GroupKey, error) { +func parseGroupKeyInfo(version int32, tweakedKey, rawKey, witness, + tapscriptRoot []byte, keyFamily, keyIndex int32, + customSubtreeRoot []byte) (*asset.GroupKey, error) { tweakedGroupKey, err := btcec.ParsePubKey(tweakedKey) if err != nil { @@ -618,11 +654,28 @@ func parseGroupKeyInfo(tweakedKey, rawKey, witness, tapscriptRoot []byte, } } + // Parse group key version from database row. + groupKeyVersion, err := asset.NewGroupKeyVersion(version) + if err != nil { + return nil, err + } + + // Parse custom tapscript root if specified. + var customSubtreeRootHash fn.Option[chainhash.Hash] + if len(customSubtreeRoot) != 0 { + var rootHash chainhash.Hash + copy(rootHash[:], customSubtreeRoot) + + customSubtreeRootHash = fn.Some(rootHash) + } + return &asset.GroupKey{ - RawKey: groupRawKey, - GroupPubKey: *tweakedGroupKey, - TapscriptRoot: tapscriptRoot, - Witness: groupWitness, + Version: groupKeyVersion, + RawKey: groupRawKey, + GroupPubKey: *tweakedGroupKey, + TapscriptRoot: tapscriptRoot, + Witness: groupWitness, + CustomTapscriptRoot: customSubtreeRootHash, }, nil } diff --git a/tapdb/assets_store_test.go b/tapdb/assets_store_test.go index 928fa2492..f999f091a 100644 --- a/tapdb/assets_store_test.go +++ b/tapdb/assets_store_test.go @@ -167,7 +167,8 @@ func randAsset(t *testing.T, genOpts ...assetGenOpt) *asset.Asset { } groupReq := asset.NewGroupKeyRequestNoErr( - t, groupKeyDesc, initialGen, protoAsset, nil, + t, groupKeyDesc, fn.None[asset.ExternalKey](), initialGen, + protoAsset, nil, fn.None[chainhash.Hash](), ) genTx, err := groupReq.BuildGroupVirtualTx(&genTxBuilder) require.NoError(t, err) @@ -1758,6 +1759,84 @@ func TestAssetGroupComplexWitness(t *testing.T) { require.True(t, groupKey.IsEqual(storedGroup.GroupKey)) } +// TestAssetGroupV1 tests that we can store and fetch an asset group version 1. +func TestAssetGroupV1(t *testing.T) { + t.Parallel() + + mintingStore, assetStore, db := newAssetStore(t) + ctx := context.Background() + + internalKey := test.RandPubKey(t) + groupAnchorGen := asset.RandGenesis(t, asset.RandAssetType(t)) + groupAnchorGen.MetaHash = [32]byte{} + tapscriptRoot := test.RandBytes(32) + customTapscriptRoot := test.RandHash() + groupSig := test.RandBytes(64) + + // First, we'll insert all the required rows we need to satisfy the + // foreign key constraints needed to insert a new genesis witness. + genesisPointID, err := upsertGenesisPoint( + ctx, db, groupAnchorGen.FirstPrevOut, + ) + require.NoError(t, err) + + genAssetID, err := upsertGenesis( + ctx, db, genesisPointID, groupAnchorGen, + ) + require.NoError(t, err) + + groupKey := asset.GroupKey{ + Version: asset.GroupKeyV1, + RawKey: keychain.KeyDescriptor{ + PubKey: internalKey, + }, + GroupPubKey: *internalKey, + TapscriptRoot: tapscriptRoot, + CustomTapscriptRoot: fn.Some[chainhash.Hash]( + customTapscriptRoot, + ), + Witness: fn.MakeSlice(tapscriptRoot, groupSig), + } + + // Upsert, fetch, and check the group key. + _, err = upsertGroupKey( + ctx, &groupKey, assetStore.db, genesisPointID, genAssetID, + ) + require.NoError(t, err) + + storedGroup, err := mintingStore.FetchGroupByGroupKey(ctx, internalKey) + require.NoError(t, err) + + require.Equal(t, groupAnchorGen, *storedGroup.Genesis) + require.True(t, groupKey.IsEqual(storedGroup.GroupKey)) + + // Formulate a new group key where the custom tapscript root is None. + // Check that we can insert and fetch the group key. + groupKeyCustomRootNone := asset.GroupKey{ + Version: asset.GroupKeyV1, + RawKey: keychain.KeyDescriptor{ + PubKey: internalKey, + }, + GroupPubKey: *internalKey, + TapscriptRoot: tapscriptRoot, + CustomTapscriptRoot: fn.None[chainhash.Hash](), + Witness: fn.MakeSlice(tapscriptRoot, groupSig), + } + + // Upsert, fetch, and check the group key. + _, err = upsertGroupKey( + ctx, &groupKeyCustomRootNone, assetStore.db, genesisPointID, + genAssetID, + ) + require.NoError(t, err) + + storedGroup2, err := mintingStore.FetchGroupByGroupKey(ctx, internalKey) + require.NoError(t, err) + + require.Equal(t, groupAnchorGen, *storedGroup2.Genesis) + require.True(t, groupKeyCustomRootNone.IsEqual(storedGroup2.GroupKey)) +} + // TestAssetGroupKeyUpsert tests that if you try to insert another asset group // key with the same tweaked_group_key, then only one is actually created. func TestAssetGroupKeyUpsert(t *testing.T) { diff --git a/tapdb/migrations.go b/tapdb/migrations.go index e8e5a85cc..afc1f58b1 100644 --- a/tapdb/migrations.go +++ b/tapdb/migrations.go @@ -22,7 +22,7 @@ const ( // daemon. // // NOTE: This MUST be updated when a new migration is added. - LatestMigrationVersion = 25 + LatestMigrationVersion = 26 ) // MigrationTarget is a functional option that can be passed to applyMigrations diff --git a/tapdb/sqlc/assets.sql.go b/tapdb/sqlc/assets.sql.go index a518ebbc3..3fa7b2a1b 100644 --- a/tapdb/sqlc/assets.sql.go +++ b/tapdb/sqlc/assets.sql.go @@ -1183,12 +1183,14 @@ func (q *Queries) FetchGenesisPointByAnchorTx(ctx context.Context, anchorTxID sq const fetchGroupByGenesis = `-- name: FetchGroupByGenesis :one SELECT + key_group_info_view.version AS version, key_group_info_view.tweaked_group_key AS tweaked_group_key, key_group_info_view.raw_key AS raw_key, key_group_info_view.key_index AS key_index, key_group_info_view.key_family AS key_family, key_group_info_view.tapscript_root AS tapscript_root, - key_group_info_view.witness_stack AS witness_stack + key_group_info_view.witness_stack AS witness_stack, + key_group_info_view.custom_subtree_root AS custom_subtree_root FROM key_group_info_view WHERE ( key_group_info_view.gen_asset_id = $1 @@ -1196,36 +1198,42 @@ WHERE ( ` type FetchGroupByGenesisRow struct { - TweakedGroupKey []byte - RawKey []byte - KeyIndex int32 - KeyFamily int32 - TapscriptRoot []byte - WitnessStack []byte + Version int32 + TweakedGroupKey []byte + RawKey []byte + KeyIndex int32 + KeyFamily int32 + TapscriptRoot []byte + WitnessStack []byte + CustomSubtreeRoot []byte } func (q *Queries) FetchGroupByGenesis(ctx context.Context, genesisID int64) (FetchGroupByGenesisRow, error) { row := q.db.QueryRowContext(ctx, fetchGroupByGenesis, genesisID) var i FetchGroupByGenesisRow err := row.Scan( + &i.Version, &i.TweakedGroupKey, &i.RawKey, &i.KeyIndex, &i.KeyFamily, &i.TapscriptRoot, &i.WitnessStack, + &i.CustomSubtreeRoot, ) return i, err } const fetchGroupByGroupKey = `-- name: FetchGroupByGroupKey :one -SELECT +SELECT + key_group_info_view.version AS version, key_group_info_view.gen_asset_id AS gen_asset_id, key_group_info_view.raw_key AS raw_key, key_group_info_view.key_index AS key_index, key_group_info_view.key_family AS key_family, key_group_info_view.tapscript_root AS tapscript_root, - key_group_info_view.witness_stack AS witness_stack + key_group_info_view.witness_stack AS witness_stack, + key_group_info_view.custom_subtree_root AS custom_subtree_root FROM key_group_info_view WHERE ( key_group_info_view.tweaked_group_key = $1 @@ -1235,12 +1243,14 @@ LIMIT 1 ` type FetchGroupByGroupKeyRow struct { - GenAssetID int64 - RawKey []byte - KeyIndex int32 - KeyFamily int32 - TapscriptRoot []byte - WitnessStack []byte + Version int32 + GenAssetID int64 + RawKey []byte + KeyIndex int32 + KeyFamily int32 + TapscriptRoot []byte + WitnessStack []byte + CustomSubtreeRoot []byte } // Sort and limit to return the genesis ID for initial genesis of the group. @@ -1248,12 +1258,14 @@ func (q *Queries) FetchGroupByGroupKey(ctx context.Context, groupKey []byte) (Fe row := q.db.QueryRowContext(ctx, fetchGroupByGroupKey, groupKey) var i FetchGroupByGroupKeyRow err := row.Scan( + &i.Version, &i.GenAssetID, &i.RawKey, &i.KeyIndex, &i.KeyFamily, &i.TapscriptRoot, &i.WitnessStack, + &i.CustomSubtreeRoot, ) return i, err } @@ -1267,7 +1279,7 @@ SELECT genesis_info_view.meta_Hash, genesis_info_view.asset_type, key_group_info_view.tweaked_group_key, - version AS asset_version + assets.version AS asset_version FROM assets JOIN genesis_info_view ON assets.genesis_id = genesis_info_view.gen_asset_id @@ -2196,7 +2208,8 @@ func (q *Queries) QueryAssetBalancesByGroup(ctx context.Context, arg QueryAssetB const queryAssets = `-- name: QueryAssets :many SELECT - assets.asset_id AS asset_primary_key, assets.genesis_id, version, spent, + assets.asset_id AS asset_primary_key, + assets.genesis_id, assets.version, spent, script_keys.tweak AS script_key_tweak, script_keys.tweaked_script_key, script_keys.declared_known AS script_key_declared_known, @@ -2569,9 +2582,10 @@ func (q *Queries) UpsertAsset(ctx context.Context, arg UpsertAssetParams) (int64 const upsertAssetGroupKey = `-- name: UpsertAssetGroupKey :one INSERT INTO asset_groups ( - tweaked_group_key, tapscript_root, internal_key_id, genesis_point_id + version, tweaked_group_key, tapscript_root, internal_key_id, + genesis_point_id, custom_subtree_root_id ) VALUES ( - $1, $2, $3, $4 + $1, $2, $3, $4, $5, $6 ) ON CONFLICT (tweaked_group_key) -- This is not a NOP, update the genesis point ID in case it wasn't set -- before. @@ -2580,18 +2594,22 @@ RETURNING group_id ` type UpsertAssetGroupKeyParams struct { - TweakedGroupKey []byte - TapscriptRoot []byte - InternalKeyID int64 - GenesisPointID int64 + Version int32 + TweakedGroupKey []byte + TapscriptRoot []byte + InternalKeyID int64 + GenesisPointID int64 + CustomSubtreeRootID sql.NullInt32 } func (q *Queries) UpsertAssetGroupKey(ctx context.Context, arg UpsertAssetGroupKeyParams) (int64, error) { row := q.db.QueryRowContext(ctx, upsertAssetGroupKey, + arg.Version, arg.TweakedGroupKey, arg.TapscriptRoot, arg.InternalKeyID, arg.GenesisPointID, + arg.CustomSubtreeRootID, ) var group_id int64 err := row.Scan(&group_id) diff --git a/tapdb/sqlc/migrations/000026_asset_group_version_customsubtree.down.sql b/tapdb/sqlc/migrations/000026_asset_group_version_customsubtree.down.sql new file mode 100644 index 000000000..05f82e868 --- /dev/null +++ b/tapdb/sqlc/migrations/000026_asset_group_version_customsubtree.down.sql @@ -0,0 +1,23 @@ +-- Remove the `key_group_info_view` view which includes the new columns. Later, +-- we will recreate the previous version of this view which does not include the +-- new columns. +DROP VIEW IF EXISTS key_group_info_view; + +-- Remove the `version` column from the `asset_groups` table. +ALTER TABLE asset_groups DROP COLUMN version; + +-- Remove the custom_subtree_root_id column from the asset_groups table. +ALTER TABLE asset_groups DROP COLUMN custom_subtree_root_id; + +-- Recreate the previous view. +CREATE VIEW key_group_info_view AS +SELECT + witness_id, gen_asset_id, witness_stack, tapscript_root, + tweaked_group_key, raw_key, key_index, key_family, + substr(tweaked_group_key, 2) AS x_only_group_key +FROM asset_group_witnesses wit + JOIN asset_groups groups + ON wit.group_key_id = groups.group_id + JOIN internal_keys keys + ON keys.key_id = groups.internal_key_id +WHERE wit.gen_asset_id IN (SELECT gen_asset_id FROM genesis_info_view); \ No newline at end of file diff --git a/tapdb/sqlc/migrations/000026_asset_group_version_customsubtree.up.sql b/tapdb/sqlc/migrations/000026_asset_group_version_customsubtree.up.sql new file mode 100644 index 000000000..ad6d958fd --- /dev/null +++ b/tapdb/sqlc/migrations/000026_asset_group_version_customsubtree.up.sql @@ -0,0 +1,36 @@ +-- Add version field to table asset_groups. +ALTER TABLE asset_groups ADD COLUMN version INTEGER NOT NULL DEFAULT 0; + +-- Add the custom_subtree_root_id column to the asset_groups table. This +-- optional column references a row in the tapscript_roots table, linking a +-- custom tapscript subtree to the asset group. The subtree includes +-- user-defined asset group key scripts. +ALTER TABLE asset_groups +ADD COLUMN custom_subtree_root_id INTEGER +REFERENCES tapscript_roots(root_id); + +-- We're going to recreate key_group_info_view to include the new columns. +-- Therefore, we need to drop the existing view. +DROP VIEW IF EXISTS key_group_info_view; + +-- Recreate the key_group_info_view to include the new columns. +-- +-- This view is useful for including group key information via joins. +CREATE VIEW key_group_info_view AS +SELECT + groups.version, witness_id, gen_asset_id, witness_stack, tapscript_root, + tweaked_group_key, raw_key, key_index, key_family, + substr(tweaked_group_key, 2) AS x_only_group_key, + tapscript_roots.root_hash AS custom_subtree_root +FROM asset_group_witnesses wit + JOIN asset_groups groups + ON wit.group_key_id = groups.group_id + JOIN internal_keys keys + ON keys.key_id = groups.internal_key_id + + -- Include the tapscript root hash for the custom subtree. Here we use + -- a LEFT JOIN to allow for the case where a group does not have a + -- custom subtree in which case the custom_subtree_root will be NULL. + LEFT JOIN tapscript_roots + ON groups.custom_subtree_root_id = tapscript_roots.root_id +WHERE wit.gen_asset_id IN (SELECT gen_asset_id FROM genesis_info_view); diff --git a/tapdb/sqlc/models.go b/tapdb/sqlc/models.go index 14e9f8f86..dee1a13b6 100644 --- a/tapdb/sqlc/models.go +++ b/tapdb/sqlc/models.go @@ -64,11 +64,13 @@ type AssetBurnTransfer struct { } type AssetGroup struct { - GroupID int64 - TweakedGroupKey []byte - TapscriptRoot []byte - InternalKeyID int64 - GenesisPointID int64 + GroupID int64 + TweakedGroupKey []byte + TapscriptRoot []byte + InternalKeyID int64 + GenesisPointID int64 + Version int32 + CustomSubtreeRootID sql.NullInt32 } type AssetGroupWitness struct { @@ -238,15 +240,17 @@ type InternalKey struct { } type KeyGroupInfoView struct { - WitnessID int64 - GenAssetID int64 - WitnessStack []byte - TapscriptRoot []byte - TweakedGroupKey []byte - RawKey []byte - KeyIndex int32 - KeyFamily int32 - XOnlyGroupKey []byte + Version int32 + WitnessID int64 + GenAssetID int64 + WitnessStack []byte + TapscriptRoot []byte + TweakedGroupKey []byte + RawKey []byte + KeyIndex int32 + KeyFamily int32 + XOnlyGroupKey []byte + CustomSubtreeRoot []byte } type Macaroon struct { diff --git a/tapdb/sqlc/queries/assets.sql b/tapdb/sqlc/queries/assets.sql index 78bfa313b..ecf868461 100644 --- a/tapdb/sqlc/queries/assets.sql +++ b/tapdb/sqlc/queries/assets.sql @@ -167,9 +167,10 @@ RETURNING genesis_id; -- name: UpsertAssetGroupKey :one INSERT INTO asset_groups ( - tweaked_group_key, tapscript_root, internal_key_id, genesis_point_id + version, tweaked_group_key, tapscript_root, internal_key_id, + genesis_point_id, custom_subtree_root_id ) VALUES ( - $1, $2, $3, $4 + $1, $2, $3, $4, $5, $6 ) ON CONFLICT (tweaked_group_key) -- This is not a NOP, update the genesis point ID in case it wasn't set -- before. @@ -377,7 +378,7 @@ SELECT genesis_info_view.meta_Hash, genesis_info_view.asset_type, key_group_info_view.tweaked_group_key, - version AS asset_version + assets.version AS asset_version FROM assets JOIN genesis_info_view ON assets.genesis_id = genesis_info_view.gen_asset_id @@ -386,13 +387,15 @@ JOIN key_group_info_view WHERE spent = false; -- name: FetchGroupByGroupKey :one -SELECT +SELECT + key_group_info_view.version AS version, key_group_info_view.gen_asset_id AS gen_asset_id, key_group_info_view.raw_key AS raw_key, key_group_info_view.key_index AS key_index, key_group_info_view.key_family AS key_family, key_group_info_view.tapscript_root AS tapscript_root, - key_group_info_view.witness_stack AS witness_stack + key_group_info_view.witness_stack AS witness_stack, + key_group_info_view.custom_subtree_root AS custom_subtree_root FROM key_group_info_view WHERE ( key_group_info_view.tweaked_group_key = @group_key @@ -403,12 +406,14 @@ LIMIT 1; -- name: FetchGroupByGenesis :one SELECT + key_group_info_view.version AS version, key_group_info_view.tweaked_group_key AS tweaked_group_key, key_group_info_view.raw_key AS raw_key, key_group_info_view.key_index AS key_index, key_group_info_view.key_family AS key_family, key_group_info_view.tapscript_root AS tapscript_root, - key_group_info_view.witness_stack AS witness_stack + key_group_info_view.witness_stack AS witness_stack, + key_group_info_view.custom_subtree_root AS custom_subtree_root FROM key_group_info_view WHERE ( key_group_info_view.gen_asset_id = @genesis_id @@ -416,7 +421,8 @@ WHERE ( -- name: QueryAssets :many SELECT - assets.asset_id AS asset_primary_key, assets.genesis_id, version, spent, + assets.asset_id AS asset_primary_key, + assets.genesis_id, assets.version, spent, script_keys.tweak AS script_key_tweak, script_keys.tweaked_script_key, script_keys.declared_known AS script_key_declared_known, diff --git a/tapgarden/interface.go b/tapgarden/interface.go index 3814d8bd0..d2d3fbb8a 100644 --- a/tapgarden/interface.go +++ b/tapgarden/interface.go @@ -22,6 +22,12 @@ import ( "github.com/lightningnetwork/lnd/lnwallet/chainfee" ) +// FundBatchResp is the response returned from the FundBatch method. +type FundBatchResp struct { + // Batch is the batch that was funded. + Batch *VerboseBatch +} + // Planter is responsible for batching a set of seedlings into a minting batch // that will eventually be confirmed on chain. type Planter interface { @@ -43,7 +49,7 @@ type Planter interface { // FundBatch attempts to provide a genesis point for the current batch, // or create a new funded batch. - FundBatch(params FundParams) (*MintingBatch, error) + FundBatch(params FundParams) (*FundBatchResp, error) // SealBatch attempts to seal the current batch, by providing or // deriving all witnesses necessary to create the final genesis TX. diff --git a/tapgarden/planter.go b/tapgarden/planter.go index 6d785b754..a3534642c 100644 --- a/tapgarden/planter.go +++ b/tapgarden/planter.go @@ -10,13 +10,16 @@ import ( "time" "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/chaincfg" "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/wire" "github.com/davecgh/go-spew/spew" "github.com/lightninglabs/taproot-assets/asset" "github.com/lightninglabs/taproot-assets/fn" "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tappsbt" "github.com/lightninglabs/taproot-assets/tapscript" "github.com/lightninglabs/taproot-assets/tapsend" "github.com/lightninglabs/taproot-assets/universe" @@ -141,6 +144,66 @@ type PendingAssetGroup struct { asset.GroupVirtualTx } +// PSBT returns a PSBT packet that can be used to create a group witness for the +// asset group. +func (p *PendingAssetGroup) PSBT( + params chaincfg.Params) (*psbt.Packet, error) { + + // Generate PSBT equivalent of the group virtual tx. + packet, err := psbt.NewFromUnsignedTx(&p.GroupVirtualTx.Tx) + if err != nil { + return nil, fmt.Errorf("error producing group virtual PSBT "+ + "from tx: %w", err) + } + + vIn := &packet.Inputs[0] + vIn.WitnessUtxo = &p.GroupVirtualTx.PrevOut + vIn.TaprootMerkleRoot = p.GroupKeyRequest.TapscriptRoot + vIn.TaprootInternalKey = schnorr.SerializePubKey( + p.GroupKeyRequest.RawKey.PubKey, + ) + + var ( + bip32Derivation *psbt.Bip32Derivation + trBip32Derivation *psbt.TaprootBip32Derivation + ) + + switch { + case p.GroupKeyRequest.ExternalKey.IsSome(): + externalKey := p.GroupKeyRequest.ExternalKey.UnwrapToPtr() + pubKey, err := externalKey.PubKey() + if err != nil { + return nil, fmt.Errorf("error deriving public key "+ + "from external key: %w", err) + } + + bip32Derivation = &psbt.Bip32Derivation{ + PubKey: pubKey.SerializeCompressed(), + MasterKeyFingerprint: externalKey.MasterFingerprint, + Bip32Path: externalKey.DerivationPath, + } + trBip32Derivation = &psbt.TaprootBip32Derivation{ + XOnlyPubKey: bip32Derivation.PubKey[1:], + MasterKeyFingerprint: externalKey.MasterFingerprint, + Bip32Path: externalKey.DerivationPath, + LeafHashes: make([][]byte, 0), + } + + default: + bip32Derivation, trBip32Derivation = + tappsbt.Bip32DerivationFromKeyDesc( + p.GroupKeyRequest.RawKey, params.HDCoinType, + ) + } + + vIn.Bip32Derivation = []*psbt.Bip32Derivation{bip32Derivation} + vIn.TaprootBip32Derivation = []*psbt.TaprootBip32Derivation{ + trBip32Derivation, + } + + return packet, nil +} + // UnsealedSeedling is a previously submitted seedling and its associated // PendingAssetGroup, which can be used to produce an asset group witness. type UnsealedSeedling struct { @@ -660,8 +723,15 @@ func buildGroupReqs(genesisPoint wire.OutPoint, assetOutputIndex uint32, } var ( - amount uint64 - groupInfo *asset.AssetGroup + amount uint64 + + // groupInfo represents the group key and genesis data + // for the asset group. This is populated if the + // seedling specifies a group key or if it specifies + // a group anchor and the corresponding group already + // exists. + groupInfo *asset.AssetGroup + protoAsset *asset.Asset err error ) @@ -703,10 +773,16 @@ func buildGroupReqs(genesisPoint wire.OutPoint, assetOutputIndex uint32, } } + // If groupInfo is specified, a group key already exists for the + // seedling. This key will be used to create a placeholder group + // key request, which will then be used to generate a group + // virtual transaction. if groupInfo != nil { groupReq, err := asset.NewGroupKeyRequest( - groupInfo.GroupKey.RawKey, *groupInfo.Genesis, - protoAsset, groupInfo.GroupKey.TapscriptRoot, + groupInfo.GroupKey.RawKey, seedling.ExternalKey, + *groupInfo.Genesis, protoAsset, + groupInfo.GroupKey.TapscriptRoot, + groupInfo.GroupKey.CustomTapscriptRoot, ) if err != nil { return nil, nil, fmt.Errorf("unable to "+ @@ -723,20 +799,85 @@ func buildGroupReqs(genesisPoint wire.OutPoint, assetOutputIndex uint32, groupReqs = append(groupReqs, *groupReq) genTXs = append(genTXs, *genTx) + + // TODO(ffranr): Should we continue to the next seedling + // at this point? The group key request and virtual + // transaction have been created. } // If emission is enabled, an internal key for the group should // already be specified. Use that to derive the key group // signature along with the tweaked key group. if seedling.EnableEmission { - if seedling.GroupInternalKey == nil { + if seedling.GroupInternalKey == nil && + seedling.ExternalKey.IsNone() { + return nil, nil, fmt.Errorf("unable to " + - "derive group key") + "derive group key, both internal and " + + "external keys are unspecified") + } + + // If seedling.GroupTapscriptRoot is specified and the + // seedling includes an external key, we must use group + // key V1. As a result, seedling.GroupTapscriptRoot will + // be treated as a custom tapscript subtree root, which + // we will graft into the group key's tapscript tree. We + // will proceed with this now. + var ( + tsRoot = seedling.GroupTapscriptRoot + customRootHash fn.Option[chainhash.Hash] + ) + if seedling.ExternalKey.IsSome() { + // If seedling.GroupTapscriptRoot is specified, + // set it to the custom root hash. Then we will + // calculate a new tapscript root hash which + // includes the custom root as a grafted + // subtree. + if len(tsRoot) > 0 { + r, err := chainhash.NewHash(tsRoot) + if err != nil { + return nil, nil, err + } + + customRootHash = fn.Some(*r) + } + + // Construct an asset group tapscript tree, + // incorporating the optional custom subtree + // through grafting. + // + // At this point, we are constructing the group + // tapscript tree root whether or not the + // customRootHash is defined. + tapscriptTree, err := + asset.NewGroupKeyTapscriptRoot( + assetGen.ID(), customRootHash, + ) + if err != nil { + return nil, nil, err + } + + // Update the group tapscript tree root hash to + // the new root hash. If customRootHash is + // defined, the new root hash incorporates it as + // a subtree. + tsRoot = fn.ByteSlice(tapscriptTree.Root()) + } + + // The group internal key should be set at this point. + // + // If an external key is present, the internal key + // should be a public key derived from the external + // key. + if seedling.GroupInternalKey == nil { + return nil, nil, fmt.Errorf("internal key is " + + "missing for seedling") } groupReq, err := asset.NewGroupKeyRequest( - *seedling.GroupInternalKey, assetGen, - protoAsset, seedling.GroupTapscriptRoot, + *seedling.GroupInternalKey, + seedling.ExternalKey, assetGen, + protoAsset, tsRoot, customRootHash, ) if err != nil { return nil, nil, fmt.Errorf("unable to "+ @@ -754,6 +895,7 @@ func buildGroupReqs(genesisPoint wire.OutPoint, assetOutputIndex uint32, genTXs = append(genTXs, *genTx) newGroupKey := &asset.GroupKey{ + Version: groupReq.Version, RawKey: *seedling.GroupInternalKey, TapscriptRoot: seedling.GroupTapscriptRoot, } @@ -952,19 +1094,12 @@ func listBatches(ctx context.Context, batchStore MintingStore, var ( finalBatches, nonFinalBatches = filterFinalizedBatches(batches) - verboseBatches []*VerboseBatch + sortedBatches []*MintingBatch ) switch { case len(finalBatches) == 0: - verboseBatches = fn.Map(batches, - func(b *MintingBatch) *VerboseBatch { - return &VerboseBatch{ - MintingBatch: b, - UnsealedSeedlings: nil, - } - }, - ) + sortedBatches = batches // For finalized batches, we need to fetch the assets from the proof // archiver, not the DB. @@ -989,7 +1124,13 @@ func listBatches(ctx context.Context, batchStore MintingStore, return a.CreationTime.Compare(b.CreationTime) }) - verboseBatches = fn.Map(allBatches, + sortedBatches = allBatches + } + + // Return the batches without any extra asset group info. + if !params.Verbose { + batches := fn.Map( + sortedBatches, func(b *MintingBatch) *VerboseBatch { return &VerboseBatch{ MintingBatch: b, @@ -997,15 +1138,15 @@ func listBatches(ctx context.Context, batchStore MintingStore, } }, ) - } - // Return the batches without any extra asset group info. - if !params.Verbose { - return verboseBatches, nil + return batches, nil } - for _, batch := range verboseBatches { - currentBatch := batch + // Formulate verbose batches from the sorted batches. + verboseBatches := make([]*VerboseBatch, len(sortedBatches)) + + for idx := range sortedBatches { + currentBatch := sortedBatches[idx] // The batch must be pending, funded, and have seedlings for us // to show pending asset group information. @@ -1019,81 +1160,96 @@ func listBatches(ctx context.Context, batchStore MintingStore, default: } - // Filter the batch seedlings to only consider those that will - // become grouped assets. If there are no such seedlings, then - // there is no extra information to show. - groupSeedlings, _ := filterSeedlingsWithGroup( - currentBatch.Seedlings, - ) - if len(groupSeedlings) == 0 { - continue + verboseBatch, err := newVerboseBatch(currentBatch, genBuilder) + if err != nil { + return nil, err } - // Before we can build the group key requests for each seedling, - // we must fetch the genesis point and anchor index for the - // batch. - anchorOutputIndex := extractAnchorOutputIndex( - currentBatch.GenesisPacket, - ) - genesisPoint := extractGenesisOutpoint( - currentBatch.GenesisPacket.Pkt.UnsignedTx, - ) + verboseBatches[idx] = verboseBatch + } - // Construct the group key requests and group virtual TXs for - // each seedling. With these we can verify provided asset group - // witnesses, or attempt to derive asset group witnesses if - // needed. - groupReqs, genTXs, err := buildGroupReqs( - genesisPoint, anchorOutputIndex, genBuilder, - groupSeedlings, - ) - if err != nil { - return nil, fmt.Errorf("unable to build group "+ - "requests: %w", err) - } + return verboseBatches, nil +} - if len(groupReqs) != len(genTXs) { - return nil, fmt.Errorf("mismatched number of group " + - "requests and virtual TXs") - } +// newVerboseBatch constructs a new verbose batch from a given minting batch. +// The verbose batch includes extra information about the asset group, if any. +func newVerboseBatch(currentBatch *MintingBatch, + genBuilder asset.GenesisTxBuilder) (*VerboseBatch, error) { - // Copy existing seedlngs into the unsealed seedling map; we'll - // clear the batch seedlings after adding group information. - currentBatch.UnsealedSeedlings = make( - map[string]*UnsealedSeedling, - len(currentBatch.Seedlings), - ) - for k, v := range currentBatch.Seedlings { - currentBatch.UnsealedSeedlings[k] = &UnsealedSeedling{ - Seedling: v, - PendingAssetGroup: nil, - } - } + verboseBatch := &VerboseBatch{ + MintingBatch: currentBatch.Copy(), + } - // Match each group key request and group virtual TX with the - // corresponding seedling. - for i := 0; i < len(groupReqs); i++ { - seedlingName := groupReqs[i].NewAsset.Genesis.Tag - seedling, ok := currentBatch. - UnsealedSeedlings[seedlingName] - if !ok { - return nil, fmt.Errorf("unable to find "+ - "seedling with tag matching asset "+ - "group: %s", seedlingName) - } + // Filter the batch seedlings to only consider those that will become + // grouped assets. If there are no such seedlings, then there is no + // extra information to add. + groupSeedlings, _ := filterSeedlingsWithGroup( + currentBatch.Seedlings, + ) + if len(groupSeedlings) == 0 { + return verboseBatch, nil + } - seedling.PendingAssetGroup = &PendingAssetGroup{ - GroupKeyRequest: groupReqs[i], - GroupVirtualTx: genTXs[i], - } + // Before we can build the group key requests for each seedling, we must + // fetch the genesis point and anchor index for the batch. + anchorOutputIndex := extractAnchorOutputIndex( + currentBatch.GenesisPacket, + ) + genesisPoint := extractGenesisOutpoint( + currentBatch.GenesisPacket.Pkt.UnsignedTx, + ) + + // Construct the group key requests and group virtual TXs for each + // seedling. With these we can verify provided asset group witnesses, or + // attempt to derive asset group witnesses if needed. + groupReqs, genTXs, err := buildGroupReqs( + genesisPoint, anchorOutputIndex, genBuilder, groupSeedlings, + ) + if err != nil { + return nil, fmt.Errorf("unable to build group requests: %w", + err) + } + + if len(groupReqs) != len(genTXs) { + return nil, fmt.Errorf("mismatched number of group requests " + + "and virtual TXs") + } + + // Copy existing seedlings into the unsealed seedling map; we'll clear + // the batch seedlings after adding group information. + verboseBatch.UnsealedSeedlings = make( + map[string]*UnsealedSeedling, + len(currentBatch.Seedlings), + ) + for k, v := range currentBatch.Seedlings { + verboseBatch.UnsealedSeedlings[k] = &UnsealedSeedling{ + Seedling: v, + PendingAssetGroup: nil, + } + } + + // Match each group key request and group virtual TX with the + // corresponding seedling. + for i := 0; i < len(groupReqs); i++ { + seedlingName := groupReqs[i].NewAsset.Genesis.Tag + seedling, ok := verboseBatch. + UnsealedSeedlings[seedlingName] + if !ok { + return nil, fmt.Errorf("unable to find seedling with "+ + "tag matching asset group: %s", seedlingName) } - // Clear the original batch seedlings so each asset is only - // represented once. - currentBatch.Seedlings = nil + seedling.PendingAssetGroup = &PendingAssetGroup{ + GroupKeyRequest: groupReqs[i], + GroupVirtualTx: genTXs[i], + } } - return verboseBatches, nil + // Clear the original batch seedlings so each asset is only represented + // once. + verboseBatch.Seedlings = nil + + return verboseBatch, nil } // canCancelBatch returns a batch key if the planter is in a state where a batch @@ -1312,7 +1468,19 @@ func (c *ChainPlanter) gardener() { break } - req.Resolve(c.pendingBatch) + // Formulate a verbose batch to return to the + // caller. + verboseBatch, err := newVerboseBatch( + c.pendingBatch, c.cfg.GenTxBuilder, + ) + if err != nil { + req.Error(err) + break + } + + req.Resolve(&FundBatchResp{ + Batch: verboseBatch, + }) case reqTypeSealBatch: if c.pendingBatch == nil { @@ -1636,11 +1804,14 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, params SealParams, switch { case ok: // Set the provided witness; it will be validated below. + subtreeRoot := groupReq.CustomTapscriptRoot groupKey = &asset.GroupKey{ - RawKey: groupReq.RawKey, - GroupPubKey: genTX.TweakedKey, - TapscriptRoot: groupReq.TapscriptRoot, - Witness: groupWitness.Witness, + Version: groupReq.Version, + RawKey: groupReq.RawKey, + GroupPubKey: genTX.TweakedKey, + TapscriptRoot: groupReq.TapscriptRoot, + CustomTapscriptRoot: subtreeRoot, + Witness: groupWitness.Witness, } default: @@ -1676,7 +1847,7 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, params SealParams, groupedAsset, nil, nil, noProofLookup, ) if err != nil { - return nil, fmt.Errorf("unable to verify asset group"+ + return nil, fmt.Errorf("unable to verify asset group "+ "witness: %s, %w", reqAssetID.String(), err) } @@ -1821,8 +1992,8 @@ func (c *ChainPlanter) ListBatches(params ListBatchesParams) ([]*VerboseBatch, // FundBatch sends a signal to the planter to fund the current batch, or create // a funded batch. -func (c *ChainPlanter) FundBatch(params FundParams) (*MintingBatch, error) { - req := newStateParamReq[*MintingBatch](reqTypeFundBatch, params) +func (c *ChainPlanter) FundBatch(params FundParams) (*FundBatchResp, error) { + req := newStateParamReq[*FundBatchResp](reqTypeFundBatch, params) if !fn.SendOrQuit[stateRequest](c.stateReqs, req, c.Quit) { return nil, fmt.Errorf("chain planter shutting down") diff --git a/tapgarden/planter_test.go b/tapgarden/planter_test.go index e20102350..353f07d8e 100644 --- a/tapgarden/planter_test.go +++ b/tapgarden/planter_test.go @@ -455,15 +455,18 @@ func (t *mintingTestHarness) fundBatch(wg *sync.WaitGroup, fundParams = *params } - fundedBatch, fundErr := t.planter.FundBatch( - fundParams, - ) - resp := &FundBatchResp{ - Batch: fundedBatch, - Err: fundErr, + fundBatchResp, fundErr := t.planter.FundBatch(fundParams) + if fundErr != nil { + respChan <- &FundBatchResp{ + Err: fundErr, + } + + return } - respChan <- resp + respChan <- &FundBatchResp{ + Batch: fundBatchResp.Batch.MintingBatch, + } }() } diff --git a/tapgarden/seedling.go b/tapgarden/seedling.go index 974beb3d5..b52109191 100644 --- a/tapgarden/seedling.go +++ b/tapgarden/seedling.go @@ -6,6 +6,7 @@ import ( "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/fn" "github.com/lightninglabs/taproot-assets/proof" "github.com/lightningnetwork/lnd/keychain" ) @@ -112,8 +113,14 @@ type Seedling struct { // all script spend conditions for the group key. Instead of spending an // asset, these scripts are used to define witnesses more complex than // a Schnorr signature for reissuing assets. A group key with an empty - // Tapscript root can only authorize reissuance with a signature. + // Tapscript root can only authorize re-issuance with a signature. GroupTapscriptRoot []byte + + // ExternalKey is an optional field that allows specifying an external + // signing key for the group virtual transaction during minting. This + // key enables signing operations to be performed externally, outside + // the daemon. + ExternalKey fn.Option[asset.ExternalKey] } // validateFields attempts to validate the set of input fields for the passed diff --git a/taprpc/marshal.go b/taprpc/marshal.go index c8cff35ce..0d7a0c271 100644 --- a/taprpc/marshal.go +++ b/taprpc/marshal.go @@ -4,11 +4,13 @@ import ( "bytes" "context" "crypto/sha256" + "encoding/binary" "fmt" "github.com/btcsuite/btcd/blockchain" "github.com/btcsuite/btcd/btcec/v2" "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcutil/hdkeychain" "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/taproot-assets/asset" @@ -19,6 +21,7 @@ import ( "github.com/lightninglabs/taproot-assets/rfqmsg" "github.com/lightninglabs/taproot-assets/taprpc/rfqrpc" "github.com/lightningnetwork/lnd/keychain" + "github.com/lightningnetwork/lnd/lntest" ) // Shorthand for the asset transfer output proof delivery status enum. @@ -292,8 +295,19 @@ func UnmarshalGroupKeyRequest(req *GroupKeyRequest) (*asset.GroupKeyRequest, return nil, err } + var externalKey fn.Option[asset.ExternalKey] + if req.ExternalKey != nil { + key, err := UnmarshalExternalKey(req.ExternalKey) + if err != nil { + return nil, err + } + + externalKey = fn.Some(key) + } + return &asset.GroupKeyRequest{ RawKey: rawKey, + ExternalKey: externalKey, AnchorGen: *anchorGen, TapscriptRoot: req.TapscriptRoot, NewAsset: &newAsset, @@ -316,13 +330,96 @@ func MarshalGroupKeyRequest(req *asset.GroupKeyRequest) (*GroupKeyRequest, return nil, err } + // Marshal the external key into the RPC format. + externalKey := fn.MapOptionZ(req.ExternalKey, MarshalExternalKey) + + // Marshal raw key into RPC format. + // + // We only need to marshal the raw key if the external key is not set. + var rawKey *KeyDescriptor + if req.ExternalKey.IsNone() { + rawKey = MarshalKeyDescriptor(req.RawKey) + } + return &GroupKeyRequest{ - RawKey: MarshalKeyDescriptor(req.RawKey), + RawKey: rawKey, AnchorGenesis: MarshalGenesisInfo( &req.AnchorGen, req.NewAsset.Type, ), TapscriptRoot: req.TapscriptRoot, NewAsset: assetBuf.Bytes(), + ExternalKey: externalKey, + }, nil +} + +// MarshalExternalKey marshals an external key into its RPC counterpart. +func MarshalExternalKey(key asset.ExternalKey) *ExternalKey { + var masterFingerprint [4]byte + binary.LittleEndian.PutUint32( + masterFingerprint[:], key.MasterFingerprint, + ) + + // The first three elements of the derivation path are hardened, so to + // format we need to subtract the hardened key offset again. + path := key.DerivationPath + purpose := path[0] - hdkeychain.HardenedKeyStart + coinType := path[1] - hdkeychain.HardenedKeyStart + account := path[2] - hdkeychain.HardenedKeyStart + internalExternalAddr := path[3] + addrIndex := path[4] + + derivationPathStr := fmt.Sprintf("m/%d'/%d'/%d'/%d/%d", purpose, + coinType, account, internalExternalAddr, addrIndex) + + return &ExternalKey{ + Xpub: key.XPub.String(), + MasterFingerprint: masterFingerprint[:], + DerivationPath: derivationPathStr, + } +} + +// UnmarshalExternalKey parses an external key from the RPC variant. +func UnmarshalExternalKey(rpcKey *ExternalKey) (asset.ExternalKey, error) { + if rpcKey == nil { + return asset.ExternalKey{}, fmt.Errorf("unexpected nil RPC " + + "external key") + } + + // Parse xpub. + xpub, err := hdkeychain.NewKeyFromString(rpcKey.Xpub) + if err != nil { + return asset.ExternalKey{}, err + } + + // Parse derivation path. + path, err := lntest.ParseDerivationPath(rpcKey.DerivationPath) + if err != nil { + return asset.ExternalKey{}, err + } + + // We assume the first three elements of the derivation path are + // hardened, so we need to add the hardened key offset. + for i := 0; i < 3; i++ { + path[i] += hdkeychain.HardenedKeyStart + } + + // Parse master fingerprint. + var masterFingerprint uint32 + if len(rpcKey.MasterFingerprint) > 0 { + if len(rpcKey.MasterFingerprint) != 4 { + return asset.ExternalKey{}, fmt.Errorf("master " + + "fingerprint must be 4 bytes") + } + + masterFingerprint = binary.LittleEndian.Uint32( + rpcKey.MasterFingerprint, + ) + } + + return asset.ExternalKey{ + XPub: *xpub, + MasterFingerprint: masterFingerprint, + DerivationPath: path, }, nil } diff --git a/taprpc/mintrpc/mint.pb.go b/taprpc/mintrpc/mint.pb.go index b4eabf407..187926719 100644 --- a/taprpc/mintrpc/mint.pb.go +++ b/taprpc/mintrpc/mint.pb.go @@ -245,6 +245,8 @@ type UnsealedAsset struct { GroupKeyRequest *taprpc.GroupKeyRequest `protobuf:"bytes,2,opt,name=group_key_request,json=groupKeyRequest,proto3" json:"group_key_request,omitempty"` // The group virtual transaction for the asset. GroupVirtualTx *taprpc.GroupVirtualTx `protobuf:"bytes,3,opt,name=group_virtual_tx,json=groupVirtualTx,proto3" json:"group_virtual_tx,omitempty"` + // The byte serialized PSBT equivalent of the group virtual transaction. + GroupVirtualPsbt string `protobuf:"bytes,4,opt,name=group_virtual_psbt,json=groupVirtualPsbt,proto3" json:"group_virtual_psbt,omitempty"` } func (x *UnsealedAsset) Reset() { @@ -300,6 +302,13 @@ func (x *UnsealedAsset) GetGroupVirtualTx() *taprpc.GroupVirtualTx { return nil } +func (x *UnsealedAsset) GetGroupVirtualPsbt() string { + if x != nil { + return x.GroupVirtualPsbt + } + return "" +} + type MintAsset struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -330,10 +339,19 @@ type MintAsset struct { GroupAnchor string `protobuf:"bytes,9,opt,name=group_anchor,json=groupAnchor,proto3" json:"group_anchor,omitempty"` // The optional key that will be used as the internal key for an asset group // created with this asset. + // + // If this field is set then external_group_key must be unset, and vice versa. GroupInternalKey *taprpc.KeyDescriptor `protobuf:"bytes,10,opt,name=group_internal_key,json=groupInternalKey,proto3" json:"group_internal_key,omitempty"` - // The optional root of a tapscript tree that will be used when constructing a - // new asset group key. This enables future issuance authorized with a script - // witness. + // An optional root of a Tapscript tree used when constructing a new asset + // group key. This allows for future asset issuance authorized using a + // script witness. + // + // If an external group key is provided, the V1 scheme for group key script + // construction will be used, which supports PSBT signing. In this scheme, + // the user-supplied Tapscript root is extended by two levels of Tapscript + // siblings that commit to the group anchor's asset ID. As a result, the + // provided Tapscript root becomes a branch within a larger Tapscript tree, + // and the final Tapscript root will differ from the one specified here. GroupTapscriptRoot []byte `protobuf:"bytes,11,opt,name=group_tapscript_root,json=groupTapscriptRoot,proto3" json:"group_tapscript_root,omitempty"` // The optional script key to use for the new asset. If no script key is given, // a BIP-86 key will be derived from the underlying wallet. @@ -349,6 +367,13 @@ type MintAsset struct { // is encoded in the MetaData field as a JSON field, therefore it is only // compatible with assets that have a JSON MetaData field. DecimalDisplay uint32 `protobuf:"varint,13,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"` + // The external group key is an optional field that allows specifying an + // external signing key for the group virtual transaction during minting. + // This key enables signing operations to be performed externally, outside + // the daemon. + // + // If this field is set then group_internal_key must be unset, and vice versa. + ExternalGroupKey *taprpc.ExternalKey `protobuf:"bytes,14,opt,name=external_group_key,json=externalGroupKey,proto3" json:"external_group_key,omitempty"` } func (x *MintAsset) Reset() { @@ -474,6 +499,13 @@ func (x *MintAsset) GetDecimalDisplay() uint32 { return 0 } +func (x *MintAsset) GetExternalGroupKey() *taprpc.ExternalKey { + if x != nil { + return x.ExternalGroupKey + } + return nil +} + type MintAssetRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -858,7 +890,7 @@ type FundBatchResponse struct { unknownFields protoimpl.UnknownFields // The funded batch. - Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + Batch *VerboseBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` } func (x *FundBatchResponse) Reset() { @@ -893,7 +925,7 @@ func (*FundBatchResponse) Descriptor() ([]byte, []int) { return file_mintrpc_mint_proto_rawDescGZIP(), []int{8} } -func (x *FundBatchResponse) GetBatch() *MintingBatch { +func (x *FundBatchResponse) GetBatch() *VerboseBatch { if x != nil { return x.Batch } @@ -1557,7 +1589,7 @@ var file_mintrpc_mint_proto_rawDesc = []byte{ 0x74, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x22, 0xc3, 0x01, 0x0a, 0x0d, 0x55, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, + 0x4b, 0x65, 0x79, 0x22, 0xf1, 0x01, 0x0a, 0x0d, 0x55, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x2b, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, 0x73, 0x73, @@ -1569,108 +1601,86 @@ var file_mintrpc_mint_proto_rawDesc = []byte{ 0x5f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x74, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x54, 0x78, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x54, 0x78, 0x22, 0xb9, 0x04, 0x0a, 0x09, 0x4d, 0x69, - 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x02, 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, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, - 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x65, 0x77, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, - 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x6e, - 0x65, 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x23, - 0x0a, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, - 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, - 0x12, 0x21, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, - 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e, 0x63, - 0x68, 0x6f, 0x72, 0x12, 0x43, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x5f, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, - 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x54, 0x61, 0x70, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, - 0x79, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x0a, 0x0f, - 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, - 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, - 0x73, 0x70, 0x6c, 0x61, 0x79, 0x22, 0x63, 0x0a, 0x10, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x05, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, 0x6f, - 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x0a, 0x11, 0x4d, 0x69, - 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x3a, 0x0a, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x0c, 0x70, - 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, 0x83, 0x02, 0x0a, 0x0c, - 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1b, 0x0a, 0x09, - 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, - 0x63, 0x68, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, - 0x61, 0x74, 0x63, 0x68, 0x54, 0x78, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, - 0x61, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, - 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, - 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x68, 0x69, 0x6e, 0x74, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x48, 0x69, - 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x70, 0x73, 0x62, 0x74, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x50, 0x73, 0x62, - 0x74, 0x22, 0x7c, 0x0a, 0x0c, 0x56, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x42, 0x61, 0x74, 0x63, - 0x68, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, - 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x12, 0x3f, - 0x0a, 0x0f, 0x75, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x55, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, - 0x0e, 0x75, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, - 0xcc, 0x01, 0x0a, 0x10, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, - 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x66, - 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x66, - 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x74, - 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, - 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x46, 0x75, 0x6c, 0x6c, - 0x54, 0x72, 0x65, 0x65, 0x48, 0x00, 0x52, 0x08, 0x66, 0x75, 0x6c, 0x6c, 0x54, 0x72, 0x65, 0x65, - 0x12, 0x2b, 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x42, 0x72, 0x61, - 0x6e, 0x63, 0x68, 0x48, 0x00, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x42, 0x0f, 0x0a, - 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x22, 0x40, - 0x0a, 0x11, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, - 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, - 0x22, 0x78, 0x0a, 0x10, 0x53, 0x65, 0x61, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, - 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x0f, 0x67, - 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x40, 0x0a, 0x11, 0x53, 0x65, - 0x61, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, - 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, - 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x22, 0xd0, 0x01, 0x0a, - 0x14, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, + 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x54, 0x78, 0x12, 0x2c, 0x0a, 0x12, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x5f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x69, 0x72, 0x74, + 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x22, 0xfc, 0x04, 0x0a, 0x09, 0x4d, 0x69, 0x6e, 0x74, + 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, + 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, + 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, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x09, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x65, 0x77, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x5f, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x6e, 0x65, 0x77, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x23, 0x0a, 0x0d, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, + 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x21, + 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e, 0x63, 0x68, 0x6f, + 0x72, 0x12, 0x43, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, + 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x54, 0x61, 0x70, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, + 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, + 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, + 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, + 0x6c, 0x61, 0x79, 0x12, 0x41, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x22, 0x63, 0x0a, 0x10, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, + 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, 0x69, 0x6e, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, + 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x0a, 0x11, 0x4d, + 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x3a, 0x0a, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x61, 0x74, 0x63, + 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x0c, + 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, 0x83, 0x02, 0x0a, + 0x0c, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1b, 0x0a, + 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, + 0x74, 0x63, 0x68, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x62, 0x61, 0x74, 0x63, 0x68, 0x54, 0x78, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x05, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, + 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x06, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, + 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x41, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x68, 0x69, 0x6e, + 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x48, + 0x69, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x70, 0x73, 0x62, + 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x50, 0x73, + 0x62, 0x74, 0x22, 0x7c, 0x0a, 0x0c, 0x56, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x42, 0x61, 0x74, + 0x63, 0x68, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, + 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x12, + 0x3f, 0x0a, 0x0f, 0x75, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x52, 0x0e, 0x75, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, + 0x22, 0xcc, 0x01, 0x0a, 0x10, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, @@ -1683,95 +1693,125 @@ var file_mintrpc_mint_proto_rawDesc = []byte{ 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x48, 0x00, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x42, 0x0f, 0x0a, 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x22, - 0x44, 0x0a, 0x15, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, - 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, - 0x62, 0x61, 0x74, 0x63, 0x68, 0x22, 0x14, 0x0a, 0x12, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x32, 0x0a, 0x13, 0x43, - 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, 0x22, - 0x7b, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4b, - 0x65, 0x79, 0x12, 0x24, 0x0a, 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, 0x5f, - 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x61, 0x74, - 0x63, 0x68, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x62, - 0x6f, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, - 0x73, 0x65, 0x42, 0x08, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x44, 0x0a, 0x11, - 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, - 0x62, 0x6f, 0x73, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, - 0x65, 0x73, 0x22, 0x43, 0x0a, 0x1a, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x4d, - 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa2, 0x01, 0x0a, 0x09, 0x4d, 0x69, 0x6e, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, - 0x61, 0x6d, 0x70, 0x12, 0x34, 0x0a, 0x0b, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x62, - 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, - 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, + 0x40, 0x0a, 0x11, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, + 0x72, 0x62, 0x6f, 0x73, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, + 0x68, 0x22, 0x78, 0x0a, 0x10, 0x53, 0x65, 0x61, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x0f, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x52, 0x0e, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x40, 0x0a, 0x11, 0x53, + 0x65, 0x61, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, + 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x22, 0xd0, 0x01, + 0x0a, 0x14, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, + 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x66, 0x75, 0x6c, 0x6c, + 0x5f, 0x74, 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x74, 0x61, + 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x46, 0x75, + 0x6c, 0x6c, 0x54, 0x72, 0x65, 0x65, 0x48, 0x00, 0x52, 0x08, 0x66, 0x75, 0x6c, 0x6c, 0x54, 0x72, + 0x65, 0x65, 0x12, 0x2b, 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x42, + 0x72, 0x61, 0x6e, 0x63, 0x68, 0x48, 0x00, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x42, + 0x0f, 0x0a, 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, + 0x22, 0x44, 0x0a, 0x15, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, + 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, - 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2a, 0x88, 0x02, 0x0a, - 0x0a, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x17, 0x0a, 0x13, 0x42, - 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, - 0x57, 0x4e, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, - 0x41, 0x54, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x16, 0x0a, - 0x12, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x52, 0x4f, - 0x5a, 0x45, 0x4e, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, - 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x54, 0x45, 0x44, 0x10, 0x03, - 0x12, 0x19, 0x0a, 0x15, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, - 0x42, 0x52, 0x4f, 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x10, 0x04, 0x12, 0x19, 0x0a, 0x15, 0x42, - 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x49, - 0x52, 0x4d, 0x45, 0x44, 0x10, 0x05, 0x12, 0x19, 0x0a, 0x15, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, - 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x49, 0x4e, 0x41, 0x4c, 0x49, 0x5a, 0x45, 0x44, 0x10, - 0x06, 0x12, 0x22, 0x0a, 0x1e, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, - 0x5f, 0x53, 0x45, 0x45, 0x44, 0x4c, 0x49, 0x4e, 0x47, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, - 0x4c, 0x45, 0x44, 0x10, 0x07, 0x12, 0x20, 0x0a, 0x1c, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, - 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x50, 0x52, 0x4f, 0x55, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, - 0x45, 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x08, 0x32, 0x84, 0x04, 0x0a, 0x04, 0x4d, 0x69, 0x6e, 0x74, - 0x12, 0x42, 0x0a, 0x09, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x19, 0x2e, - 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, - 0x68, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, - 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, - 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x53, 0x65, 0x61, 0x6c, - 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x53, 0x65, 0x61, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x61, 0x6c, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x0d, - 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1d, 0x2e, + 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x22, 0x14, 0x0a, 0x12, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, + 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x32, 0x0a, 0x13, + 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, + 0x22, 0x7b, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, + 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, + 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x61, + 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, + 0x62, 0x6f, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x65, 0x72, 0x62, + 0x6f, 0x73, 0x65, 0x42, 0x08, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x44, 0x0a, + 0x11, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, + 0x72, 0x62, 0x6f, 0x73, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63, + 0x68, 0x65, 0x73, 0x22, 0x43, 0x0a, 0x1a, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa2, 0x01, 0x0a, 0x09, 0x4d, 0x69, 0x6e, + 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x12, 0x34, 0x0a, 0x0b, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x6d, 0x69, 0x6e, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0a, + 0x62, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, + 0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x52, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2a, 0x88, 0x02, + 0x0a, 0x0a, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x17, 0x0a, 0x13, + 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, + 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x16, + 0x0a, 0x12, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x52, + 0x4f, 0x5a, 0x45, 0x4e, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x54, 0x45, 0x44, 0x10, + 0x03, 0x12, 0x19, 0x0a, 0x15, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x42, 0x52, 0x4f, 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x10, 0x04, 0x12, 0x19, 0x0a, 0x15, + 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x46, + 0x49, 0x52, 0x4d, 0x45, 0x44, 0x10, 0x05, 0x12, 0x19, 0x0a, 0x15, 0x42, 0x41, 0x54, 0x43, 0x48, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x49, 0x4e, 0x41, 0x4c, 0x49, 0x5a, 0x45, 0x44, + 0x10, 0x06, 0x12, 0x22, 0x0a, 0x1e, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x45, 0x5f, 0x53, 0x45, 0x45, 0x44, 0x4c, 0x49, 0x4e, 0x47, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, + 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x07, 0x12, 0x20, 0x0a, 0x1c, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x50, 0x52, 0x4f, 0x55, 0x54, 0x5f, 0x43, 0x41, 0x4e, + 0x43, 0x45, 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x08, 0x32, 0x84, 0x04, 0x0a, 0x04, 0x4d, 0x69, 0x6e, + 0x74, 0x12, 0x42, 0x0a, 0x09, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x19, + 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, + 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, + 0x63, 0x68, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, + 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, + 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x53, 0x65, 0x61, + 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x53, 0x65, 0x61, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x61, 0x6c, + 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, + 0x0d, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1d, + 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, - 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, - 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0b, - 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1b, 0x2e, 0x6d, 0x69, - 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, - 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, - 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x13, - 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, - 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x42, 0x38, - 0x5a, 0x36, 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, - 0x2f, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, + 0x0b, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1b, 0x2e, 0x6d, + 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, + 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x42, + 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, + 0x13, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, + 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6d, 0x69, 0x6e, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x42, + 0x38, 0x5a, 0x36, 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, 0x2f, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, } var ( @@ -1816,9 +1856,10 @@ var file_mintrpc_mint_proto_goTypes = []interface{}{ (*taprpc.ScriptKey)(nil), // 24: taprpc.ScriptKey (*taprpc.GroupKeyRequest)(nil), // 25: taprpc.GroupKeyRequest (*taprpc.GroupVirtualTx)(nil), // 26: taprpc.GroupVirtualTx - (*taprpc.TapscriptFullTree)(nil), // 27: taprpc.TapscriptFullTree - (*taprpc.TapBranch)(nil), // 28: taprpc.TapBranch - (*taprpc.GroupWitness)(nil), // 29: taprpc.GroupWitness + (*taprpc.ExternalKey)(nil), // 27: taprpc.ExternalKey + (*taprpc.TapscriptFullTree)(nil), // 28: taprpc.TapscriptFullTree + (*taprpc.TapBranch)(nil), // 29: taprpc.TapBranch + (*taprpc.GroupWitness)(nil), // 30: taprpc.GroupWitness } var file_mintrpc_mint_proto_depIdxs = []int32{ 20, // 0: mintrpc.PendingAsset.asset_version:type_name -> taprpc.AssetVersion @@ -1834,42 +1875,43 @@ var file_mintrpc_mint_proto_depIdxs = []int32{ 22, // 10: mintrpc.MintAsset.asset_meta:type_name -> taprpc.AssetMeta 23, // 11: mintrpc.MintAsset.group_internal_key:type_name -> taprpc.KeyDescriptor 24, // 12: mintrpc.MintAsset.script_key:type_name -> taprpc.ScriptKey - 3, // 13: mintrpc.MintAssetRequest.asset:type_name -> mintrpc.MintAsset - 6, // 14: mintrpc.MintAssetResponse.pending_batch:type_name -> mintrpc.MintingBatch - 0, // 15: mintrpc.MintingBatch.state:type_name -> mintrpc.BatchState - 1, // 16: mintrpc.MintingBatch.assets:type_name -> mintrpc.PendingAsset - 6, // 17: mintrpc.VerboseBatch.batch:type_name -> mintrpc.MintingBatch - 2, // 18: mintrpc.VerboseBatch.unsealed_assets:type_name -> mintrpc.UnsealedAsset - 27, // 19: mintrpc.FundBatchRequest.full_tree:type_name -> taprpc.TapscriptFullTree - 28, // 20: mintrpc.FundBatchRequest.branch:type_name -> taprpc.TapBranch - 6, // 21: mintrpc.FundBatchResponse.batch:type_name -> mintrpc.MintingBatch - 29, // 22: mintrpc.SealBatchRequest.group_witnesses:type_name -> taprpc.GroupWitness - 6, // 23: mintrpc.SealBatchResponse.batch:type_name -> mintrpc.MintingBatch - 27, // 24: mintrpc.FinalizeBatchRequest.full_tree:type_name -> taprpc.TapscriptFullTree - 28, // 25: mintrpc.FinalizeBatchRequest.branch:type_name -> taprpc.TapBranch - 6, // 26: mintrpc.FinalizeBatchResponse.batch:type_name -> mintrpc.MintingBatch - 7, // 27: mintrpc.ListBatchResponse.batches:type_name -> mintrpc.VerboseBatch - 0, // 28: mintrpc.MintEvent.batch_state:type_name -> mintrpc.BatchState - 6, // 29: mintrpc.MintEvent.batch:type_name -> mintrpc.MintingBatch - 4, // 30: mintrpc.Mint.MintAsset:input_type -> mintrpc.MintAssetRequest - 8, // 31: mintrpc.Mint.FundBatch:input_type -> mintrpc.FundBatchRequest - 10, // 32: mintrpc.Mint.SealBatch:input_type -> mintrpc.SealBatchRequest - 12, // 33: mintrpc.Mint.FinalizeBatch:input_type -> mintrpc.FinalizeBatchRequest - 14, // 34: mintrpc.Mint.CancelBatch:input_type -> mintrpc.CancelBatchRequest - 16, // 35: mintrpc.Mint.ListBatches:input_type -> mintrpc.ListBatchRequest - 18, // 36: mintrpc.Mint.SubscribeMintEvents:input_type -> mintrpc.SubscribeMintEventsRequest - 5, // 37: mintrpc.Mint.MintAsset:output_type -> mintrpc.MintAssetResponse - 9, // 38: mintrpc.Mint.FundBatch:output_type -> mintrpc.FundBatchResponse - 11, // 39: mintrpc.Mint.SealBatch:output_type -> mintrpc.SealBatchResponse - 13, // 40: mintrpc.Mint.FinalizeBatch:output_type -> mintrpc.FinalizeBatchResponse - 15, // 41: mintrpc.Mint.CancelBatch:output_type -> mintrpc.CancelBatchResponse - 17, // 42: mintrpc.Mint.ListBatches:output_type -> mintrpc.ListBatchResponse - 19, // 43: mintrpc.Mint.SubscribeMintEvents:output_type -> mintrpc.MintEvent - 37, // [37:44] is the sub-list for method output_type - 30, // [30:37] is the sub-list for method input_type - 30, // [30:30] is the sub-list for extension type_name - 30, // [30:30] is the sub-list for extension extendee - 0, // [0:30] is the sub-list for field type_name + 27, // 13: mintrpc.MintAsset.external_group_key:type_name -> taprpc.ExternalKey + 3, // 14: mintrpc.MintAssetRequest.asset:type_name -> mintrpc.MintAsset + 6, // 15: mintrpc.MintAssetResponse.pending_batch:type_name -> mintrpc.MintingBatch + 0, // 16: mintrpc.MintingBatch.state:type_name -> mintrpc.BatchState + 1, // 17: mintrpc.MintingBatch.assets:type_name -> mintrpc.PendingAsset + 6, // 18: mintrpc.VerboseBatch.batch:type_name -> mintrpc.MintingBatch + 2, // 19: mintrpc.VerboseBatch.unsealed_assets:type_name -> mintrpc.UnsealedAsset + 28, // 20: mintrpc.FundBatchRequest.full_tree:type_name -> taprpc.TapscriptFullTree + 29, // 21: mintrpc.FundBatchRequest.branch:type_name -> taprpc.TapBranch + 7, // 22: mintrpc.FundBatchResponse.batch:type_name -> mintrpc.VerboseBatch + 30, // 23: mintrpc.SealBatchRequest.group_witnesses:type_name -> taprpc.GroupWitness + 6, // 24: mintrpc.SealBatchResponse.batch:type_name -> mintrpc.MintingBatch + 28, // 25: mintrpc.FinalizeBatchRequest.full_tree:type_name -> taprpc.TapscriptFullTree + 29, // 26: mintrpc.FinalizeBatchRequest.branch:type_name -> taprpc.TapBranch + 6, // 27: mintrpc.FinalizeBatchResponse.batch:type_name -> mintrpc.MintingBatch + 7, // 28: mintrpc.ListBatchResponse.batches:type_name -> mintrpc.VerboseBatch + 0, // 29: mintrpc.MintEvent.batch_state:type_name -> mintrpc.BatchState + 6, // 30: mintrpc.MintEvent.batch:type_name -> mintrpc.MintingBatch + 4, // 31: mintrpc.Mint.MintAsset:input_type -> mintrpc.MintAssetRequest + 8, // 32: mintrpc.Mint.FundBatch:input_type -> mintrpc.FundBatchRequest + 10, // 33: mintrpc.Mint.SealBatch:input_type -> mintrpc.SealBatchRequest + 12, // 34: mintrpc.Mint.FinalizeBatch:input_type -> mintrpc.FinalizeBatchRequest + 14, // 35: mintrpc.Mint.CancelBatch:input_type -> mintrpc.CancelBatchRequest + 16, // 36: mintrpc.Mint.ListBatches:input_type -> mintrpc.ListBatchRequest + 18, // 37: mintrpc.Mint.SubscribeMintEvents:input_type -> mintrpc.SubscribeMintEventsRequest + 5, // 38: mintrpc.Mint.MintAsset:output_type -> mintrpc.MintAssetResponse + 9, // 39: mintrpc.Mint.FundBatch:output_type -> mintrpc.FundBatchResponse + 11, // 40: mintrpc.Mint.SealBatch:output_type -> mintrpc.SealBatchResponse + 13, // 41: mintrpc.Mint.FinalizeBatch:output_type -> mintrpc.FinalizeBatchResponse + 15, // 42: mintrpc.Mint.CancelBatch:output_type -> mintrpc.CancelBatchResponse + 17, // 43: mintrpc.Mint.ListBatches:output_type -> mintrpc.ListBatchResponse + 19, // 44: mintrpc.Mint.SubscribeMintEvents:output_type -> mintrpc.MintEvent + 38, // [38:45] is the sub-list for method output_type + 31, // [31:38] is the sub-list for method input_type + 31, // [31:31] is the sub-list for extension type_name + 31, // [31:31] is the sub-list for extension extendee + 0, // [0:31] is the sub-list for field type_name } func init() { file_mintrpc_mint_proto_init() } diff --git a/taprpc/mintrpc/mint.proto b/taprpc/mintrpc/mint.proto index abc446bf7..1d395ea0a 100644 --- a/taprpc/mintrpc/mint.proto +++ b/taprpc/mintrpc/mint.proto @@ -124,6 +124,9 @@ message UnsealedAsset { // The group virtual transaction for the asset. taprpc.GroupVirtualTx group_virtual_tx = 3; + + // The byte serialized PSBT equivalent of the group virtual transaction. + string group_virtual_psbt = 4; } message MintAsset { @@ -172,13 +175,22 @@ message MintAsset { /* The optional key that will be used as the internal key for an asset group created with this asset. + + If this field is set then external_group_key must be unset, and vice versa. */ taprpc.KeyDescriptor group_internal_key = 10; /* - The optional root of a tapscript tree that will be used when constructing a - new asset group key. This enables future issuance authorized with a script - witness. + An optional root of a Tapscript tree used when constructing a new asset + group key. This allows for future asset issuance authorized using a + script witness. + + If an external group key is provided, the V1 scheme for group key script + construction will be used, which supports PSBT signing. In this scheme, + the user-supplied Tapscript root is extended by two levels of Tapscript + siblings that commit to the group anchor's asset ID. As a result, the + provided Tapscript root becomes a branch within a larger Tapscript tree, + and the final Tapscript root will differ from the one specified here. */ bytes group_tapscript_root = 11; @@ -201,6 +213,16 @@ message MintAsset { compatible with assets that have a JSON MetaData field. */ uint32 decimal_display = 13; + + /* + The external group key is an optional field that allows specifying an + external signing key for the group virtual transaction during minting. + This key enables signing operations to be performed externally, outside + the daemon. + + If this field is set then group_internal_key must be unset, and vice versa. + */ + taprpc.ExternalKey external_group_key = 14; } message MintAssetRequest { @@ -303,7 +325,7 @@ message FundBatchRequest { message FundBatchResponse { // The funded batch. - MintingBatch batch = 1; + VerboseBatch batch = 1; } message SealBatchRequest { diff --git a/taprpc/mintrpc/mint.swagger.json b/taprpc/mintrpc/mint.swagger.json index 9ae059feb..7043348b2 100644 --- a/taprpc/mintrpc/mint.swagger.json +++ b/taprpc/mintrpc/mint.swagger.json @@ -357,7 +357,7 @@ "type": "object", "properties": { "batch": { - "$ref": "#/definitions/mintrpcMintingBatch", + "$ref": "#/definitions/mintrpcVerboseBatch", "description": "The funded batch." } } @@ -417,12 +417,12 @@ }, "group_internal_key": { "$ref": "#/definitions/taprpcKeyDescriptor", - "description": "The optional key that will be used as the internal key for an asset group\ncreated with this asset." + "description": "The optional key that will be used as the internal key for an asset group\ncreated with this asset.\n\nIf this field is set then external_group_key must be unset, and vice versa." }, "group_tapscript_root": { "type": "string", "format": "byte", - "description": "The optional root of a tapscript tree that will be used when constructing a\nnew asset group key. This enables future issuance authorized with a script\nwitness." + "description": "An optional root of a Tapscript tree used when constructing a new asset\ngroup key. This allows for future asset issuance authorized using a\nscript witness.\n\nIf an external group key is provided, the V1 scheme for group key script\nconstruction will be used, which supports PSBT signing. In this scheme,\nthe user-supplied Tapscript root is extended by two levels of Tapscript\nsiblings that commit to the group anchor's asset ID. As a result, the\nprovided Tapscript root becomes a branch within a larger Tapscript tree,\nand the final Tapscript root will differ from the one specified here." }, "script_key": { "$ref": "#/definitions/taprpcScriptKey", @@ -432,6 +432,10 @@ "type": "integer", "format": "int64", "description": "Decimal display dictates the number of decimal places to shift the amount to\nthe left converting from Taproot Asset integer representation to a\nUX-recognizable fractional quantity.\n\nFor example, if the decimal_display value is 2 and there's 100 of those\nassets, then a wallet would display the amount as \"1.00\". This field is\nintended as information for wallets that display balances and has no impact\non the behavior of the daemon or any other part of the protocol. This value\nis encoded in the MetaData field as a JSON field, therefore it is only\ncompatible with assets that have a JSON MetaData field." + }, + "external_group_key": { + "$ref": "#/definitions/taprpcExternalKey", + "description": "The external group key is an optional field that allows specifying an\nexternal signing key for the group virtual transaction during minting.\nThis key enables signing operations to be performed externally, outside\nthe daemon.\n\nIf this field is set then group_internal_key must be unset, and vice versa." } } }, @@ -621,6 +625,10 @@ "group_virtual_tx": { "$ref": "#/definitions/taprpcGroupVirtualTx", "description": "The group virtual transaction for the asset." + }, + "group_virtual_psbt": { + "type": "string", + "description": "The byte serialized PSBT equivalent of the group virtual transaction." } } }, @@ -715,6 +723,25 @@ "default": "ASSET_VERSION_V0", "description": " - ASSET_VERSION_V0: ASSET_VERSION_V0 is the default asset version. This version will include\nthe witness vector in the leaf for a tap commitment.\n - ASSET_VERSION_V1: ASSET_VERSION_V1 is the asset version that leaves out the witness vector\nfrom the MS-SMT leaf encoding." }, + "taprpcExternalKey": { + "type": "object", + "properties": { + "xpub": { + "type": "string", + "description": "This field specifies the extended public key derived at depth 3 of the\nBIP-86 hierarchy (e.g., m/86'/0'/0'). This key serves as the parent key for\nderiving child public keys and addresses." + }, + "master_fingerprint": { + "type": "string", + "format": "byte", + "description": "This field specifies the fingerprint of the master key, derived from the\nfirst 4 bytes of the hash160 of the master public key. It is used to\nidentify the master key in BIP-86 derivation schemes." + }, + "derivation_path": { + "type": "string", + "description": "This field specifies the extended BIP-86 derivation path used to derive a\nchild key from the XPub. Starting from the base path of the XPub\n(e.g., m/86'/0'/0'), this path must contain exactly 5 components in total\n(e.g., m/86'/0'/0'/0/0), with the additional components defining specific\nchild keys, such as individual addresses." + } + }, + "description": "This message represents an external key used for deriving and managing\nhierarchical deterministic (HD) wallet addresses according to BIP-86." + }, "taprpcGenesisInfo": { "type": "object", "properties": { @@ -752,7 +779,7 @@ "properties": { "raw_key": { "$ref": "#/definitions/taprpcKeyDescriptor", - "description": "The internal key for the asset group before any tweaks have been applied." + "description": "The internal key for the asset group before any tweaks have been applied.\nIf this field is set then external_key must be empty, and vice versa." }, "anchor_genesis": { "$ref": "#/definitions/taprpcGenesisInfo", @@ -767,6 +794,10 @@ "type": "string", "format": "byte", "description": "The serialized asset which we are requesting group membership for. A\nsuccessful request will produce a witness that authorizes this asset to be a\nmember of this asset group." + }, + "external_key": { + "$ref": "#/definitions/taprpcExternalKey", + "description": "The external key is an optional field that allows specifying an\nexternal signing key for the group virtual transaction during minting.\nThis key enables signing operations to be performed externally, outside\nthe daemon.\n\nIf this field is set then raw_key must be empty, and vice versa." } } }, diff --git a/taprpc/taprootassets.pb.go b/taprpc/taprootassets.pb.go index ddf998a23..c2d97ae67 100644 --- a/taprpc/taprootassets.pb.go +++ b/taprpc/taprootassets.pb.go @@ -882,12 +882,89 @@ func (x *GenesisInfo) GetOutputIndex() uint32 { return 0 } +// This message represents an external key used for deriving and managing +// hierarchical deterministic (HD) wallet addresses according to BIP-86. +type ExternalKey struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // This field specifies the extended public key derived at depth 3 of the + // BIP-86 hierarchy (e.g., m/86'/0'/0'). This key serves as the parent key for + // deriving child public keys and addresses. + Xpub string `protobuf:"bytes,1,opt,name=xpub,proto3" json:"xpub,omitempty"` + // This field specifies the fingerprint of the master key, derived from the + // first 4 bytes of the hash160 of the master public key. It is used to + // identify the master key in BIP-86 derivation schemes. + MasterFingerprint []byte `protobuf:"bytes,2,opt,name=master_fingerprint,json=masterFingerprint,proto3" json:"master_fingerprint,omitempty"` + // This field specifies the extended BIP-86 derivation path used to derive a + // child key from the XPub. Starting from the base path of the XPub + // (e.g., m/86'/0'/0'), this path must contain exactly 5 components in total + // (e.g., m/86'/0'/0'/0/0), with the additional components defining specific + // child keys, such as individual addresses. + DerivationPath string `protobuf:"bytes,3,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"` +} + +func (x *ExternalKey) Reset() { + *x = ExternalKey{} + if protoimpl.UnsafeEnabled { + mi := &file_taprootassets_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExternalKey) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExternalKey) ProtoMessage() {} + +func (x *ExternalKey) ProtoReflect() protoreflect.Message { + mi := &file_taprootassets_proto_msgTypes[4] + 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 ExternalKey.ProtoReflect.Descriptor instead. +func (*ExternalKey) Descriptor() ([]byte, []int) { + return file_taprootassets_proto_rawDescGZIP(), []int{4} +} + +func (x *ExternalKey) GetXpub() string { + if x != nil { + return x.Xpub + } + return "" +} + +func (x *ExternalKey) GetMasterFingerprint() []byte { + if x != nil { + return x.MasterFingerprint + } + return nil +} + +func (x *ExternalKey) GetDerivationPath() string { + if x != nil { + return x.DerivationPath + } + return "" +} + type GroupKeyRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The internal key for the asset group before any tweaks have been applied. + // If this field is set then external_key must be empty, and vice versa. RawKey *KeyDescriptor `protobuf:"bytes,1,opt,name=raw_key,json=rawKey,proto3" json:"raw_key,omitempty"` // The genesis of the group anchor asset, which is used to derive the single // tweak for the group key. For a new group key, this will be the genesis of @@ -901,12 +978,19 @@ type GroupKeyRequest struct { // successful request will produce a witness that authorizes this asset to be a // member of this asset group. NewAsset []byte `protobuf:"bytes,4,opt,name=new_asset,json=newAsset,proto3" json:"new_asset,omitempty"` + // The external key is an optional field that allows specifying an + // external signing key for the group virtual transaction during minting. + // This key enables signing operations to be performed externally, outside + // the daemon. + // + // If this field is set then raw_key must be empty, and vice versa. + ExternalKey *ExternalKey `protobuf:"bytes,5,opt,name=external_key,json=externalKey,proto3" json:"external_key,omitempty"` } func (x *GroupKeyRequest) Reset() { *x = GroupKeyRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[4] + mi := &file_taprootassets_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -919,7 +1003,7 @@ func (x *GroupKeyRequest) String() string { func (*GroupKeyRequest) ProtoMessage() {} func (x *GroupKeyRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[4] + mi := &file_taprootassets_proto_msgTypes[5] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -932,7 +1016,7 @@ func (x *GroupKeyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupKeyRequest.ProtoReflect.Descriptor instead. func (*GroupKeyRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{4} + return file_taprootassets_proto_rawDescGZIP(), []int{5} } func (x *GroupKeyRequest) GetRawKey() *KeyDescriptor { @@ -963,6 +1047,13 @@ func (x *GroupKeyRequest) GetNewAsset() []byte { return nil } +func (x *GroupKeyRequest) GetExternalKey() *ExternalKey { + if x != nil { + return x.ExternalKey + } + return nil +} + type TxOut struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -977,7 +1068,7 @@ type TxOut struct { func (x *TxOut) Reset() { *x = TxOut{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[5] + mi := &file_taprootassets_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -990,7 +1081,7 @@ func (x *TxOut) String() string { func (*TxOut) ProtoMessage() {} func (x *TxOut) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[5] + mi := &file_taprootassets_proto_msgTypes[6] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1003,7 +1094,7 @@ func (x *TxOut) ProtoReflect() protoreflect.Message { // Deprecated: Use TxOut.ProtoReflect.Descriptor instead. func (*TxOut) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{5} + return file_taprootassets_proto_rawDescGZIP(), []int{6} } func (x *TxOut) GetValue() int64 { @@ -1044,7 +1135,7 @@ type GroupVirtualTx struct { func (x *GroupVirtualTx) Reset() { *x = GroupVirtualTx{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[6] + mi := &file_taprootassets_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1057,7 +1148,7 @@ func (x *GroupVirtualTx) String() string { func (*GroupVirtualTx) ProtoMessage() {} func (x *GroupVirtualTx) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[6] + mi := &file_taprootassets_proto_msgTypes[7] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1070,7 +1161,7 @@ func (x *GroupVirtualTx) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupVirtualTx.ProtoReflect.Descriptor instead. func (*GroupVirtualTx) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{6} + return file_taprootassets_proto_rawDescGZIP(), []int{7} } func (x *GroupVirtualTx) GetTransaction() []byte { @@ -1116,7 +1207,7 @@ type GroupWitness struct { func (x *GroupWitness) Reset() { *x = GroupWitness{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[7] + mi := &file_taprootassets_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1129,7 +1220,7 @@ func (x *GroupWitness) String() string { func (*GroupWitness) ProtoMessage() {} func (x *GroupWitness) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[7] + mi := &file_taprootassets_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1142,7 +1233,7 @@ func (x *GroupWitness) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupWitness.ProtoReflect.Descriptor instead. func (*GroupWitness) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{7} + return file_taprootassets_proto_rawDescGZIP(), []int{8} } func (x *GroupWitness) GetGenesisId() []byte { @@ -1180,7 +1271,7 @@ type AssetGroup struct { func (x *AssetGroup) Reset() { *x = AssetGroup{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[8] + mi := &file_taprootassets_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1193,7 +1284,7 @@ func (x *AssetGroup) String() string { func (*AssetGroup) ProtoMessage() {} func (x *AssetGroup) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[8] + mi := &file_taprootassets_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1206,7 +1297,7 @@ func (x *AssetGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetGroup.ProtoReflect.Descriptor instead. func (*AssetGroup) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{8} + return file_taprootassets_proto_rawDescGZIP(), []int{9} } func (x *AssetGroup) GetRawGroupKey() []byte { @@ -1251,7 +1342,7 @@ type GroupKeyReveal struct { func (x *GroupKeyReveal) Reset() { *x = GroupKeyReveal{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[9] + mi := &file_taprootassets_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1264,7 +1355,7 @@ func (x *GroupKeyReveal) String() string { func (*GroupKeyReveal) ProtoMessage() {} func (x *GroupKeyReveal) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[9] + mi := &file_taprootassets_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1277,7 +1368,7 @@ func (x *GroupKeyReveal) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupKeyReveal.ProtoReflect.Descriptor instead. func (*GroupKeyReveal) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{9} + return file_taprootassets_proto_rawDescGZIP(), []int{10} } func (x *GroupKeyReveal) GetRawGroupKey() []byte { @@ -1306,7 +1397,7 @@ type GenesisReveal struct { func (x *GenesisReveal) Reset() { *x = GenesisReveal{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[10] + mi := &file_taprootassets_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1319,7 +1410,7 @@ func (x *GenesisReveal) String() string { func (*GenesisReveal) ProtoMessage() {} func (x *GenesisReveal) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[10] + mi := &file_taprootassets_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1332,7 +1423,7 @@ func (x *GenesisReveal) ProtoReflect() protoreflect.Message { // Deprecated: Use GenesisReveal.ProtoReflect.Descriptor instead. func (*GenesisReveal) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{10} + return file_taprootassets_proto_rawDescGZIP(), []int{11} } func (x *GenesisReveal) GetGenesisBaseReveal() *GenesisInfo { @@ -1363,7 +1454,7 @@ type DecimalDisplay struct { func (x *DecimalDisplay) Reset() { *x = DecimalDisplay{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[11] + mi := &file_taprootassets_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1376,7 +1467,7 @@ func (x *DecimalDisplay) String() string { func (*DecimalDisplay) ProtoMessage() {} func (x *DecimalDisplay) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[11] + mi := &file_taprootassets_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1389,7 +1480,7 @@ func (x *DecimalDisplay) ProtoReflect() protoreflect.Message { // Deprecated: Use DecimalDisplay.ProtoReflect.Descriptor instead. func (*DecimalDisplay) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{11} + return file_taprootassets_proto_rawDescGZIP(), []int{12} } func (x *DecimalDisplay) GetDecimalDisplay() uint32 { @@ -1462,7 +1553,7 @@ type Asset struct { func (x *Asset) Reset() { *x = Asset{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[12] + mi := &file_taprootassets_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1475,7 +1566,7 @@ func (x *Asset) String() string { func (*Asset) ProtoMessage() {} func (x *Asset) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[12] + mi := &file_taprootassets_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1488,7 +1579,7 @@ func (x *Asset) ProtoReflect() protoreflect.Message { // Deprecated: Use Asset.ProtoReflect.Descriptor instead. func (*Asset) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{12} + return file_taprootassets_proto_rawDescGZIP(), []int{13} } func (x *Asset) GetVersion() AssetVersion { @@ -1630,7 +1721,7 @@ type PrevWitness struct { func (x *PrevWitness) Reset() { *x = PrevWitness{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[13] + mi := &file_taprootassets_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1643,7 +1734,7 @@ func (x *PrevWitness) String() string { func (*PrevWitness) ProtoMessage() {} func (x *PrevWitness) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[13] + mi := &file_taprootassets_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1656,7 +1747,7 @@ func (x *PrevWitness) ProtoReflect() protoreflect.Message { // Deprecated: Use PrevWitness.ProtoReflect.Descriptor instead. func (*PrevWitness) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{13} + return file_taprootassets_proto_rawDescGZIP(), []int{14} } func (x *PrevWitness) GetPrevId() *PrevInputAsset { @@ -1691,7 +1782,7 @@ type SplitCommitment struct { func (x *SplitCommitment) Reset() { *x = SplitCommitment{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[14] + mi := &file_taprootassets_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1704,7 +1795,7 @@ func (x *SplitCommitment) String() string { func (*SplitCommitment) ProtoMessage() {} func (x *SplitCommitment) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[14] + mi := &file_taprootassets_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1717,7 +1808,7 @@ func (x *SplitCommitment) ProtoReflect() protoreflect.Message { // Deprecated: Use SplitCommitment.ProtoReflect.Descriptor instead. func (*SplitCommitment) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{14} + return file_taprootassets_proto_rawDescGZIP(), []int{15} } func (x *SplitCommitment) GetRootAsset() *Asset { @@ -1745,7 +1836,7 @@ type ListAssetResponse struct { func (x *ListAssetResponse) Reset() { *x = ListAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[15] + mi := &file_taprootassets_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1758,7 +1849,7 @@ func (x *ListAssetResponse) String() string { func (*ListAssetResponse) ProtoMessage() {} func (x *ListAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[15] + mi := &file_taprootassets_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1771,7 +1862,7 @@ func (x *ListAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAssetResponse.ProtoReflect.Descriptor instead. func (*ListAssetResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{15} + return file_taprootassets_proto_rawDescGZIP(), []int{16} } func (x *ListAssetResponse) GetAssets() []*Asset { @@ -1806,7 +1897,7 @@ type ListUtxosRequest struct { func (x *ListUtxosRequest) Reset() { *x = ListUtxosRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[16] + mi := &file_taprootassets_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1819,7 +1910,7 @@ func (x *ListUtxosRequest) String() string { func (*ListUtxosRequest) ProtoMessage() {} func (x *ListUtxosRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[16] + mi := &file_taprootassets_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1832,7 +1923,7 @@ func (x *ListUtxosRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListUtxosRequest.ProtoReflect.Descriptor instead. func (*ListUtxosRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{16} + return file_taprootassets_proto_rawDescGZIP(), []int{17} } func (x *ListUtxosRequest) GetIncludeLeased() bool { @@ -1871,7 +1962,7 @@ type ManagedUtxo struct { func (x *ManagedUtxo) Reset() { *x = ManagedUtxo{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[17] + mi := &file_taprootassets_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1884,7 +1975,7 @@ func (x *ManagedUtxo) String() string { func (*ManagedUtxo) ProtoMessage() {} func (x *ManagedUtxo) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[17] + mi := &file_taprootassets_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1897,7 +1988,7 @@ func (x *ManagedUtxo) ProtoReflect() protoreflect.Message { // Deprecated: Use ManagedUtxo.ProtoReflect.Descriptor instead. func (*ManagedUtxo) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{17} + return file_taprootassets_proto_rawDescGZIP(), []int{18} } func (x *ManagedUtxo) GetOutPoint() string { @@ -1968,7 +2059,7 @@ type ListUtxosResponse struct { func (x *ListUtxosResponse) Reset() { *x = ListUtxosResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[18] + mi := &file_taprootassets_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1981,7 +2072,7 @@ func (x *ListUtxosResponse) String() string { func (*ListUtxosResponse) ProtoMessage() {} func (x *ListUtxosResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[18] + mi := &file_taprootassets_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1994,7 +2085,7 @@ func (x *ListUtxosResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListUtxosResponse.ProtoReflect.Descriptor instead. func (*ListUtxosResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{18} + return file_taprootassets_proto_rawDescGZIP(), []int{19} } func (x *ListUtxosResponse) GetManagedUtxos() map[string]*ManagedUtxo { @@ -2013,7 +2104,7 @@ type ListGroupsRequest struct { func (x *ListGroupsRequest) Reset() { *x = ListGroupsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[19] + mi := &file_taprootassets_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2026,7 +2117,7 @@ func (x *ListGroupsRequest) String() string { func (*ListGroupsRequest) ProtoMessage() {} func (x *ListGroupsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[19] + mi := &file_taprootassets_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2039,7 +2130,7 @@ func (x *ListGroupsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListGroupsRequest.ProtoReflect.Descriptor instead. func (*ListGroupsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{19} + return file_taprootassets_proto_rawDescGZIP(), []int{20} } type AssetHumanReadable struct { @@ -2068,7 +2159,7 @@ type AssetHumanReadable struct { func (x *AssetHumanReadable) Reset() { *x = AssetHumanReadable{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[20] + mi := &file_taprootassets_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2081,7 +2172,7 @@ func (x *AssetHumanReadable) String() string { func (*AssetHumanReadable) ProtoMessage() {} func (x *AssetHumanReadable) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[20] + mi := &file_taprootassets_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2094,7 +2185,7 @@ func (x *AssetHumanReadable) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetHumanReadable.ProtoReflect.Descriptor instead. func (*AssetHumanReadable) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{20} + return file_taprootassets_proto_rawDescGZIP(), []int{21} } func (x *AssetHumanReadable) GetId() []byte { @@ -2165,7 +2256,7 @@ type GroupedAssets struct { func (x *GroupedAssets) Reset() { *x = GroupedAssets{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[21] + mi := &file_taprootassets_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2178,7 +2269,7 @@ func (x *GroupedAssets) String() string { func (*GroupedAssets) ProtoMessage() {} func (x *GroupedAssets) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[21] + mi := &file_taprootassets_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2191,7 +2282,7 @@ func (x *GroupedAssets) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupedAssets.ProtoReflect.Descriptor instead. func (*GroupedAssets) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{21} + return file_taprootassets_proto_rawDescGZIP(), []int{22} } func (x *GroupedAssets) GetAssets() []*AssetHumanReadable { @@ -2213,7 +2304,7 @@ type ListGroupsResponse struct { func (x *ListGroupsResponse) Reset() { *x = ListGroupsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[22] + mi := &file_taprootassets_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2226,7 +2317,7 @@ func (x *ListGroupsResponse) String() string { func (*ListGroupsResponse) ProtoMessage() {} func (x *ListGroupsResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[22] + mi := &file_taprootassets_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2239,7 +2330,7 @@ func (x *ListGroupsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListGroupsResponse.ProtoReflect.Descriptor instead. func (*ListGroupsResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{22} + return file_taprootassets_proto_rawDescGZIP(), []int{23} } func (x *ListGroupsResponse) GetGroups() map[string]*GroupedAssets { @@ -2273,7 +2364,7 @@ type ListBalancesRequest struct { func (x *ListBalancesRequest) Reset() { *x = ListBalancesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[23] + mi := &file_taprootassets_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2286,7 +2377,7 @@ func (x *ListBalancesRequest) String() string { func (*ListBalancesRequest) ProtoMessage() {} func (x *ListBalancesRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[23] + mi := &file_taprootassets_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2299,7 +2390,7 @@ func (x *ListBalancesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBalancesRequest.ProtoReflect.Descriptor instead. func (*ListBalancesRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{23} + return file_taprootassets_proto_rawDescGZIP(), []int{24} } func (m *ListBalancesRequest) GetGroupBy() isListBalancesRequest_GroupBy { @@ -2376,7 +2467,7 @@ type AssetBalance struct { func (x *AssetBalance) Reset() { *x = AssetBalance{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[24] + mi := &file_taprootassets_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2389,7 +2480,7 @@ func (x *AssetBalance) String() string { func (*AssetBalance) ProtoMessage() {} func (x *AssetBalance) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[24] + mi := &file_taprootassets_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2402,7 +2493,7 @@ func (x *AssetBalance) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetBalance.ProtoReflect.Descriptor instead. func (*AssetBalance) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{24} + return file_taprootassets_proto_rawDescGZIP(), []int{25} } func (x *AssetBalance) GetAssetGenesis() *GenesisInfo { @@ -2433,7 +2524,7 @@ type AssetGroupBalance struct { func (x *AssetGroupBalance) Reset() { *x = AssetGroupBalance{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[25] + mi := &file_taprootassets_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2446,7 +2537,7 @@ func (x *AssetGroupBalance) String() string { func (*AssetGroupBalance) ProtoMessage() {} func (x *AssetGroupBalance) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[25] + mi := &file_taprootassets_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2459,7 +2550,7 @@ func (x *AssetGroupBalance) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetGroupBalance.ProtoReflect.Descriptor instead. func (*AssetGroupBalance) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{25} + return file_taprootassets_proto_rawDescGZIP(), []int{26} } func (x *AssetGroupBalance) GetGroupKey() []byte { @@ -2488,7 +2579,7 @@ type ListBalancesResponse struct { func (x *ListBalancesResponse) Reset() { *x = ListBalancesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[26] + mi := &file_taprootassets_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2501,7 +2592,7 @@ func (x *ListBalancesResponse) String() string { func (*ListBalancesResponse) ProtoMessage() {} func (x *ListBalancesResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[26] + mi := &file_taprootassets_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2514,7 +2605,7 @@ func (x *ListBalancesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBalancesResponse.ProtoReflect.Descriptor instead. func (*ListBalancesResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{26} + return file_taprootassets_proto_rawDescGZIP(), []int{27} } func (x *ListBalancesResponse) GetAssetBalances() map[string]*AssetBalance { @@ -2545,7 +2636,7 @@ type ListTransfersRequest struct { func (x *ListTransfersRequest) Reset() { *x = ListTransfersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[27] + mi := &file_taprootassets_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2558,7 +2649,7 @@ func (x *ListTransfersRequest) String() string { func (*ListTransfersRequest) ProtoMessage() {} func (x *ListTransfersRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[27] + mi := &file_taprootassets_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2571,7 +2662,7 @@ func (x *ListTransfersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTransfersRequest.ProtoReflect.Descriptor instead. func (*ListTransfersRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{27} + return file_taprootassets_proto_rawDescGZIP(), []int{28} } func (x *ListTransfersRequest) GetAnchorTxid() string { @@ -2593,7 +2684,7 @@ type ListTransfersResponse struct { func (x *ListTransfersResponse) Reset() { *x = ListTransfersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[28] + mi := &file_taprootassets_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2606,7 +2697,7 @@ func (x *ListTransfersResponse) String() string { func (*ListTransfersResponse) ProtoMessage() {} func (x *ListTransfersResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[28] + mi := &file_taprootassets_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2619,7 +2710,7 @@ func (x *ListTransfersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTransfersResponse.ProtoReflect.Descriptor instead. func (*ListTransfersResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{28} + return file_taprootassets_proto_rawDescGZIP(), []int{29} } func (x *ListTransfersResponse) GetTransfers() []*AssetTransfer { @@ -2657,7 +2748,7 @@ type ChainHash struct { func (x *ChainHash) Reset() { *x = ChainHash{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[29] + mi := &file_taprootassets_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2670,7 +2761,7 @@ func (x *ChainHash) String() string { func (*ChainHash) ProtoMessage() {} func (x *ChainHash) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[29] + mi := &file_taprootassets_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2683,7 +2774,7 @@ func (x *ChainHash) ProtoReflect() protoreflect.Message { // Deprecated: Use ChainHash.ProtoReflect.Descriptor instead. func (*ChainHash) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{29} + return file_taprootassets_proto_rawDescGZIP(), []int{30} } func (x *ChainHash) GetHash() []byte { @@ -2724,7 +2815,7 @@ type AssetTransfer struct { func (x *AssetTransfer) Reset() { *x = AssetTransfer{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[30] + mi := &file_taprootassets_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2737,7 +2828,7 @@ func (x *AssetTransfer) String() string { func (*AssetTransfer) ProtoMessage() {} func (x *AssetTransfer) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[30] + mi := &file_taprootassets_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2750,7 +2841,7 @@ func (x *AssetTransfer) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetTransfer.ProtoReflect.Descriptor instead. func (*AssetTransfer) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{30} + return file_taprootassets_proto_rawDescGZIP(), []int{31} } func (x *AssetTransfer) GetTransferTimestamp() int64 { @@ -2821,7 +2912,7 @@ type TransferInput struct { func (x *TransferInput) Reset() { *x = TransferInput{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[31] + mi := &file_taprootassets_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2834,7 +2925,7 @@ func (x *TransferInput) String() string { func (*TransferInput) ProtoMessage() {} func (x *TransferInput) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[31] + mi := &file_taprootassets_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2847,7 +2938,7 @@ func (x *TransferInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferInput.ProtoReflect.Descriptor instead. func (*TransferInput) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{31} + return file_taprootassets_proto_rawDescGZIP(), []int{32} } func (x *TransferInput) GetAnchorPoint() string { @@ -2897,7 +2988,7 @@ type TransferOutputAnchor struct { func (x *TransferOutputAnchor) Reset() { *x = TransferOutputAnchor{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[32] + mi := &file_taprootassets_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2910,7 +3001,7 @@ func (x *TransferOutputAnchor) String() string { func (*TransferOutputAnchor) ProtoMessage() {} func (x *TransferOutputAnchor) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[32] + mi := &file_taprootassets_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2923,7 +3014,7 @@ func (x *TransferOutputAnchor) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferOutputAnchor.ProtoReflect.Descriptor instead. func (*TransferOutputAnchor) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{32} + return file_taprootassets_proto_rawDescGZIP(), []int{33} } func (x *TransferOutputAnchor) GetOutpoint() string { @@ -2999,7 +3090,7 @@ type TransferOutput struct { func (x *TransferOutput) Reset() { *x = TransferOutput{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[33] + mi := &file_taprootassets_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3012,7 +3103,7 @@ func (x *TransferOutput) String() string { func (*TransferOutput) ProtoMessage() {} func (x *TransferOutput) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[33] + mi := &file_taprootassets_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3025,7 +3116,7 @@ func (x *TransferOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferOutput.ProtoReflect.Descriptor instead. func (*TransferOutput) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{33} + return file_taprootassets_proto_rawDescGZIP(), []int{34} } func (x *TransferOutput) GetAnchor() *TransferOutputAnchor { @@ -3114,7 +3205,7 @@ type StopRequest struct { func (x *StopRequest) Reset() { *x = StopRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[34] + mi := &file_taprootassets_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3127,7 +3218,7 @@ func (x *StopRequest) String() string { func (*StopRequest) ProtoMessage() {} func (x *StopRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[34] + mi := &file_taprootassets_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3140,7 +3231,7 @@ func (x *StopRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopRequest.ProtoReflect.Descriptor instead. func (*StopRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{34} + return file_taprootassets_proto_rawDescGZIP(), []int{35} } type StopResponse struct { @@ -3152,7 +3243,7 @@ type StopResponse struct { func (x *StopResponse) Reset() { *x = StopResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[35] + mi := &file_taprootassets_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3165,7 +3256,7 @@ func (x *StopResponse) String() string { func (*StopResponse) ProtoMessage() {} func (x *StopResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[35] + mi := &file_taprootassets_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3178,7 +3269,7 @@ func (x *StopResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StopResponse.ProtoReflect.Descriptor instead. func (*StopResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{35} + return file_taprootassets_proto_rawDescGZIP(), []int{36} } type DebugLevelRequest struct { @@ -3194,7 +3285,7 @@ type DebugLevelRequest struct { func (x *DebugLevelRequest) Reset() { *x = DebugLevelRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[36] + mi := &file_taprootassets_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3207,7 +3298,7 @@ func (x *DebugLevelRequest) String() string { func (*DebugLevelRequest) ProtoMessage() {} func (x *DebugLevelRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[36] + mi := &file_taprootassets_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3220,7 +3311,7 @@ func (x *DebugLevelRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugLevelRequest.ProtoReflect.Descriptor instead. func (*DebugLevelRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{36} + return file_taprootassets_proto_rawDescGZIP(), []int{37} } func (x *DebugLevelRequest) GetShow() bool { @@ -3248,7 +3339,7 @@ type DebugLevelResponse struct { func (x *DebugLevelResponse) Reset() { *x = DebugLevelResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[37] + mi := &file_taprootassets_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3261,7 +3352,7 @@ func (x *DebugLevelResponse) String() string { func (*DebugLevelResponse) ProtoMessage() {} func (x *DebugLevelResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[37] + mi := &file_taprootassets_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3274,7 +3365,7 @@ func (x *DebugLevelResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugLevelResponse.ProtoReflect.Descriptor instead. func (*DebugLevelResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{37} + return file_taprootassets_proto_rawDescGZIP(), []int{38} } func (x *DebugLevelResponse) GetSubSystems() string { @@ -3324,7 +3415,7 @@ type Addr struct { func (x *Addr) Reset() { *x = Addr{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[38] + mi := &file_taprootassets_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3337,7 +3428,7 @@ func (x *Addr) String() string { func (*Addr) ProtoMessage() {} func (x *Addr) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[38] + mi := &file_taprootassets_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3350,7 +3441,7 @@ func (x *Addr) ProtoReflect() protoreflect.Message { // Deprecated: Use Addr.ProtoReflect.Descriptor instead. func (*Addr) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{38} + return file_taprootassets_proto_rawDescGZIP(), []int{39} } func (x *Addr) GetEncoded() string { @@ -3457,7 +3548,7 @@ type QueryAddrRequest struct { func (x *QueryAddrRequest) Reset() { *x = QueryAddrRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[39] + mi := &file_taprootassets_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3470,7 +3561,7 @@ func (x *QueryAddrRequest) String() string { func (*QueryAddrRequest) ProtoMessage() {} func (x *QueryAddrRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[39] + mi := &file_taprootassets_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3483,7 +3574,7 @@ func (x *QueryAddrRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAddrRequest.ProtoReflect.Descriptor instead. func (*QueryAddrRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{39} + return file_taprootassets_proto_rawDescGZIP(), []int{40} } func (x *QueryAddrRequest) GetCreatedAfter() int64 { @@ -3525,7 +3616,7 @@ type QueryAddrResponse struct { func (x *QueryAddrResponse) Reset() { *x = QueryAddrResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[40] + mi := &file_taprootassets_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3538,7 +3629,7 @@ func (x *QueryAddrResponse) String() string { func (*QueryAddrResponse) ProtoMessage() {} func (x *QueryAddrResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[40] + mi := &file_taprootassets_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3551,7 +3642,7 @@ func (x *QueryAddrResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAddrResponse.ProtoReflect.Descriptor instead. func (*QueryAddrResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{40} + return file_taprootassets_proto_rawDescGZIP(), []int{41} } func (x *QueryAddrResponse) GetAddrs() []*Addr { @@ -3599,7 +3690,7 @@ type NewAddrRequest struct { func (x *NewAddrRequest) Reset() { *x = NewAddrRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[41] + mi := &file_taprootassets_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3612,7 +3703,7 @@ func (x *NewAddrRequest) String() string { func (*NewAddrRequest) ProtoMessage() {} func (x *NewAddrRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[41] + mi := &file_taprootassets_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3625,7 +3716,7 @@ func (x *NewAddrRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use NewAddrRequest.ProtoReflect.Descriptor instead. func (*NewAddrRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{41} + return file_taprootassets_proto_rawDescGZIP(), []int{42} } func (x *NewAddrRequest) GetAssetId() []byte { @@ -3703,7 +3794,7 @@ type ScriptKey struct { func (x *ScriptKey) Reset() { *x = ScriptKey{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[42] + mi := &file_taprootassets_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3716,7 +3807,7 @@ func (x *ScriptKey) String() string { func (*ScriptKey) ProtoMessage() {} func (x *ScriptKey) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[42] + mi := &file_taprootassets_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3729,7 +3820,7 @@ func (x *ScriptKey) ProtoReflect() protoreflect.Message { // Deprecated: Use ScriptKey.ProtoReflect.Descriptor instead. func (*ScriptKey) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{42} + return file_taprootassets_proto_rawDescGZIP(), []int{43} } func (x *ScriptKey) GetPubKey() []byte { @@ -3767,7 +3858,7 @@ type KeyLocator struct { func (x *KeyLocator) Reset() { *x = KeyLocator{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[43] + mi := &file_taprootassets_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3780,7 +3871,7 @@ func (x *KeyLocator) String() string { func (*KeyLocator) ProtoMessage() {} func (x *KeyLocator) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[43] + mi := &file_taprootassets_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3793,7 +3884,7 @@ func (x *KeyLocator) ProtoReflect() protoreflect.Message { // Deprecated: Use KeyLocator.ProtoReflect.Descriptor instead. func (*KeyLocator) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{43} + return file_taprootassets_proto_rawDescGZIP(), []int{44} } func (x *KeyLocator) GetKeyFamily() int32 { @@ -3824,7 +3915,7 @@ type KeyDescriptor struct { func (x *KeyDescriptor) Reset() { *x = KeyDescriptor{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[44] + mi := &file_taprootassets_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3837,7 +3928,7 @@ func (x *KeyDescriptor) String() string { func (*KeyDescriptor) ProtoMessage() {} func (x *KeyDescriptor) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[44] + mi := &file_taprootassets_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3850,7 +3941,7 @@ func (x *KeyDescriptor) ProtoReflect() protoreflect.Message { // Deprecated: Use KeyDescriptor.ProtoReflect.Descriptor instead. func (*KeyDescriptor) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{44} + return file_taprootassets_proto_rawDescGZIP(), []int{45} } func (x *KeyDescriptor) GetRawKeyBytes() []byte { @@ -3879,7 +3970,7 @@ type TapscriptFullTree struct { func (x *TapscriptFullTree) Reset() { *x = TapscriptFullTree{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[45] + mi := &file_taprootassets_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3892,7 +3983,7 @@ func (x *TapscriptFullTree) String() string { func (*TapscriptFullTree) ProtoMessage() {} func (x *TapscriptFullTree) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[45] + mi := &file_taprootassets_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3905,7 +3996,7 @@ func (x *TapscriptFullTree) ProtoReflect() protoreflect.Message { // Deprecated: Use TapscriptFullTree.ProtoReflect.Descriptor instead. func (*TapscriptFullTree) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{45} + return file_taprootassets_proto_rawDescGZIP(), []int{46} } func (x *TapscriptFullTree) GetAllLeaves() []*TapLeaf { @@ -3927,7 +4018,7 @@ type TapLeaf struct { func (x *TapLeaf) Reset() { *x = TapLeaf{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[46] + mi := &file_taprootassets_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3940,7 +4031,7 @@ func (x *TapLeaf) String() string { func (*TapLeaf) ProtoMessage() {} func (x *TapLeaf) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[46] + mi := &file_taprootassets_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3953,7 +4044,7 @@ func (x *TapLeaf) ProtoReflect() protoreflect.Message { // Deprecated: Use TapLeaf.ProtoReflect.Descriptor instead. func (*TapLeaf) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{46} + return file_taprootassets_proto_rawDescGZIP(), []int{47} } func (x *TapLeaf) GetScript() []byte { @@ -3977,7 +4068,7 @@ type TapBranch struct { func (x *TapBranch) Reset() { *x = TapBranch{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[47] + mi := &file_taprootassets_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3990,7 +4081,7 @@ func (x *TapBranch) String() string { func (*TapBranch) ProtoMessage() {} func (x *TapBranch) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[47] + mi := &file_taprootassets_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4003,7 +4094,7 @@ func (x *TapBranch) ProtoReflect() protoreflect.Message { // Deprecated: Use TapBranch.ProtoReflect.Descriptor instead. func (*TapBranch) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{47} + return file_taprootassets_proto_rawDescGZIP(), []int{48} } func (x *TapBranch) GetLeftTaphash() []byte { @@ -4031,7 +4122,7 @@ type DecodeAddrRequest struct { func (x *DecodeAddrRequest) Reset() { *x = DecodeAddrRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[48] + mi := &file_taprootassets_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4044,7 +4135,7 @@ func (x *DecodeAddrRequest) String() string { func (*DecodeAddrRequest) ProtoMessage() {} func (x *DecodeAddrRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[48] + mi := &file_taprootassets_proto_msgTypes[49] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4057,7 +4148,7 @@ func (x *DecodeAddrRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodeAddrRequest.ProtoReflect.Descriptor instead. func (*DecodeAddrRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{48} + return file_taprootassets_proto_rawDescGZIP(), []int{49} } func (x *DecodeAddrRequest) GetAddr() string { @@ -4081,7 +4172,7 @@ type ProofFile struct { func (x *ProofFile) Reset() { *x = ProofFile{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[49] + mi := &file_taprootassets_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4094,7 +4185,7 @@ func (x *ProofFile) String() string { func (*ProofFile) ProtoMessage() {} func (x *ProofFile) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[49] + mi := &file_taprootassets_proto_msgTypes[50] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4107,7 +4198,7 @@ func (x *ProofFile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProofFile.ProtoReflect.Descriptor instead. func (*ProofFile) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{49} + return file_taprootassets_proto_rawDescGZIP(), []int{50} } func (x *ProofFile) GetRawProofFile() []byte { @@ -4182,7 +4273,7 @@ type DecodedProof struct { func (x *DecodedProof) Reset() { *x = DecodedProof{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[50] + mi := &file_taprootassets_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4195,7 +4286,7 @@ func (x *DecodedProof) String() string { func (*DecodedProof) ProtoMessage() {} func (x *DecodedProof) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[50] + mi := &file_taprootassets_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4208,7 +4299,7 @@ func (x *DecodedProof) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodedProof.ProtoReflect.Descriptor instead. func (*DecodedProof) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{50} + return file_taprootassets_proto_rawDescGZIP(), []int{51} } func (x *DecodedProof) GetProofAtDepth() uint32 { @@ -4322,7 +4413,7 @@ type VerifyProofResponse struct { func (x *VerifyProofResponse) Reset() { *x = VerifyProofResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[51] + mi := &file_taprootassets_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4335,7 +4426,7 @@ func (x *VerifyProofResponse) String() string { func (*VerifyProofResponse) ProtoMessage() {} func (x *VerifyProofResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[51] + mi := &file_taprootassets_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4348,7 +4439,7 @@ func (x *VerifyProofResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VerifyProofResponse.ProtoReflect.Descriptor instead. func (*VerifyProofResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{51} + return file_taprootassets_proto_rawDescGZIP(), []int{52} } func (x *VerifyProofResponse) GetValid() bool { @@ -4388,7 +4479,7 @@ type DecodeProofRequest struct { func (x *DecodeProofRequest) Reset() { *x = DecodeProofRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[52] + mi := &file_taprootassets_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4401,7 +4492,7 @@ func (x *DecodeProofRequest) String() string { func (*DecodeProofRequest) ProtoMessage() {} func (x *DecodeProofRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[52] + mi := &file_taprootassets_proto_msgTypes[53] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4414,7 +4505,7 @@ func (x *DecodeProofRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodeProofRequest.ProtoReflect.Descriptor instead. func (*DecodeProofRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{52} + return file_taprootassets_proto_rawDescGZIP(), []int{53} } func (x *DecodeProofRequest) GetRawProof() []byte { @@ -4456,7 +4547,7 @@ type DecodeProofResponse struct { func (x *DecodeProofResponse) Reset() { *x = DecodeProofResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[53] + mi := &file_taprootassets_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4469,7 +4560,7 @@ func (x *DecodeProofResponse) String() string { func (*DecodeProofResponse) ProtoMessage() {} func (x *DecodeProofResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[53] + mi := &file_taprootassets_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4482,7 +4573,7 @@ func (x *DecodeProofResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodeProofResponse.ProtoReflect.Descriptor instead. func (*DecodeProofResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{53} + return file_taprootassets_proto_rawDescGZIP(), []int{54} } func (x *DecodeProofResponse) GetDecodedProof() *DecodedProof { @@ -4505,7 +4596,7 @@ type ExportProofRequest struct { func (x *ExportProofRequest) Reset() { *x = ExportProofRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[54] + mi := &file_taprootassets_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4518,7 +4609,7 @@ func (x *ExportProofRequest) String() string { func (*ExportProofRequest) ProtoMessage() {} func (x *ExportProofRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[54] + mi := &file_taprootassets_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4531,7 +4622,7 @@ func (x *ExportProofRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExportProofRequest.ProtoReflect.Descriptor instead. func (*ExportProofRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{54} + return file_taprootassets_proto_rawDescGZIP(), []int{55} } func (x *ExportProofRequest) GetAssetId() []byte { @@ -4585,7 +4676,7 @@ type AddrEvent struct { func (x *AddrEvent) Reset() { *x = AddrEvent{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[55] + mi := &file_taprootassets_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4598,7 +4689,7 @@ func (x *AddrEvent) String() string { func (*AddrEvent) ProtoMessage() {} func (x *AddrEvent) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[55] + mi := &file_taprootassets_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4611,7 +4702,7 @@ func (x *AddrEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use AddrEvent.ProtoReflect.Descriptor instead. func (*AddrEvent) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{55} + return file_taprootassets_proto_rawDescGZIP(), []int{56} } func (x *AddrEvent) GetCreationTimeUnixSeconds() uint64 { @@ -4684,7 +4775,7 @@ type AddrReceivesRequest struct { func (x *AddrReceivesRequest) Reset() { *x = AddrReceivesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[56] + mi := &file_taprootassets_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4697,7 +4788,7 @@ func (x *AddrReceivesRequest) String() string { func (*AddrReceivesRequest) ProtoMessage() {} func (x *AddrReceivesRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[56] + mi := &file_taprootassets_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4710,7 +4801,7 @@ func (x *AddrReceivesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddrReceivesRequest.ProtoReflect.Descriptor instead. func (*AddrReceivesRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{56} + return file_taprootassets_proto_rawDescGZIP(), []int{57} } func (x *AddrReceivesRequest) GetFilterAddr() string { @@ -4739,7 +4830,7 @@ type AddrReceivesResponse struct { func (x *AddrReceivesResponse) Reset() { *x = AddrReceivesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[57] + mi := &file_taprootassets_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4752,7 +4843,7 @@ func (x *AddrReceivesResponse) String() string { func (*AddrReceivesResponse) ProtoMessage() {} func (x *AddrReceivesResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[57] + mi := &file_taprootassets_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4765,7 +4856,7 @@ func (x *AddrReceivesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddrReceivesResponse.ProtoReflect.Descriptor instead. func (*AddrReceivesResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{57} + return file_taprootassets_proto_rawDescGZIP(), []int{58} } func (x *AddrReceivesResponse) GetEvents() []*AddrEvent { @@ -4788,7 +4879,7 @@ type SendAssetRequest struct { func (x *SendAssetRequest) Reset() { *x = SendAssetRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[58] + mi := &file_taprootassets_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4801,7 +4892,7 @@ func (x *SendAssetRequest) String() string { func (*SendAssetRequest) ProtoMessage() {} func (x *SendAssetRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[58] + mi := &file_taprootassets_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4814,7 +4905,7 @@ func (x *SendAssetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SendAssetRequest.ProtoReflect.Descriptor instead. func (*SendAssetRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{58} + return file_taprootassets_proto_rawDescGZIP(), []int{59} } func (x *SendAssetRequest) GetTapAddrs() []string { @@ -4845,7 +4936,7 @@ type PrevInputAsset struct { func (x *PrevInputAsset) Reset() { *x = PrevInputAsset{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[59] + mi := &file_taprootassets_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4858,7 +4949,7 @@ func (x *PrevInputAsset) String() string { func (*PrevInputAsset) ProtoMessage() {} func (x *PrevInputAsset) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[59] + mi := &file_taprootassets_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4871,7 +4962,7 @@ func (x *PrevInputAsset) ProtoReflect() protoreflect.Message { // Deprecated: Use PrevInputAsset.ProtoReflect.Descriptor instead. func (*PrevInputAsset) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{59} + return file_taprootassets_proto_rawDescGZIP(), []int{60} } func (x *PrevInputAsset) GetAnchorPoint() string { @@ -4913,7 +5004,7 @@ type SendAssetResponse struct { func (x *SendAssetResponse) Reset() { *x = SendAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[60] + mi := &file_taprootassets_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4926,7 +5017,7 @@ func (x *SendAssetResponse) String() string { func (*SendAssetResponse) ProtoMessage() {} func (x *SendAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[60] + mi := &file_taprootassets_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4939,7 +5030,7 @@ func (x *SendAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SendAssetResponse.ProtoReflect.Descriptor instead. func (*SendAssetResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{60} + return file_taprootassets_proto_rawDescGZIP(), []int{61} } func (x *SendAssetResponse) GetTransfer() *AssetTransfer { @@ -4958,7 +5049,7 @@ type GetInfoRequest struct { func (x *GetInfoRequest) Reset() { *x = GetInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[61] + mi := &file_taprootassets_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4971,7 +5062,7 @@ func (x *GetInfoRequest) String() string { func (*GetInfoRequest) ProtoMessage() {} func (x *GetInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[61] + mi := &file_taprootassets_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4984,7 +5075,7 @@ func (x *GetInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetInfoRequest.ProtoReflect.Descriptor instead. func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{61} + return file_taprootassets_proto_rawDescGZIP(), []int{62} } type GetInfoResponse struct { @@ -5005,7 +5096,7 @@ type GetInfoResponse struct { func (x *GetInfoResponse) Reset() { *x = GetInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[62] + mi := &file_taprootassets_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5018,7 +5109,7 @@ func (x *GetInfoResponse) String() string { func (*GetInfoResponse) ProtoMessage() {} func (x *GetInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[62] + mi := &file_taprootassets_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5031,7 +5122,7 @@ func (x *GetInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetInfoResponse.ProtoReflect.Descriptor instead. func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{62} + return file_taprootassets_proto_rawDescGZIP(), []int{63} } func (x *GetInfoResponse) GetVersion() string { @@ -5107,7 +5198,7 @@ type FetchAssetMetaRequest struct { func (x *FetchAssetMetaRequest) Reset() { *x = FetchAssetMetaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[63] + mi := &file_taprootassets_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5120,7 +5211,7 @@ func (x *FetchAssetMetaRequest) String() string { func (*FetchAssetMetaRequest) ProtoMessage() {} func (x *FetchAssetMetaRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[63] + mi := &file_taprootassets_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5133,7 +5224,7 @@ func (x *FetchAssetMetaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FetchAssetMetaRequest.ProtoReflect.Descriptor instead. func (*FetchAssetMetaRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{63} + return file_taprootassets_proto_rawDescGZIP(), []int{64} } func (m *FetchAssetMetaRequest) GetAsset() isFetchAssetMetaRequest_Asset { @@ -5225,7 +5316,7 @@ type BurnAssetRequest struct { func (x *BurnAssetRequest) Reset() { *x = BurnAssetRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[64] + mi := &file_taprootassets_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5238,7 +5329,7 @@ func (x *BurnAssetRequest) String() string { func (*BurnAssetRequest) ProtoMessage() {} func (x *BurnAssetRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[64] + mi := &file_taprootassets_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5251,7 +5342,7 @@ func (x *BurnAssetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BurnAssetRequest.ProtoReflect.Descriptor instead. func (*BurnAssetRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{64} + return file_taprootassets_proto_rawDescGZIP(), []int{65} } func (m *BurnAssetRequest) GetAsset() isBurnAssetRequest_Asset { @@ -5328,7 +5419,7 @@ type BurnAssetResponse struct { func (x *BurnAssetResponse) Reset() { *x = BurnAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[65] + mi := &file_taprootassets_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5341,7 +5432,7 @@ func (x *BurnAssetResponse) String() string { func (*BurnAssetResponse) ProtoMessage() {} func (x *BurnAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[65] + mi := &file_taprootassets_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5354,7 +5445,7 @@ func (x *BurnAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BurnAssetResponse.ProtoReflect.Descriptor instead. func (*BurnAssetResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{65} + return file_taprootassets_proto_rawDescGZIP(), []int{66} } func (x *BurnAssetResponse) GetBurnTransfer() *AssetTransfer { @@ -5387,7 +5478,7 @@ type ListBurnsRequest struct { func (x *ListBurnsRequest) Reset() { *x = ListBurnsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[66] + mi := &file_taprootassets_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5400,7 +5491,7 @@ func (x *ListBurnsRequest) String() string { func (*ListBurnsRequest) ProtoMessage() {} func (x *ListBurnsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[66] + mi := &file_taprootassets_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5413,7 +5504,7 @@ func (x *ListBurnsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBurnsRequest.ProtoReflect.Descriptor instead. func (*ListBurnsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{66} + return file_taprootassets_proto_rawDescGZIP(), []int{67} } func (x *ListBurnsRequest) GetAssetId() []byte { @@ -5457,7 +5548,7 @@ type AssetBurn struct { func (x *AssetBurn) Reset() { *x = AssetBurn{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[67] + mi := &file_taprootassets_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5470,7 +5561,7 @@ func (x *AssetBurn) String() string { func (*AssetBurn) ProtoMessage() {} func (x *AssetBurn) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[67] + mi := &file_taprootassets_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5483,7 +5574,7 @@ func (x *AssetBurn) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetBurn.ProtoReflect.Descriptor instead. func (*AssetBurn) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{67} + return file_taprootassets_proto_rawDescGZIP(), []int{68} } func (x *AssetBurn) GetNote() string { @@ -5532,7 +5623,7 @@ type ListBurnsResponse struct { func (x *ListBurnsResponse) Reset() { *x = ListBurnsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[68] + mi := &file_taprootassets_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5545,7 +5636,7 @@ func (x *ListBurnsResponse) String() string { func (*ListBurnsResponse) ProtoMessage() {} func (x *ListBurnsResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[68] + mi := &file_taprootassets_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5558,7 +5649,7 @@ func (x *ListBurnsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBurnsResponse.ProtoReflect.Descriptor instead. func (*ListBurnsResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{68} + return file_taprootassets_proto_rawDescGZIP(), []int{69} } func (x *ListBurnsResponse) GetBurns() []*AssetBurn { @@ -5582,7 +5673,7 @@ type OutPoint struct { func (x *OutPoint) Reset() { *x = OutPoint{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[69] + mi := &file_taprootassets_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5595,7 +5686,7 @@ func (x *OutPoint) String() string { func (*OutPoint) ProtoMessage() {} func (x *OutPoint) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[69] + mi := &file_taprootassets_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5608,7 +5699,7 @@ func (x *OutPoint) ProtoReflect() protoreflect.Message { // Deprecated: Use OutPoint.ProtoReflect.Descriptor instead. func (*OutPoint) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{69} + return file_taprootassets_proto_rawDescGZIP(), []int{70} } func (x *OutPoint) GetTxid() []byte { @@ -5641,7 +5732,7 @@ type SubscribeReceiveEventsRequest struct { func (x *SubscribeReceiveEventsRequest) Reset() { *x = SubscribeReceiveEventsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[70] + mi := &file_taprootassets_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5654,7 +5745,7 @@ func (x *SubscribeReceiveEventsRequest) String() string { func (*SubscribeReceiveEventsRequest) ProtoMessage() {} func (x *SubscribeReceiveEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[70] + mi := &file_taprootassets_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5667,7 +5758,7 @@ func (x *SubscribeReceiveEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubscribeReceiveEventsRequest.ProtoReflect.Descriptor instead. func (*SubscribeReceiveEventsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{70} + return file_taprootassets_proto_rawDescGZIP(), []int{71} } func (x *SubscribeReceiveEventsRequest) GetFilterAddr() string { @@ -5709,7 +5800,7 @@ type ReceiveEvent struct { func (x *ReceiveEvent) Reset() { *x = ReceiveEvent{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[71] + mi := &file_taprootassets_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5722,7 +5813,7 @@ func (x *ReceiveEvent) String() string { func (*ReceiveEvent) ProtoMessage() {} func (x *ReceiveEvent) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[71] + mi := &file_taprootassets_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5735,7 +5826,7 @@ func (x *ReceiveEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ReceiveEvent.ProtoReflect.Descriptor instead. func (*ReceiveEvent) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{71} + return file_taprootassets_proto_rawDescGZIP(), []int{72} } func (x *ReceiveEvent) GetTimestamp() int64 { @@ -5793,7 +5884,7 @@ type SubscribeSendEventsRequest struct { func (x *SubscribeSendEventsRequest) Reset() { *x = SubscribeSendEventsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[72] + mi := &file_taprootassets_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5806,7 +5897,7 @@ func (x *SubscribeSendEventsRequest) String() string { func (*SubscribeSendEventsRequest) ProtoMessage() {} func (x *SubscribeSendEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[72] + mi := &file_taprootassets_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5819,7 +5910,7 @@ func (x *SubscribeSendEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubscribeSendEventsRequest.ProtoReflect.Descriptor instead. func (*SubscribeSendEventsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{72} + return file_taprootassets_proto_rawDescGZIP(), []int{73} } func (x *SubscribeSendEventsRequest) GetFilterScriptKey() []byte { @@ -5865,7 +5956,7 @@ type SendEvent struct { func (x *SendEvent) Reset() { *x = SendEvent{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[73] + mi := &file_taprootassets_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5878,7 +5969,7 @@ func (x *SendEvent) String() string { func (*SendEvent) ProtoMessage() {} func (x *SendEvent) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[73] + mi := &file_taprootassets_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5891,7 +5982,7 @@ func (x *SendEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SendEvent.ProtoReflect.Descriptor instead. func (*SendEvent) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{73} + return file_taprootassets_proto_rawDescGZIP(), []int{74} } func (x *SendEvent) GetTimestamp() int64 { @@ -5981,7 +6072,7 @@ type AnchorTransaction struct { func (x *AnchorTransaction) Reset() { *x = AnchorTransaction{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[74] + mi := &file_taprootassets_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5994,7 +6085,7 @@ func (x *AnchorTransaction) String() string { func (*AnchorTransaction) ProtoMessage() {} func (x *AnchorTransaction) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[74] + mi := &file_taprootassets_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6007,7 +6098,7 @@ func (x *AnchorTransaction) ProtoReflect() protoreflect.Message { // Deprecated: Use AnchorTransaction.ProtoReflect.Descriptor instead. func (*AnchorTransaction) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{74} + return file_taprootassets_proto_rawDescGZIP(), []int{75} } func (x *AnchorTransaction) GetAnchorPsbt() []byte { @@ -6106,302 +6197,156 @@ var file_taprootassets_proto_rawDesc = []byte{ 0x79, 0x70, 0x65, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, - 0x78, 0x22, 0xc1, 0x01, 0x0a, 0x0f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2e, 0x0a, 0x07, 0x72, 0x61, 0x77, 0x5f, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x72, - 0x61, 0x77, 0x4b, 0x65, 0x79, 0x12, 0x3a, 0x0a, 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, - 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x0d, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, - 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, - 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x61, 0x70, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x65, 0x77, 0x5f, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6e, 0x65, 0x77, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x22, 0x3a, 0x0a, 0x05, 0x54, 0x78, 0x4f, 0x75, 0x74, 0x12, 0x14, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x6b, 0x5f, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x6b, 0x53, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x69, 0x72, 0x74, 0x75, - 0x61, 0x6c, 0x54, 0x78, 0x12, 0x20, 0x0a, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, - 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x08, 0x70, 0x72, 0x65, 0x76, 0x5f, 0x6f, - 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, - 0x63, 0x2e, 0x54, 0x78, 0x4f, 0x75, 0x74, 0x52, 0x07, 0x70, 0x72, 0x65, 0x76, 0x4f, 0x75, 0x74, - 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x64, 0x12, - 0x1f, 0x0a, 0x0b, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x4b, 0x65, 0x79, - 0x22, 0x47, 0x0a, 0x0c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, - 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x64, 0x12, - 0x18, 0x0a, 0x07, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, - 0x52, 0x07, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x22, 0xa8, 0x01, 0x0a, 0x0a, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x61, 0x77, 0x5f, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x0b, 0x72, 0x61, 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x11, - 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, - 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, + 0x78, 0x22, 0x79, 0x0a, 0x0b, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, + 0x12, 0x12, 0x0a, 0x04, 0x78, 0x70, 0x75, 0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x78, 0x70, 0x75, 0x62, 0x12, 0x2d, 0x0a, 0x12, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x66, + 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x11, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x46, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, + 0x69, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x72, 0x69, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x64, 0x65, + 0x72, 0x69, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x74, 0x68, 0x22, 0xf9, 0x01, 0x0a, + 0x0f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x2e, 0x0a, 0x07, 0x72, 0x61, 0x77, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x72, 0x61, 0x77, 0x4b, 0x65, 0x79, + 0x12, 0x3a, 0x0a, 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, + 0x69, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x61, + 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x25, 0x0a, 0x0e, + 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, + 0x6f, 0x6f, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x12, 0x36, 0x0a, 0x0c, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x65, 0x78, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x22, 0x3a, 0x0a, 0x05, 0x54, 0x78, 0x4f, 0x75, + 0x74, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x6b, 0x5f, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x6b, 0x53, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x69, + 0x72, 0x74, 0x75, 0x61, 0x6c, 0x54, 0x78, 0x12, 0x20, 0x0a, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x08, 0x70, 0x72, 0x65, + 0x76, 0x5f, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, + 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x78, 0x4f, 0x75, 0x74, 0x52, 0x07, 0x70, 0x72, 0x65, 0x76, + 0x4f, 0x75, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x69, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, + 0x4b, 0x65, 0x79, 0x22, 0x47, 0x0a, 0x0c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x57, 0x69, 0x74, 0x6e, + 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0c, 0x52, 0x07, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x22, 0xa8, 0x01, 0x0a, + 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x22, 0x0a, 0x0d, 0x72, + 0x61, 0x77, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x0b, 0x72, 0x61, 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, + 0x2a, 0x0a, 0x11, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x74, 0x77, 0x65, 0x61, + 0x6b, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, + 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, + 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x5b, 0x0a, 0x0e, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4b, 0x65, 0x79, 0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x61, 0x77, + 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0b, 0x72, 0x61, 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x5b, 0x0a, 0x0e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, - 0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x61, 0x77, 0x5f, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x72, - 0x61, 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x61, - 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x6f, 0x6f, - 0x74, 0x22, 0x54, 0x0a, 0x0d, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65, 0x76, 0x65, - 0x61, 0x6c, 0x12, 0x43, 0x0a, 0x13, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x62, 0x61, - 0x73, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x42, 0x61, 0x73, - 0x65, 0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x22, 0x39, 0x0a, 0x0e, 0x44, 0x65, 0x63, 0x69, 0x6d, - 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x63, - 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, - 0x61, 0x79, 0x22, 0xa1, 0x06, 0x0a, 0x05, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x2e, 0x0a, 0x07, - 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x0d, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, - 0x65, 0x73, 0x69, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x47, - 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, - 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x72, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, - 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x0d, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x09, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, - 0x2d, 0x0a, 0x13, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x73, - 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x73, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x12, 0x33, - 0x0a, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x0b, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x12, 0x35, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x61, 0x6e, 0x63, - 0x68, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, - 0x70, 0x63, 0x2e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x63, - 0x68, 0x61, 0x69, 0x6e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x3a, 0x0a, 0x0e, 0x70, 0x72, - 0x65, 0x76, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x65, 0x76, - 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x76, 0x57, 0x69, 0x74, - 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x73, 0x70, 0x65, - 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x53, 0x70, 0x65, 0x6e, - 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, - 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x4f, 0x77, 0x6e, - 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x69, - 0x72, 0x79, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x45, - 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x62, 0x75, 0x72, 0x6e, - 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x42, 0x75, 0x72, 0x6e, 0x12, 0x39, - 0x0a, 0x19, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x64, 0x65, 0x63, - 0x6c, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x18, 0x12, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x16, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x63, 0x6c, - 0x61, 0x72, 0x65, 0x64, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x12, 0x3a, 0x0a, 0x1a, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x68, 0x61, 0x73, 0x5f, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x48, 0x61, 0x73, 0x53, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3f, 0x0a, 0x0f, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, - 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, - 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, - 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x22, 0xa1, 0x01, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x76, 0x57, - 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x12, 0x2f, 0x0a, 0x07, 0x70, 0x72, 0x65, 0x76, 0x5f, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x50, 0x72, 0x65, 0x76, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, - 0x06, 0x70, 0x72, 0x65, 0x76, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x78, 0x5f, 0x77, 0x69, - 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09, 0x74, 0x78, 0x57, - 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, - 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x43, - 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0f, 0x73, 0x70, 0x6c, 0x69, 0x74, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x3f, 0x0a, 0x0f, 0x53, 0x70, - 0x6c, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x2c, 0x0a, - 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 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, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x22, 0x9c, 0x01, 0x0a, 0x11, - 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x25, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x33, 0x0a, 0x15, 0x75, 0x6e, 0x63, 0x6f, - 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, - 0x72, 0x6d, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x12, 0x2b, 0x0a, - 0x11, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x6d, 0x69, 0x6e, - 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, - 0x69, 0x72, 0x6d, 0x65, 0x64, 0x4d, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x39, 0x0a, 0x10, 0x4c, 0x69, - 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, - 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4c, - 0x65, 0x61, 0x73, 0x65, 0x64, 0x22, 0xa9, 0x02, 0x0a, 0x0b, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, - 0x64, 0x55, 0x74, 0x78, 0x6f, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x75, 0x74, 0x5f, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x50, 0x6f, 0x69, - 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x61, 0x6d, 0x74, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x06, 0x61, 0x6d, 0x74, 0x53, 0x61, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x2c, - 0x0a, 0x12, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, 0x72, - 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1f, 0x0a, 0x0b, - 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x0a, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x25, 0x0a, - 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x06, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x6f, 0x77, - 0x6e, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6c, 0x65, 0x61, 0x73, 0x65, - 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x65, - 0x78, 0x70, 0x69, 0x72, 0x79, 0x5f, 0x75, 0x6e, 0x69, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, 0x55, 0x6e, 0x69, - 0x78, 0x22, 0xbb, 0x01, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0d, 0x6d, 0x61, 0x6e, 0x61, 0x67, - 0x65, 0x64, 0x5f, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, - 0x64, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x6d, 0x61, 0x6e, - 0x61, 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x1a, 0x54, 0x0a, 0x11, 0x4d, 0x61, 0x6e, - 0x61, 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 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, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, - 0x55, 0x74, 0x78, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, - 0x13, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x22, 0x8d, 0x02, 0x0a, 0x12, 0x41, 0x73, 0x73, 0x65, 0x74, 0x48, 0x75, - 0x6d, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x61, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, - 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, - 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6c, 0x6f, 0x63, - 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, - 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x10, - 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, - 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x61, 0x73, 0x68, 0x12, 0x25, 0x0a, - 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x61, - 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, - 0x74, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, - 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x43, 0x0a, 0x0d, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x48, 0x75, 0x6d, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, - 0x65, 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, 0xa6, 0x01, 0x0a, 0x12, 0x4c, 0x69, - 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x3e, 0x0a, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x26, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, - 0x1a, 0x50, 0x0a, 0x0b, 0x47, 0x72, 0x6f, 0x75, 0x70, 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, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, - 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, - 0x38, 0x01, 0x22, 0xd1, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, - 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x08, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x07, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x46, 0x69, 0x6c, - 0x74, 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, - 0x65, 0x61, 0x73, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x69, 0x6e, 0x63, - 0x6c, 0x75, 0x64, 0x65, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x42, 0x0a, 0x0a, 0x08, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x79, 0x22, 0x62, 0x0a, 0x0c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x38, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, - 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x04, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x4a, 0x0a, 0x11, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 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, 0x18, 0x0a, 0x07, - 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x62, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x90, 0x03, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x42, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x56, 0x0a, 0x0e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, - 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x42, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x66, 0x0a, 0x14, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, - 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x12, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x1a, - 0x56, 0x0a, 0x12, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 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, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x60, 0x0a, 0x17, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 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, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x37, 0x0a, 0x14, 0x4c, 0x69, 0x73, - 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, - 0x69, 0x64, 0x22, 0x4c, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x09, 0x74, - 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, - 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, - 0x22, 0x3a, 0x0a, 0x09, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x12, 0x12, 0x0a, - 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, - 0x68, 0x12, 0x19, 0x0a, 0x08, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x68, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x22, 0xed, 0x02, 0x0a, - 0x0d, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x2d, - 0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, 0x72, 0x61, 0x6e, - 0x73, 0x66, 0x65, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x24, 0x0a, - 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x48, - 0x61, 0x73, 0x68, 0x12, 0x31, 0x0a, 0x15, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, - 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x12, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x48, 0x65, 0x69, 0x67, - 0x68, 0x74, 0x48, 0x69, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x14, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, - 0x5f, 0x74, 0x78, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x43, 0x68, - 0x61, 0x69, 0x6e, 0x46, 0x65, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, - 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x52, 0x06, - 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, - 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, - 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x14, 0x61, 0x6e, 0x63, 0x68, - 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x52, 0x11, 0x61, 0x6e, 0x63, 0x68, 0x6f, - 0x72, 0x54, 0x78, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x84, 0x01, 0x0a, - 0x0d, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x21, - 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 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, 0x12, 0x16, 0x0a, 0x06, 0x61, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, - 0x75, 0x6e, 0x74, 0x22, 0x95, 0x02, 0x0a, 0x14, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, - 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, - 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, + 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x54, 0x0a, 0x0d, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, + 0x65, 0x76, 0x65, 0x61, 0x6c, 0x12, 0x43, 0x0a, 0x13, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x5f, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, + 0x73, 0x69, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x22, 0x39, 0x0a, 0x0e, 0x44, 0x65, + 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x12, 0x27, 0x0a, 0x0f, + 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, + 0x73, 0x70, 0x6c, 0x61, 0x79, 0x22, 0xa1, 0x06, 0x0a, 0x05, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, + 0x2e, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x38, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2c, + 0x0a, 0x12, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, + 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x13, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, + 0x5f, 0x69, 0x73, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x10, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x73, 0x4c, 0x6f, 0x63, 0x61, + 0x6c, 0x12, 0x33, 0x0a, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x41, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x35, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, + 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, + 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x0b, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x3a, 0x0a, + 0x0e, 0x70, 0x72, 0x65, 0x76, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, + 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, + 0x72, 0x65, 0x76, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x76, + 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, + 0x73, 0x70, 0x65, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x53, + 0x70, 0x65, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x6f, 0x77, + 0x6e, 0x65, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x65, + 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6c, 0x65, 0x61, + 0x73, 0x65, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x62, + 0x75, 0x72, 0x6e, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x42, 0x75, 0x72, + 0x6e, 0x12, 0x39, 0x0a, 0x19, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, + 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x18, 0x12, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x44, + 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x64, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x12, 0x3a, 0x0a, 0x1a, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x68, 0x61, 0x73, 0x5f, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x16, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x48, 0x61, 0x73, 0x53, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3f, 0x0a, 0x0f, 0x64, 0x65, 0x63, 0x69, + 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x14, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x22, 0xa1, 0x01, 0x0a, 0x0b, 0x50, 0x72, + 0x65, 0x76, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x12, 0x2f, 0x0a, 0x07, 0x70, 0x72, 0x65, + 0x76, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x65, 0x76, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x73, 0x73, + 0x65, 0x74, 0x52, 0x06, 0x70, 0x72, 0x65, 0x76, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x78, + 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09, + 0x74, 0x78, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x73, 0x70, 0x6c, + 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x70, 0x6c, + 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0f, 0x73, 0x70, + 0x6c, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x3f, 0x0a, + 0x0f, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, + 0x12, 0x2c, 0x0a, 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 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, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x22, 0x9c, + 0x01, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, + 0x73, 0x65, 0x74, 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x33, 0x0a, 0x15, 0x75, + 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x75, 0x6e, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, + 0x12, 0x2b, 0x0a, 0x11, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, + 0x6d, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x75, 0x6e, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x4d, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x39, 0x0a, + 0x10, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, 0x65, 0x61, + 0x73, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x22, 0xa9, 0x02, 0x0a, 0x0b, 0x4d, 0x61, 0x6e, + 0x61, 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x75, 0x74, 0x5f, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, + 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x61, 0x6d, 0x74, 0x5f, 0x73, 0x61, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x61, 0x6d, 0x74, 0x53, 0x61, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x61, 0x73, 0x73, @@ -6409,589 +6354,746 @@ var file_taprootassets_proto_rawDesc = []byte{ 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, - 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x73, 0x69, - 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, - 0x12, 0x6e, 0x75, 0x6d, 0x5f, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x50, 0x61, - 0x73, 0x73, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, 0x93, 0x04, 0x0a, 0x0e, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x34, - 0x0a, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, - 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x52, 0x06, 0x61, 0x6e, - 0x63, 0x68, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, - 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x13, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, - 0x79, 0x5f, 0x69, 0x73, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x10, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x73, 0x4c, 0x6f, 0x63, - 0x61, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x65, - 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x62, 0x6c, 0x6f, 0x62, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x42, 0x6c, 0x6f, 0x62, - 0x12, 0x33, 0x0a, 0x16, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, - 0x52, 0x13, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x6f, 0x6f, - 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x33, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, - 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x12, 0x25, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, + 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x5f, 0x75, 0x6e, 0x69, 0x78, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, + 0x55, 0x6e, 0x69, 0x78, 0x22, 0xbb, 0x01, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, + 0x6f, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0d, 0x6d, 0x61, + 0x6e, 0x61, 0x67, 0x65, 0x64, 0x5f, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x2b, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, + 0x74, 0x78, 0x6f, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x61, 0x6e, + 0x61, 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, + 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x1a, 0x54, 0x0a, 0x11, + 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 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, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x6e, 0x61, + 0x67, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0x13, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x8d, 0x02, 0x0a, 0x12, 0x41, 0x73, 0x73, 0x65, + 0x74, 0x48, 0x75, 0x6d, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, + 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x6b, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, + 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x74, 0x61, 0x67, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x61, 0x73, 0x68, + 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x43, 0x0a, 0x0d, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x48, 0x75, 0x6d, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, + 0x61, 0x62, 0x6c, 0x65, 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, 0xa6, 0x01, 0x0a, + 0x12, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x73, 0x1a, 0x50, 0x0a, 0x0b, 0x47, 0x72, 0x6f, 0x75, 0x70, 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, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd1, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, + 0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, + 0x00, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x09, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, + 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x28, 0x0a, 0x10, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, + 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x42, 0x0a, 0x0a, + 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x79, 0x22, 0x62, 0x0a, 0x0c, 0x41, 0x73, 0x73, + 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x38, 0x0a, 0x0d, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, + 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x47, 0x65, 0x6e, 0x65, + 0x73, 0x69, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x4a, 0x0a, + 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 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, + 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, + 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x90, 0x03, 0x0a, 0x14, 0x4c, 0x69, + 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x56, 0x0a, 0x0e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x66, 0x0a, 0x14, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x12, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x1a, 0x56, 0x0a, 0x12, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 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, 0x2a, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x60, 0x0a, 0x17, 0x41, 0x73, + 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 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, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x41, 0x73, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x37, 0x0a, 0x14, + 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, + 0x78, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, + 0x72, 0x54, 0x78, 0x69, 0x64, 0x22, 0x4c, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, + 0x0a, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x73, 0x22, 0x3a, 0x0a, 0x09, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, + 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, + 0x68, 0x61, 0x73, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x68, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x22, + 0xed, 0x02, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x12, 0x2d, 0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x12, 0x24, 0x0a, 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x5f, 0x68, 0x61, + 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 0x54, 0x78, 0x48, 0x61, 0x73, 0x68, 0x12, 0x31, 0x0a, 0x15, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 0x5f, 0x74, 0x78, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x48, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x48, 0x69, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x14, 0x61, 0x6e, 0x63, + 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x66, 0x65, 0x65, + 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, + 0x78, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x46, 0x65, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x06, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x14, 0x61, + 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, + 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x52, 0x11, 0x61, 0x6e, + 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, + 0x84, 0x01, 0x0a, 0x0d, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 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, 0x12, 0x16, + 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x95, 0x02, 0x0a, 0x14, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, + 0x1a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x5f, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x10, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, + 0x6f, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x5f, 0x72, 0x6f, 0x6f, + 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, + 0x6f, 0x6f, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, + 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, + 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x75, 0x6d, 0x5f, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x5f, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x6e, 0x75, + 0x6d, 0x50, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, 0x93, + 0x04, 0x0a, 0x0e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x12, 0x34, 0x0a, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x52, + 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x13, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x73, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x73, + 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, 0x0a, + 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x62, 0x6c, 0x6f, 0x62, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x42, + 0x6c, 0x6f, 0x62, 0x12, 0x33, 0x0a, 0x16, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x13, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x52, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x33, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, + 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, + 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x6b, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6c, 0x6f, 0x63, + 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x4f, 0x0a, 0x15, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x64, 0x65, 0x6c, + 0x69, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x44, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x13, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x44, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x22, 0x0d, 0x0a, 0x0b, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x22, 0x0e, 0x0a, 0x0c, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x46, 0x0a, 0x11, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x68, 0x6f, 0x77, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x68, 0x6f, 0x77, 0x12, 0x1d, 0x0a, 0x0a, + 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x53, 0x70, 0x65, 0x63, 0x22, 0x35, 0x0a, 0x12, 0x44, + 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x75, 0x62, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x75, 0x62, 0x53, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x73, 0x22, 0xe6, 0x03, 0x0a, 0x04, 0x41, 0x64, 0x64, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x65, + 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, + 0x63, 0x6f, 0x64, 0x65, 0x64, 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, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, + 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, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x61, 0x70, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, + 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x12, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, + 0x74, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x4b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, + 0x75, 0x72, 0x69, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x43, 0x6f, 0x75, 0x72, 0x69, 0x65, 0x72, 0x41, 0x64, + 0x64, 0x72, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, + 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3c, 0x0a, + 0x0f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x41, 0x64, 0x64, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x8c, 0x01, 0x0a, 0x10, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x41, 0x66, 0x74, 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x37, 0x0a, 0x11, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x22, 0x0a, 0x05, 0x61, 0x64, 0x64, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x05, 0x61, 0x64, + 0x64, 0x72, 0x73, 0x22, 0xfd, 0x02, 0x0a, 0x0e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 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, 0x10, 0x0a, 0x03, 0x61, 0x6d, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, + 0x61, 0x6d, 0x74, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, + 0x2e, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x38, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, + 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x6f, 0x72, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, + 0x2b, 0x0a, 0x11, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x62, + 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x12, + 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x75, 0x72, 0x69, 0x65, 0x72, 0x5f, 0x61, 0x64, + 0x64, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x43, + 0x6f, 0x75, 0x72, 0x69, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, - 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x69, - 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6c, - 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x54, 0x69, 0x6d, 0x65, - 0x12, 0x4f, 0x0a, 0x15, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, - 0x72, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x44, 0x65, - 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x13, 0x70, 0x72, - 0x6f, 0x6f, 0x66, 0x44, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x22, 0x0d, 0x0a, 0x0b, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x22, 0x0e, 0x0a, 0x0c, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x46, 0x0a, 0x11, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x68, 0x6f, 0x77, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x68, 0x6f, 0x77, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x65, 0x76, - 0x65, 0x6c, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6c, - 0x65, 0x76, 0x65, 0x6c, 0x53, 0x70, 0x65, 0x63, 0x22, 0x35, 0x0a, 0x12, 0x44, 0x65, 0x62, 0x75, - 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, - 0x0a, 0x0b, 0x73, 0x75, 0x62, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x75, 0x62, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x22, - 0xe6, 0x03, 0x0a, 0x04, 0x41, 0x64, 0x64, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x63, 0x6f, - 0x64, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x63, 0x6f, 0x64, - 0x65, 0x64, 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, 0x30, 0x0a, - 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 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, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3c, 0x0a, 0x0f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x22, 0x73, 0x0a, 0x09, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, + 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x5f, 0x64, 0x65, 0x73, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, + 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x6f, 0x72, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x12, 0x1b, 0x0a, 0x09, 0x74, + 0x61, 0x70, 0x5f, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, + 0x74, 0x61, 0x70, 0x54, 0x77, 0x65, 0x61, 0x6b, 0x22, 0x48, 0x0a, 0x0a, 0x4b, 0x65, 0x79, 0x4c, + 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x61, + 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6b, 0x65, 0x79, 0x46, + 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x49, 0x6e, 0x64, + 0x65, 0x78, 0x22, 0x60, 0x0a, 0x0d, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x61, 0x77, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, + 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x72, 0x61, 0x77, 0x4b, + 0x65, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x07, 0x6b, 0x65, 0x79, 0x5f, 0x6c, + 0x6f, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6b, 0x65, + 0x79, 0x4c, 0x6f, 0x63, 0x22, 0x43, 0x0a, 0x11, 0x54, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x46, 0x75, 0x6c, 0x6c, 0x54, 0x72, 0x65, 0x65, 0x12, 0x2e, 0x0a, 0x0a, 0x61, 0x6c, 0x6c, + 0x5f, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x09, + 0x61, 0x6c, 0x6c, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x21, 0x0a, 0x07, 0x54, 0x61, 0x70, + 0x4c, 0x65, 0x61, 0x66, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x53, 0x0a, 0x09, + 0x54, 0x61, 0x70, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x65, 0x66, + 0x74, 0x5f, 0x74, 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0b, 0x6c, 0x65, 0x66, 0x74, 0x54, 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x74, 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x54, 0x61, 0x70, 0x68, 0x61, 0x73, + 0x68, 0x22, 0x27, 0x0a, 0x11, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x64, 0x64, 0x72, 0x22, 0x56, 0x0a, 0x09, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x61, 0x77, 0x5f, 0x70, + 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0c, 0x72, 0x61, 0x77, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 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, 0x22, 0xf6, 0x04, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x12, 0x24, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x61, 0x74, 0x5f, + 0x64, 0x65, 0x70, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x70, 0x72, 0x6f, + 0x6f, 0x66, 0x41, 0x74, 0x44, 0x65, 0x70, 0x74, 0x68, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x4f, 0x66, 0x50, 0x72, 0x6f, + 0x6f, 0x66, 0x73, 0x12, 0x23, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 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, 0x32, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, + 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x04, 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, 0x26, 0x0a, 0x0f, + 0x74, 0x78, 0x5f, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x78, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x50, + 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, + 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x29, 0x0a, + 0x10, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x70, 0x6c, 0x69, + 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x0e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x50, 0x72, 0x6f, + 0x6f, 0x66, 0x12, 0x32, 0x0a, 0x15, 0x6e, 0x75, 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x13, 0x6e, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, + 0x6e, 0x67, 0x65, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, + 0x0c, 0x52, 0x10, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x57, 0x69, 0x74, 0x6e, + 0x65, 0x73, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x62, 0x75, 0x72, 0x6e, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x42, 0x75, 0x72, 0x6e, 0x12, 0x3c, 0x0a, 0x0e, + 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x0c, + 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, 0x0d, + 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, 0x12, 0x1d, 0x0a, 0x0a, + 0x61, 0x6c, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x09, 0x61, 0x6c, 0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x66, 0x0a, 0x13, 0x56, + 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x39, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x6f, + 0x64, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x22, 0xb1, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x61, + 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, + 0x61, 0x77, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x24, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x5f, 0x61, 0x74, 0x5f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x41, 0x74, 0x44, 0x65, 0x70, 0x74, 0x68, 0x12, 0x2e, 0x0a, + 0x13, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x70, 0x72, 0x65, 0x76, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, + 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x77, 0x69, 0x74, 0x68, + 0x50, 0x72, 0x65, 0x76, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x28, 0x0a, + 0x10, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, + 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x77, 0x69, 0x74, 0x68, 0x4d, 0x65, 0x74, + 0x61, 0x52, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x22, 0x50, 0x0a, 0x13, 0x44, 0x65, 0x63, 0x6f, 0x64, + 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, + 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, + 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x0c, 0x64, 0x65, 0x63, + 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x7c, 0x0a, 0x12, 0x45, 0x78, 0x70, + 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 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, 0x1d, 0x0a, 0x0a, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x08, 0x6f, 0x75, 0x74, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x61, + 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x6f, + 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0xd0, 0x02, 0x0a, 0x09, 0x41, 0x64, 0x64, 0x72, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x1a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x78, 0x5f, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x17, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x6e, 0x69, 0x78, 0x53, 0x65, 0x63, 0x6f, 0x6e, + 0x64, 0x73, 0x12, 0x20, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x04, + 0x61, 0x64, 0x64, 0x72, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, + 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x12, 0x20, 0x0a, 0x0c, 0x75, 0x74, 0x78, 0x6f, 0x5f, 0x61, 0x6d, 0x74, 0x5f, 0x73, 0x61, + 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x75, 0x74, 0x78, 0x6f, 0x41, 0x6d, 0x74, + 0x53, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x73, + 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x74, 0x61, + 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x53, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x2f, 0x0a, 0x13, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1b, 0x0a, + 0x09, 0x68, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x08, 0x68, 0x61, 0x73, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x74, 0x0a, 0x13, 0x41, 0x64, + 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x41, 0x64, + 0x64, 0x72, 0x12, 0x3c, 0x0a, 0x0d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x0c, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x22, 0x41, 0x0a, 0x14, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x73, 0x22, 0x4a, 0x0a, 0x10, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x70, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x70, 0x41, + 0x64, 0x64, 0x72, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x22, + 0x85, 0x01, 0x0a, 0x0e, 0x50, 0x72, 0x65, 0x76, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x73, 0x73, + 0x65, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 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, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, - 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, - 0x65, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, - 0x6b, 0x65, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x69, 0x62, 0x6c, - 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x12, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6f, - 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x10, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x4b, 0x65, - 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x75, 0x72, 0x69, - 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, - 0x72, 0x6f, 0x6f, 0x66, 0x43, 0x6f, 0x75, 0x72, 0x69, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, - 0x39, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3c, 0x0a, 0x0f, 0x61, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0c, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, - 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x8c, 0x01, 0x0a, 0x10, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, - 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x66, 0x74, - 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x65, - 0x66, 0x6f, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, - 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x37, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x05, - 0x61, 0x64, 0x64, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x74, 0x61, - 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x05, 0x61, 0x64, 0x64, 0x72, 0x73, - 0x22, 0xfd, 0x02, 0x0a, 0x0e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 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, 0x10, - 0x0a, 0x03, 0x61, 0x6d, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x61, 0x6d, 0x74, - 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, - 0x65, 0x79, 0x12, 0x38, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, - 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, - 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, - 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x11, - 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, 0x6e, - 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x53, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, - 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x75, 0x72, 0x69, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x43, 0x6f, 0x75, 0x72, - 0x69, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x3c, 0x0a, 0x0f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x76, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x74, 0x61, - 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x52, 0x0e, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x22, 0x73, 0x0a, 0x09, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x17, 0x0a, - 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, - 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x64, 0x65, - 0x73, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, - 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, - 0x07, 0x6b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x70, 0x5f, - 0x74, 0x77, 0x65, 0x61, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x74, 0x61, 0x70, - 0x54, 0x77, 0x65, 0x61, 0x6b, 0x22, 0x48, 0x0a, 0x0a, 0x4b, 0x65, 0x79, 0x4c, 0x6f, 0x63, 0x61, - 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6b, 0x65, 0x79, 0x46, 0x61, 0x6d, 0x69, - 0x6c, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, - 0x60, 0x0a, 0x0d, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x61, 0x77, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x72, 0x61, 0x77, 0x4b, 0x65, 0x79, 0x42, - 0x79, 0x74, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x07, 0x6b, 0x65, 0x79, 0x5f, 0x6c, 0x6f, 0x63, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, - 0x65, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6b, 0x65, 0x79, 0x4c, 0x6f, - 0x63, 0x22, 0x43, 0x0a, 0x11, 0x54, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x46, 0x75, - 0x6c, 0x6c, 0x54, 0x72, 0x65, 0x65, 0x12, 0x2e, 0x0a, 0x0a, 0x61, 0x6c, 0x6c, 0x5f, 0x6c, 0x65, - 0x61, 0x76, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x09, 0x61, 0x6c, 0x6c, - 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x21, 0x0a, 0x07, 0x54, 0x61, 0x70, 0x4c, 0x65, 0x61, - 0x66, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x53, 0x0a, 0x09, 0x54, 0x61, 0x70, - 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x65, 0x66, 0x74, 0x5f, 0x74, - 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x6c, 0x65, - 0x66, 0x74, 0x54, 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x5f, 0x74, 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, - 0x52, 0x0c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x54, 0x61, 0x70, 0x68, 0x61, 0x73, 0x68, 0x22, 0x27, - 0x0a, 0x11, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x61, 0x64, 0x64, 0x72, 0x22, 0x56, 0x0a, 0x09, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x61, 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, - 0x66, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x61, - 0x77, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 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, 0x22, - 0xf6, 0x04, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x12, 0x24, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x61, 0x74, 0x5f, 0x64, 0x65, 0x70, - 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x41, - 0x74, 0x44, 0x65, 0x70, 0x74, 0x68, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, - 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, - 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x4f, 0x66, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, - 0x12, 0x23, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 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, 0x32, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x72, 0x65, - 0x76, 0x65, 0x61, 0x6c, 0x18, 0x04, 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, 0x26, 0x0a, 0x0f, 0x74, 0x78, 0x5f, - 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0d, 0x74, 0x78, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x6f, - 0x66, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, - 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, - 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x78, - 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x07, - 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, - 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x5f, 0x72, - 0x6f, 0x6f, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x0e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, - 0x32, 0x0a, 0x15, 0x6e, 0x75, 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, - 0x6e, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x70, - 0x75, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, - 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x10, - 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, - 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x62, 0x75, 0x72, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x06, 0x69, 0x73, 0x42, 0x75, 0x72, 0x6e, 0x12, 0x3c, 0x0a, 0x0e, 0x67, 0x65, 0x6e, - 0x65, 0x73, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x0c, 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, 0x0d, 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, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6c, 0x74, - 0x5f, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x61, - 0x6c, 0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x66, 0x0a, 0x13, 0x56, 0x65, 0x72, 0x69, - 0x66, 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, - 0x76, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x39, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, - 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, - 0x6f, 0x66, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x22, 0xb1, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x61, 0x77, 0x5f, 0x70, - 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x61, 0x77, 0x50, - 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x24, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x61, 0x74, - 0x5f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x70, 0x72, - 0x6f, 0x6f, 0x66, 0x41, 0x74, 0x44, 0x65, 0x70, 0x74, 0x68, 0x12, 0x2e, 0x0a, 0x13, 0x77, 0x69, - 0x74, 0x68, 0x5f, 0x70, 0x72, 0x65, 0x76, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, - 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x77, 0x69, 0x74, 0x68, 0x50, 0x72, 0x65, - 0x76, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x77, 0x69, - 0x74, 0x68, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x77, 0x69, 0x74, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, - 0x76, 0x65, 0x61, 0x6c, 0x22, 0x50, 0x0a, 0x13, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0d, 0x64, - 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, - 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, - 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x7c, 0x0a, 0x12, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, - 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 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, 0x1d, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, - 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x22, 0xd0, 0x02, 0x0a, 0x09, 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x1a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, - 0x69, 0x6d, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x78, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x17, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x54, 0x69, 0x6d, 0x65, 0x55, 0x6e, 0x69, 0x78, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, - 0x20, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x04, 0x61, 0x64, 0x64, - 0x72, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x45, - 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x20, - 0x0a, 0x0c, 0x75, 0x74, 0x78, 0x6f, 0x5f, 0x61, 0x6d, 0x74, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x75, 0x74, 0x78, 0x6f, 0x41, 0x6d, 0x74, 0x53, 0x61, 0x74, - 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x73, 0x69, 0x62, 0x6c, - 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x74, 0x61, 0x70, 0x72, 0x6f, - 0x6f, 0x74, 0x53, 0x69, 0x62, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x68, 0x61, - 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x68, - 0x61, 0x73, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x74, 0x0a, 0x13, 0x41, 0x64, 0x64, 0x72, 0x52, - 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, - 0x0a, 0x0b, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, - 0x3c, 0x0a, 0x0d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, - 0x0c, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x41, 0x0a, - 0x14, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, - 0x22, 0x4a, 0x0a, 0x10, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x70, 0x5f, 0x61, 0x64, 0x64, 0x72, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x70, 0x41, 0x64, 0x64, 0x72, - 0x73, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0d, 0x52, 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x22, 0x85, 0x01, 0x0a, - 0x0e, 0x50, 0x72, 0x65, 0x76, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, - 0x21, 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 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, 0x12, 0x16, 0x0a, 0x06, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x46, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x08, 0x74, 0x72, 0x61, + 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x46, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x41, + 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x08, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x22, + 0x10, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x22, 0x9b, 0x02, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x1f, 0x0a, 0x0b, 0x6c, 0x6e, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6c, 0x6e, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x18, 0x0a, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x6e, + 0x64, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6c, 0x6e, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x6f, + 0x64, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x6e, 0x6f, 0x64, 0x65, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, + 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 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, 0x07, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0d, 0x73, + 0x79, 0x6e, 0x63, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x54, 0x6f, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x22, + 0xa6, 0x01, 0x0a, 0x15, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, + 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 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, 0x1d, 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, + 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x48, 0x61, 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, + 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x24, 0x0a, 0x0d, 0x6d, 0x65, 0x74, + 0x61, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x42, + 0x07, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0xc3, 0x01, 0x0a, 0x10, 0x42, 0x75, 0x72, + 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 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, 0x24, + 0x0a, 0x0e, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x62, 0x75, 0x72, 0x6e, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x6f, + 0x42, 0x75, 0x72, 0x6e, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x65, 0x78, + 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x84, + 0x01, 0x0a, 0x11, 0x42, 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x0d, 0x62, 0x75, 0x72, 0x6e, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x22, 0x10, 0x0a, 0x0e, - 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x9b, - 0x02, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, - 0x6c, 0x6e, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0a, 0x6c, 0x6e, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, - 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x6e, 0x64, 0x5f, 0x69, - 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6c, 0x6e, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x5f, - 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x6f, 0x64, - 0x65, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, - 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 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, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, - 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x79, 0x6e, 0x63, - 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x54, 0x6f, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x22, 0xa6, 0x01, 0x0a, - 0x15, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 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, 0x1d, 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, 0x61, 0x73, 0x68, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x61, - 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x73, - 0x74, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x24, 0x0a, 0x0d, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x68, - 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, - 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x48, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x42, 0x07, 0x0a, 0x05, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0xc3, 0x01, 0x0a, 0x10, 0x42, 0x75, 0x72, 0x6e, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 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, 0x24, 0x0a, 0x0e, 0x61, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x62, 0x75, 0x72, 0x6e, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x0c, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x6f, 0x42, 0x75, 0x72, - 0x6e, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x6f, - 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x65, 0x78, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x6f, - 0x74, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x84, 0x01, 0x0a, 0x11, - 0x42, 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x3a, 0x0a, 0x0d, 0x62, 0x75, 0x72, 0x6e, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, - 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, - 0x0c, 0x62, 0x75, 0x72, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x33, 0x0a, - 0x0a, 0x62, 0x75, 0x72, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x64, - 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x09, 0x62, 0x75, 0x72, 0x6e, 0x50, 0x72, 0x6f, - 0x6f, 0x66, 0x22, 0x7a, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 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, 0x2a, 0x0a, 0x11, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x74, 0x77, - 0x65, 0x61, 0x6b, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, - 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x69, 0x64, 0x22, 0x9f, - 0x01, 0x0a, 0x09, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x12, 0x12, 0x0a, 0x04, - 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x6f, 0x74, 0x65, - 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, 0x2a, 0x0a, 0x11, 0x74, - 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, - 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, - 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x69, 0x64, - 0x22, 0x3c, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x05, 0x62, 0x75, 0x72, 0x6e, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x52, 0x05, 0x62, 0x75, 0x72, 0x6e, 0x73, 0x22, 0x41, - 0x0a, 0x08, 0x4f, 0x75, 0x74, 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, 0x22, 0x69, 0x0a, 0x1d, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, - 0x63, 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, - 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x41, - 0x64, 0x64, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xe8, 0x01, 0x0a, - 0x0c, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, - 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x26, 0x0a, 0x07, 0x61, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, - 0x2f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x63, - 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, - 0x74, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x48, 0x0a, 0x1a, 0x53, 0x75, 0x62, 0x73, 0x63, - 0x72, 0x69, 0x62, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, - 0x52, 0x0f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, - 0x79, 0x22, 0x9d, 0x03, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, - 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1d, 0x0a, - 0x0a, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x73, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x0b, - 0x70, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x72, 0x63, 0x65, - 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x2a, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, - 0x64, 0x72, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x27, 0x0a, - 0x0f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, - 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0e, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, - 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, - 0x65, 0x5f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, - 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x15, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, - 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x48, - 0x0a, 0x12, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x72, 0x61, - 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x0a, 0x08, 0x74, 0x72, 0x61, 0x6e, - 0x73, 0x66, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, - 0x72, 0x52, 0x08, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x65, - 0x72, 0x72, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, - 0x72, 0x22, 0x97, 0x02, 0x0a, 0x11, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x6e, - 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, - 0x72, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x61, 0x6e, - 0x63, 0x68, 0x6f, 0x72, 0x50, 0x73, 0x62, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x75, 0x74, - 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x26, 0x0a, 0x0f, 0x63, 0x68, 0x61, 0x69, - 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x5f, 0x73, 0x61, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0d, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x46, 0x65, 0x65, 0x73, 0x53, 0x61, 0x74, 0x73, - 0x12, 0x32, 0x0a, 0x16, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x72, - 0x61, 0x74, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x5f, 0x6b, 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x12, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x53, - 0x61, 0x74, 0x4b, 0x77, 0x12, 0x3a, 0x0a, 0x10, 0x6c, 0x6e, 0x64, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, - 0x65, 0x64, 0x5f, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, - 0x52, 0x0e, 0x6c, 0x6e, 0x64, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x74, 0x78, 0x6f, 0x73, - 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x74, 0x78, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x07, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x78, 0x2a, 0x28, 0x0a, 0x09, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x4f, 0x52, 0x4d, - 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x4f, 0x4c, 0x4c, 0x45, 0x43, 0x54, 0x49, - 0x42, 0x4c, 0x45, 0x10, 0x01, 0x2a, 0x39, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, - 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x10, 0x4d, 0x45, 0x54, 0x41, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x50, 0x41, 0x51, 0x55, 0x45, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, - 0x4d, 0x45, 0x54, 0x41, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4a, 0x53, 0x4f, 0x4e, 0x10, 0x01, - 0x2a, 0x3a, 0x0a, 0x0c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x12, 0x14, 0x0a, 0x10, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, - 0x4e, 0x5f, 0x56, 0x30, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, - 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x31, 0x10, 0x01, 0x2a, 0x52, 0x0a, 0x0a, - 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x12, 0x4f, 0x55, - 0x54, 0x50, 0x55, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4d, 0x50, 0x4c, 0x45, - 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x4f, 0x55, 0x54, 0x50, 0x55, 0x54, 0x5f, 0x54, 0x59, 0x50, - 0x45, 0x5f, 0x53, 0x50, 0x4c, 0x49, 0x54, 0x5f, 0x52, 0x4f, 0x4f, 0x54, 0x10, 0x01, 0x22, 0x04, - 0x08, 0x02, 0x10, 0x02, 0x22, 0x04, 0x08, 0x03, 0x10, 0x03, 0x22, 0x04, 0x08, 0x04, 0x10, 0x04, - 0x2a, 0x86, 0x01, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x44, 0x65, 0x6c, 0x69, 0x76, 0x65, - 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x28, 0x0a, 0x24, 0x50, 0x52, 0x4f, 0x4f, - 0x46, 0x5f, 0x44, 0x45, 0x4c, 0x49, 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, - 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, - 0x10, 0x00, 0x12, 0x22, 0x0a, 0x1e, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x44, 0x45, 0x4c, 0x49, - 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x4d, 0x50, - 0x4c, 0x45, 0x54, 0x45, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, - 0x44, 0x45, 0x4c, 0x49, 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, - 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x2a, 0x55, 0x0a, 0x0b, 0x41, 0x64, 0x64, - 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x18, 0x41, 0x44, 0x44, 0x52, - 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, - 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x56, - 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x30, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x41, - 0x44, 0x44, 0x52, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x31, 0x10, 0x02, - 0x2a, 0xd0, 0x01, 0x0a, 0x0f, 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, - 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, - 0x4e, 0x10, 0x00, 0x12, 0x2a, 0x0a, 0x26, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, 0x4e, - 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x41, 0x43, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x54, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x01, 0x12, - 0x2b, 0x0a, 0x27, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, - 0x41, 0x54, 0x55, 0x53, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x45, 0x44, 0x10, 0x02, 0x12, 0x24, 0x0a, 0x20, - 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, - 0x53, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x52, 0x45, 0x43, 0x45, 0x49, 0x56, 0x45, 0x44, - 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, - 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, - 0x44, 0x10, 0x04, 0x2a, 0x9b, 0x02, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x12, 0x23, 0x0a, 0x1f, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, - 0x56, 0x49, 0x52, 0x54, 0x55, 0x41, 0x4c, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x5f, 0x53, 0x45, - 0x4c, 0x45, 0x43, 0x54, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, - 0x54, 0x41, 0x54, 0x45, 0x5f, 0x56, 0x49, 0x52, 0x54, 0x55, 0x41, 0x4c, 0x5f, 0x53, 0x49, 0x47, - 0x4e, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x45, 0x5f, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x10, 0x02, 0x12, - 0x1d, 0x0a, 0x19, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4c, 0x4f, - 0x47, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x10, 0x03, 0x12, 0x18, - 0x0a, 0x14, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x42, 0x52, 0x4f, - 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x10, 0x04, 0x12, 0x20, 0x0a, 0x1c, 0x53, 0x45, 0x4e, 0x44, - 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x57, 0x41, 0x49, 0x54, 0x5f, 0x43, 0x4f, 0x4e, 0x46, - 0x49, 0x52, 0x4d, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x05, 0x12, 0x1b, 0x0a, 0x17, 0x53, 0x45, - 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x54, 0x4f, 0x52, 0x45, 0x5f, 0x50, - 0x52, 0x4f, 0x4f, 0x46, 0x53, 0x10, 0x06, 0x12, 0x1e, 0x0a, 0x1a, 0x53, 0x45, 0x4e, 0x44, 0x5f, - 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x46, 0x45, 0x52, 0x5f, 0x50, - 0x52, 0x4f, 0x4f, 0x46, 0x53, 0x10, 0x07, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x45, 0x4e, 0x44, 0x5f, - 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x10, - 0x08, 0x2a, 0x78, 0x0a, 0x0a, 0x50, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x17, 0x0a, 0x13, 0x50, 0x41, 0x52, 0x43, 0x45, 0x4c, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, - 0x44, 0x44, 0x52, 0x45, 0x53, 0x53, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x41, 0x52, 0x43, - 0x45, 0x4c, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x45, 0x5f, 0x53, 0x49, 0x47, 0x4e, - 0x45, 0x44, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x41, 0x52, 0x43, 0x45, 0x4c, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x1c, 0x0a, - 0x18, 0x50, 0x41, 0x52, 0x43, 0x45, 0x4c, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x45, - 0x5f, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x45, 0x44, 0x10, 0x03, 0x32, 0x9a, 0x0b, 0x0a, 0x0d, - 0x54, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x41, 0x0a, - 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x18, 0x2e, 0x74, 0x61, - 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x40, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x12, 0x18, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, - 0x12, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x74, 0x61, - 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x42, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x73, 0x12, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, - 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x37, 0x0a, 0x0a, 0x53, 0x74, 0x6f, 0x70, 0x44, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x12, 0x13, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x6f, - 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0a, 0x44, 0x65, 0x62, - 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, - 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x62, 0x75, - 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, - 0x0a, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x73, 0x12, 0x18, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x12, 0x16, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, - 0x64, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, - 0x12, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, - 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0c, 0x2e, 0x74, 0x61, - 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x12, 0x49, 0x0a, 0x0c, 0x41, 0x64, 0x64, - 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x65, 0x72, 0x52, 0x0c, 0x62, 0x75, 0x72, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x12, 0x33, 0x0a, 0x0a, 0x62, 0x75, 0x72, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, + 0x63, 0x6f, 0x64, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x09, 0x62, 0x75, 0x72, 0x6e, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x7a, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 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, 0x2a, 0x0a, 0x11, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0f, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, + 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x69, + 0x64, 0x22, 0x9f, 0x01, 0x0a, 0x09, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x6f, 0x74, 0x65, 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, 0x2a, + 0x0a, 0x11, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x74, 0x77, 0x65, 0x61, 0x6b, + 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, 0x69, + 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, + 0x78, 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x05, 0x62, 0x75, 0x72, 0x6e, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, + 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x52, 0x05, 0x62, 0x75, 0x72, 0x6e, + 0x73, 0x22, 0x41, 0x0a, 0x08, 0x4f, 0x75, 0x74, 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, 0x22, 0x69, 0x0a, 0x1d, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, + 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, + 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, + 0xe8, 0x01, 0x0a, 0x0c, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x26, + 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x07, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x48, 0x0a, 0x1a, 0x53, 0x75, + 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x5f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x4b, 0x65, 0x79, 0x22, 0x9d, 0x03, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x33, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, + 0x72, 0x63, 0x65, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x63, 0x65, 0x6c, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, + 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, + 0x12, 0x27, 0x0a, 0x0f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0e, 0x76, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x70, 0x61, 0x73, + 0x73, 0x69, 0x76, 0x65, 0x5f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x15, 0x70, 0x61, 0x73, 0x73, + 0x69, 0x76, 0x65, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x73, 0x12, 0x48, 0x0a, 0x12, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x0a, 0x08, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x14, + 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x22, 0x97, 0x02, 0x0a, 0x11, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6e, + 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x50, 0x73, 0x62, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x26, 0x0a, 0x0f, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x5f, 0x73, 0x61, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x46, 0x65, 0x65, 0x73, 0x53, + 0x61, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x16, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x65, + 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x5f, 0x6b, 0x77, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x12, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x65, 0x65, 0x52, 0x61, + 0x74, 0x65, 0x53, 0x61, 0x74, 0x4b, 0x77, 0x12, 0x3a, 0x0a, 0x10, 0x6c, 0x6e, 0x64, 0x5f, 0x6c, + 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, + 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x6c, 0x6e, 0x64, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x55, 0x74, + 0x78, 0x6f, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x74, 0x78, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x78, 0x2a, 0x28, + 0x0a, 0x09, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x4e, + 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x4f, 0x4c, 0x4c, 0x45, + 0x43, 0x54, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x2a, 0x39, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, + 0x74, 0x4d, 0x65, 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x10, 0x4d, 0x45, 0x54, + 0x41, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x50, 0x41, 0x51, 0x55, 0x45, 0x10, 0x00, 0x12, + 0x12, 0x0a, 0x0e, 0x4d, 0x45, 0x54, 0x41, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4a, 0x53, 0x4f, + 0x4e, 0x10, 0x01, 0x2a, 0x3a, 0x0a, 0x0c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x10, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x56, 0x45, 0x52, + 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x30, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x41, 0x53, 0x53, + 0x45, 0x54, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x31, 0x10, 0x01, 0x2a, + 0x52, 0x0a, 0x0a, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, + 0x12, 0x4f, 0x55, 0x54, 0x50, 0x55, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4d, + 0x50, 0x4c, 0x45, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x4f, 0x55, 0x54, 0x50, 0x55, 0x54, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x50, 0x4c, 0x49, 0x54, 0x5f, 0x52, 0x4f, 0x4f, 0x54, 0x10, + 0x01, 0x22, 0x04, 0x08, 0x02, 0x10, 0x02, 0x22, 0x04, 0x08, 0x03, 0x10, 0x03, 0x22, 0x04, 0x08, + 0x04, 0x10, 0x04, 0x2a, 0x86, 0x01, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x44, 0x65, 0x6c, + 0x69, 0x76, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x28, 0x0a, 0x24, 0x50, + 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x44, 0x45, 0x4c, 0x49, 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, + 0x41, 0x54, 0x55, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, 0x41, + 0x42, 0x4c, 0x45, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x1e, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x44, + 0x45, 0x4c, 0x49, 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, + 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x50, 0x52, 0x4f, + 0x4f, 0x46, 0x5f, 0x44, 0x45, 0x4c, 0x49, 0x56, 0x45, 0x52, 0x59, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x55, 0x53, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x2a, 0x55, 0x0a, 0x0b, + 0x41, 0x64, 0x64, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x18, 0x41, + 0x44, 0x44, 0x52, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x41, 0x44, 0x44, + 0x52, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x30, 0x10, 0x01, 0x12, 0x13, + 0x0a, 0x0f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, + 0x31, 0x10, 0x02, 0x2a, 0xd0, 0x01, 0x0a, 0x0f, 0x41, 0x64, 0x64, 0x72, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x44, 0x44, 0x52, 0x5f, + 0x45, 0x56, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x4b, + 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x2a, 0x0a, 0x26, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, + 0x56, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x54, 0x52, 0x41, 0x4e, + 0x53, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x54, 0x45, 0x43, 0x54, 0x45, 0x44, + 0x10, 0x01, 0x12, 0x2b, 0x0a, 0x27, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x41, 0x43, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x45, 0x44, 0x10, 0x02, 0x12, + 0x24, 0x0a, 0x20, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, + 0x41, 0x54, 0x55, 0x53, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x52, 0x45, 0x43, 0x45, 0x49, + 0x56, 0x45, 0x44, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x45, 0x56, + 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, + 0x45, 0x54, 0x45, 0x44, 0x10, 0x04, 0x2a, 0x9b, 0x02, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x64, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x1f, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, + 0x54, 0x45, 0x5f, 0x56, 0x49, 0x52, 0x54, 0x55, 0x41, 0x4c, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, + 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x53, 0x45, 0x4e, + 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x56, 0x49, 0x52, 0x54, 0x55, 0x41, 0x4c, 0x5f, + 0x53, 0x49, 0x47, 0x4e, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x45, 0x5f, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x5f, 0x53, 0x49, 0x47, 0x4e, + 0x10, 0x02, 0x12, 0x1d, 0x0a, 0x19, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x10, + 0x03, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, + 0x42, 0x52, 0x4f, 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x10, 0x04, 0x12, 0x20, 0x0a, 0x1c, 0x53, + 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x57, 0x41, 0x49, 0x54, 0x5f, 0x43, + 0x4f, 0x4e, 0x46, 0x49, 0x52, 0x4d, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x05, 0x12, 0x1b, 0x0a, + 0x17, 0x53, 0x45, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x54, 0x4f, 0x52, + 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x53, 0x10, 0x06, 0x12, 0x1e, 0x0a, 0x1a, 0x53, 0x45, + 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x46, 0x45, + 0x52, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x53, 0x10, 0x07, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x45, + 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, + 0x45, 0x44, 0x10, 0x08, 0x2a, 0x78, 0x0a, 0x0a, 0x50, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x41, 0x52, 0x43, 0x45, 0x4c, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x45, 0x53, 0x53, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x50, + 0x41, 0x52, 0x43, 0x45, 0x4c, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x45, 0x5f, 0x53, + 0x49, 0x47, 0x4e, 0x45, 0x44, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x41, 0x52, 0x43, 0x45, + 0x4c, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, + 0x12, 0x1c, 0x0a, 0x18, 0x50, 0x41, 0x52, 0x43, 0x45, 0x4c, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x50, 0x52, 0x45, 0x5f, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x45, 0x44, 0x10, 0x03, 0x32, 0x9a, + 0x0b, 0x0a, 0x0d, 0x54, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, + 0x12, 0x41, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x18, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, + 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, + 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, + 0x12, 0x18, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, + 0x78, 0x6f, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x74, 0x78, 0x6f, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x73, 0x12, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x4c, 0x69, + 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x12, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x37, 0x0a, 0x0a, 0x53, 0x74, 0x6f, 0x70, 0x44, 0x61, 0x65, 0x6d, 0x6f, + 0x6e, 0x12, 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0a, + 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x19, 0x2e, 0x74, 0x61, 0x70, + 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, + 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x41, 0x0a, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x73, 0x12, + 0x18, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, + 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x12, + 0x16, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, + 0x2e, 0x41, 0x64, 0x64, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x41, + 0x64, 0x64, 0x72, 0x12, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, + 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0c, + 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x12, 0x49, 0x0a, 0x0c, + 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x74, + 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x64, 0x64, 0x72, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x12, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, - 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 0x1a, 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, - 0x6f, 0x66, 0x12, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, - 0x64, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, - 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x0b, 0x45, - 0x78, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x1a, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x56, 0x65, 0x72, 0x69, 0x66, + 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 0x1a, 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, + 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x64, + 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, + 0x0a, 0x0b, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x1a, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, + 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x40, 0x0a, 0x09, + 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x18, 0x2e, 0x74, 0x61, 0x70, 0x72, + 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, + 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, + 0x0a, 0x09, 0x42, 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x18, 0x2e, 0x74, 0x61, + 0x70, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x42, + 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x40, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x12, 0x18, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, + 0x0a, 0x0e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, + 0x12, 0x1d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, + 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, + 0x74, 0x61, 0x12, 0x57, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, + 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x25, 0x2e, 0x74, + 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, + 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x12, 0x4e, 0x0a, 0x13, 0x53, + 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x73, 0x12, 0x22, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x73, + 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x40, 0x0a, 0x09, 0x53, 0x65, 0x6e, - 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x18, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x09, 0x42, - 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x18, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, - 0x63, 0x2e, 0x42, 0x75, 0x72, 0x6e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x75, 0x72, 0x6e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, - 0x09, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x12, 0x18, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x3a, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0e, 0x46, - 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x1d, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x12, - 0x57, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x63, 0x65, - 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x25, 0x2e, 0x74, 0x61, 0x70, 0x72, - 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x63, 0x65, - 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x14, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, - 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x12, 0x4e, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x73, - 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, - 0x22, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, - 0x62, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, - 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 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, + 0x53, 0x65, 0x6e, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 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 ( @@ -7007,7 +7109,7 @@ func file_taprootassets_proto_rawDescGZIP() []byte { } var file_taprootassets_proto_enumTypes = make([]protoimpl.EnumInfo, 9) -var file_taprootassets_proto_msgTypes = make([]protoimpl.MessageInfo, 79) +var file_taprootassets_proto_msgTypes = make([]protoimpl.MessageInfo, 80) var file_taprootassets_proto_goTypes = []interface{}{ (AssetType)(0), // 0: taprpc.AssetType (AssetMetaType)(0), // 1: taprpc.AssetMetaType @@ -7022,200 +7124,202 @@ var file_taprootassets_proto_goTypes = []interface{}{ (*ListAssetRequest)(nil), // 10: taprpc.ListAssetRequest (*AnchorInfo)(nil), // 11: taprpc.AnchorInfo (*GenesisInfo)(nil), // 12: taprpc.GenesisInfo - (*GroupKeyRequest)(nil), // 13: taprpc.GroupKeyRequest - (*TxOut)(nil), // 14: taprpc.TxOut - (*GroupVirtualTx)(nil), // 15: taprpc.GroupVirtualTx - (*GroupWitness)(nil), // 16: taprpc.GroupWitness - (*AssetGroup)(nil), // 17: taprpc.AssetGroup - (*GroupKeyReveal)(nil), // 18: taprpc.GroupKeyReveal - (*GenesisReveal)(nil), // 19: taprpc.GenesisReveal - (*DecimalDisplay)(nil), // 20: taprpc.DecimalDisplay - (*Asset)(nil), // 21: taprpc.Asset - (*PrevWitness)(nil), // 22: taprpc.PrevWitness - (*SplitCommitment)(nil), // 23: taprpc.SplitCommitment - (*ListAssetResponse)(nil), // 24: taprpc.ListAssetResponse - (*ListUtxosRequest)(nil), // 25: taprpc.ListUtxosRequest - (*ManagedUtxo)(nil), // 26: taprpc.ManagedUtxo - (*ListUtxosResponse)(nil), // 27: taprpc.ListUtxosResponse - (*ListGroupsRequest)(nil), // 28: taprpc.ListGroupsRequest - (*AssetHumanReadable)(nil), // 29: taprpc.AssetHumanReadable - (*GroupedAssets)(nil), // 30: taprpc.GroupedAssets - (*ListGroupsResponse)(nil), // 31: taprpc.ListGroupsResponse - (*ListBalancesRequest)(nil), // 32: taprpc.ListBalancesRequest - (*AssetBalance)(nil), // 33: taprpc.AssetBalance - (*AssetGroupBalance)(nil), // 34: taprpc.AssetGroupBalance - (*ListBalancesResponse)(nil), // 35: taprpc.ListBalancesResponse - (*ListTransfersRequest)(nil), // 36: taprpc.ListTransfersRequest - (*ListTransfersResponse)(nil), // 37: taprpc.ListTransfersResponse - (*ChainHash)(nil), // 38: taprpc.ChainHash - (*AssetTransfer)(nil), // 39: taprpc.AssetTransfer - (*TransferInput)(nil), // 40: taprpc.TransferInput - (*TransferOutputAnchor)(nil), // 41: taprpc.TransferOutputAnchor - (*TransferOutput)(nil), // 42: taprpc.TransferOutput - (*StopRequest)(nil), // 43: taprpc.StopRequest - (*StopResponse)(nil), // 44: taprpc.StopResponse - (*DebugLevelRequest)(nil), // 45: taprpc.DebugLevelRequest - (*DebugLevelResponse)(nil), // 46: taprpc.DebugLevelResponse - (*Addr)(nil), // 47: taprpc.Addr - (*QueryAddrRequest)(nil), // 48: taprpc.QueryAddrRequest - (*QueryAddrResponse)(nil), // 49: taprpc.QueryAddrResponse - (*NewAddrRequest)(nil), // 50: taprpc.NewAddrRequest - (*ScriptKey)(nil), // 51: taprpc.ScriptKey - (*KeyLocator)(nil), // 52: taprpc.KeyLocator - (*KeyDescriptor)(nil), // 53: taprpc.KeyDescriptor - (*TapscriptFullTree)(nil), // 54: taprpc.TapscriptFullTree - (*TapLeaf)(nil), // 55: taprpc.TapLeaf - (*TapBranch)(nil), // 56: taprpc.TapBranch - (*DecodeAddrRequest)(nil), // 57: taprpc.DecodeAddrRequest - (*ProofFile)(nil), // 58: taprpc.ProofFile - (*DecodedProof)(nil), // 59: taprpc.DecodedProof - (*VerifyProofResponse)(nil), // 60: taprpc.VerifyProofResponse - (*DecodeProofRequest)(nil), // 61: taprpc.DecodeProofRequest - (*DecodeProofResponse)(nil), // 62: taprpc.DecodeProofResponse - (*ExportProofRequest)(nil), // 63: taprpc.ExportProofRequest - (*AddrEvent)(nil), // 64: taprpc.AddrEvent - (*AddrReceivesRequest)(nil), // 65: taprpc.AddrReceivesRequest - (*AddrReceivesResponse)(nil), // 66: taprpc.AddrReceivesResponse - (*SendAssetRequest)(nil), // 67: taprpc.SendAssetRequest - (*PrevInputAsset)(nil), // 68: taprpc.PrevInputAsset - (*SendAssetResponse)(nil), // 69: taprpc.SendAssetResponse - (*GetInfoRequest)(nil), // 70: taprpc.GetInfoRequest - (*GetInfoResponse)(nil), // 71: taprpc.GetInfoResponse - (*FetchAssetMetaRequest)(nil), // 72: taprpc.FetchAssetMetaRequest - (*BurnAssetRequest)(nil), // 73: taprpc.BurnAssetRequest - (*BurnAssetResponse)(nil), // 74: taprpc.BurnAssetResponse - (*ListBurnsRequest)(nil), // 75: taprpc.ListBurnsRequest - (*AssetBurn)(nil), // 76: taprpc.AssetBurn - (*ListBurnsResponse)(nil), // 77: taprpc.ListBurnsResponse - (*OutPoint)(nil), // 78: taprpc.OutPoint - (*SubscribeReceiveEventsRequest)(nil), // 79: taprpc.SubscribeReceiveEventsRequest - (*ReceiveEvent)(nil), // 80: taprpc.ReceiveEvent - (*SubscribeSendEventsRequest)(nil), // 81: taprpc.SubscribeSendEventsRequest - (*SendEvent)(nil), // 82: taprpc.SendEvent - (*AnchorTransaction)(nil), // 83: taprpc.AnchorTransaction - nil, // 84: taprpc.ListUtxosResponse.ManagedUtxosEntry - nil, // 85: taprpc.ListGroupsResponse.GroupsEntry - nil, // 86: taprpc.ListBalancesResponse.AssetBalancesEntry - nil, // 87: taprpc.ListBalancesResponse.AssetGroupBalancesEntry + (*ExternalKey)(nil), // 13: taprpc.ExternalKey + (*GroupKeyRequest)(nil), // 14: taprpc.GroupKeyRequest + (*TxOut)(nil), // 15: taprpc.TxOut + (*GroupVirtualTx)(nil), // 16: taprpc.GroupVirtualTx + (*GroupWitness)(nil), // 17: taprpc.GroupWitness + (*AssetGroup)(nil), // 18: taprpc.AssetGroup + (*GroupKeyReveal)(nil), // 19: taprpc.GroupKeyReveal + (*GenesisReveal)(nil), // 20: taprpc.GenesisReveal + (*DecimalDisplay)(nil), // 21: taprpc.DecimalDisplay + (*Asset)(nil), // 22: taprpc.Asset + (*PrevWitness)(nil), // 23: taprpc.PrevWitness + (*SplitCommitment)(nil), // 24: taprpc.SplitCommitment + (*ListAssetResponse)(nil), // 25: taprpc.ListAssetResponse + (*ListUtxosRequest)(nil), // 26: taprpc.ListUtxosRequest + (*ManagedUtxo)(nil), // 27: taprpc.ManagedUtxo + (*ListUtxosResponse)(nil), // 28: taprpc.ListUtxosResponse + (*ListGroupsRequest)(nil), // 29: taprpc.ListGroupsRequest + (*AssetHumanReadable)(nil), // 30: taprpc.AssetHumanReadable + (*GroupedAssets)(nil), // 31: taprpc.GroupedAssets + (*ListGroupsResponse)(nil), // 32: taprpc.ListGroupsResponse + (*ListBalancesRequest)(nil), // 33: taprpc.ListBalancesRequest + (*AssetBalance)(nil), // 34: taprpc.AssetBalance + (*AssetGroupBalance)(nil), // 35: taprpc.AssetGroupBalance + (*ListBalancesResponse)(nil), // 36: taprpc.ListBalancesResponse + (*ListTransfersRequest)(nil), // 37: taprpc.ListTransfersRequest + (*ListTransfersResponse)(nil), // 38: taprpc.ListTransfersResponse + (*ChainHash)(nil), // 39: taprpc.ChainHash + (*AssetTransfer)(nil), // 40: taprpc.AssetTransfer + (*TransferInput)(nil), // 41: taprpc.TransferInput + (*TransferOutputAnchor)(nil), // 42: taprpc.TransferOutputAnchor + (*TransferOutput)(nil), // 43: taprpc.TransferOutput + (*StopRequest)(nil), // 44: taprpc.StopRequest + (*StopResponse)(nil), // 45: taprpc.StopResponse + (*DebugLevelRequest)(nil), // 46: taprpc.DebugLevelRequest + (*DebugLevelResponse)(nil), // 47: taprpc.DebugLevelResponse + (*Addr)(nil), // 48: taprpc.Addr + (*QueryAddrRequest)(nil), // 49: taprpc.QueryAddrRequest + (*QueryAddrResponse)(nil), // 50: taprpc.QueryAddrResponse + (*NewAddrRequest)(nil), // 51: taprpc.NewAddrRequest + (*ScriptKey)(nil), // 52: taprpc.ScriptKey + (*KeyLocator)(nil), // 53: taprpc.KeyLocator + (*KeyDescriptor)(nil), // 54: taprpc.KeyDescriptor + (*TapscriptFullTree)(nil), // 55: taprpc.TapscriptFullTree + (*TapLeaf)(nil), // 56: taprpc.TapLeaf + (*TapBranch)(nil), // 57: taprpc.TapBranch + (*DecodeAddrRequest)(nil), // 58: taprpc.DecodeAddrRequest + (*ProofFile)(nil), // 59: taprpc.ProofFile + (*DecodedProof)(nil), // 60: taprpc.DecodedProof + (*VerifyProofResponse)(nil), // 61: taprpc.VerifyProofResponse + (*DecodeProofRequest)(nil), // 62: taprpc.DecodeProofRequest + (*DecodeProofResponse)(nil), // 63: taprpc.DecodeProofResponse + (*ExportProofRequest)(nil), // 64: taprpc.ExportProofRequest + (*AddrEvent)(nil), // 65: taprpc.AddrEvent + (*AddrReceivesRequest)(nil), // 66: taprpc.AddrReceivesRequest + (*AddrReceivesResponse)(nil), // 67: taprpc.AddrReceivesResponse + (*SendAssetRequest)(nil), // 68: taprpc.SendAssetRequest + (*PrevInputAsset)(nil), // 69: taprpc.PrevInputAsset + (*SendAssetResponse)(nil), // 70: taprpc.SendAssetResponse + (*GetInfoRequest)(nil), // 71: taprpc.GetInfoRequest + (*GetInfoResponse)(nil), // 72: taprpc.GetInfoResponse + (*FetchAssetMetaRequest)(nil), // 73: taprpc.FetchAssetMetaRequest + (*BurnAssetRequest)(nil), // 74: taprpc.BurnAssetRequest + (*BurnAssetResponse)(nil), // 75: taprpc.BurnAssetResponse + (*ListBurnsRequest)(nil), // 76: taprpc.ListBurnsRequest + (*AssetBurn)(nil), // 77: taprpc.AssetBurn + (*ListBurnsResponse)(nil), // 78: taprpc.ListBurnsResponse + (*OutPoint)(nil), // 79: taprpc.OutPoint + (*SubscribeReceiveEventsRequest)(nil), // 80: taprpc.SubscribeReceiveEventsRequest + (*ReceiveEvent)(nil), // 81: taprpc.ReceiveEvent + (*SubscribeSendEventsRequest)(nil), // 82: taprpc.SubscribeSendEventsRequest + (*SendEvent)(nil), // 83: taprpc.SendEvent + (*AnchorTransaction)(nil), // 84: taprpc.AnchorTransaction + nil, // 85: taprpc.ListUtxosResponse.ManagedUtxosEntry + nil, // 86: taprpc.ListGroupsResponse.GroupsEntry + nil, // 87: taprpc.ListBalancesResponse.AssetBalancesEntry + nil, // 88: taprpc.ListBalancesResponse.AssetGroupBalancesEntry } var file_taprootassets_proto_depIdxs = []int32{ 1, // 0: taprpc.AssetMeta.type:type_name -> taprpc.AssetMetaType 0, // 1: taprpc.GenesisInfo.asset_type:type_name -> taprpc.AssetType - 53, // 2: taprpc.GroupKeyRequest.raw_key:type_name -> taprpc.KeyDescriptor + 54, // 2: taprpc.GroupKeyRequest.raw_key:type_name -> taprpc.KeyDescriptor 12, // 3: taprpc.GroupKeyRequest.anchor_genesis:type_name -> taprpc.GenesisInfo - 14, // 4: taprpc.GroupVirtualTx.prev_out:type_name -> taprpc.TxOut - 12, // 5: taprpc.GenesisReveal.genesis_base_reveal:type_name -> taprpc.GenesisInfo - 2, // 6: taprpc.Asset.version:type_name -> taprpc.AssetVersion - 12, // 7: taprpc.Asset.asset_genesis:type_name -> taprpc.GenesisInfo - 17, // 8: taprpc.Asset.asset_group:type_name -> taprpc.AssetGroup - 11, // 9: taprpc.Asset.chain_anchor:type_name -> taprpc.AnchorInfo - 22, // 10: taprpc.Asset.prev_witnesses:type_name -> taprpc.PrevWitness - 20, // 11: taprpc.Asset.decimal_display:type_name -> taprpc.DecimalDisplay - 68, // 12: taprpc.PrevWitness.prev_id:type_name -> taprpc.PrevInputAsset - 23, // 13: taprpc.PrevWitness.split_commitment:type_name -> taprpc.SplitCommitment - 21, // 14: taprpc.SplitCommitment.root_asset:type_name -> taprpc.Asset - 21, // 15: taprpc.ListAssetResponse.assets:type_name -> taprpc.Asset - 21, // 16: taprpc.ManagedUtxo.assets:type_name -> taprpc.Asset - 84, // 17: taprpc.ListUtxosResponse.managed_utxos:type_name -> taprpc.ListUtxosResponse.ManagedUtxosEntry - 0, // 18: taprpc.AssetHumanReadable.type:type_name -> taprpc.AssetType - 2, // 19: taprpc.AssetHumanReadable.version:type_name -> taprpc.AssetVersion - 29, // 20: taprpc.GroupedAssets.assets:type_name -> taprpc.AssetHumanReadable - 85, // 21: taprpc.ListGroupsResponse.groups:type_name -> taprpc.ListGroupsResponse.GroupsEntry - 12, // 22: taprpc.AssetBalance.asset_genesis:type_name -> taprpc.GenesisInfo - 86, // 23: taprpc.ListBalancesResponse.asset_balances:type_name -> taprpc.ListBalancesResponse.AssetBalancesEntry - 87, // 24: taprpc.ListBalancesResponse.asset_group_balances:type_name -> taprpc.ListBalancesResponse.AssetGroupBalancesEntry - 39, // 25: taprpc.ListTransfersResponse.transfers:type_name -> taprpc.AssetTransfer - 40, // 26: taprpc.AssetTransfer.inputs:type_name -> taprpc.TransferInput - 42, // 27: taprpc.AssetTransfer.outputs:type_name -> taprpc.TransferOutput - 38, // 28: taprpc.AssetTransfer.anchor_tx_block_hash:type_name -> taprpc.ChainHash - 41, // 29: taprpc.TransferOutput.anchor:type_name -> taprpc.TransferOutputAnchor - 3, // 30: taprpc.TransferOutput.output_type:type_name -> taprpc.OutputType - 2, // 31: taprpc.TransferOutput.asset_version:type_name -> taprpc.AssetVersion - 4, // 32: taprpc.TransferOutput.proof_delivery_status:type_name -> taprpc.ProofDeliveryStatus - 0, // 33: taprpc.Addr.asset_type:type_name -> taprpc.AssetType - 2, // 34: taprpc.Addr.asset_version:type_name -> taprpc.AssetVersion - 5, // 35: taprpc.Addr.address_version:type_name -> taprpc.AddrVersion - 47, // 36: taprpc.QueryAddrResponse.addrs:type_name -> taprpc.Addr - 51, // 37: taprpc.NewAddrRequest.script_key:type_name -> taprpc.ScriptKey - 53, // 38: taprpc.NewAddrRequest.internal_key:type_name -> taprpc.KeyDescriptor - 2, // 39: taprpc.NewAddrRequest.asset_version:type_name -> taprpc.AssetVersion - 5, // 40: taprpc.NewAddrRequest.address_version:type_name -> taprpc.AddrVersion - 53, // 41: taprpc.ScriptKey.key_desc:type_name -> taprpc.KeyDescriptor - 52, // 42: taprpc.KeyDescriptor.key_loc:type_name -> taprpc.KeyLocator - 55, // 43: taprpc.TapscriptFullTree.all_leaves:type_name -> taprpc.TapLeaf - 21, // 44: taprpc.DecodedProof.asset:type_name -> taprpc.Asset - 9, // 45: taprpc.DecodedProof.meta_reveal:type_name -> taprpc.AssetMeta - 19, // 46: taprpc.DecodedProof.genesis_reveal:type_name -> taprpc.GenesisReveal - 18, // 47: taprpc.DecodedProof.group_key_reveal:type_name -> taprpc.GroupKeyReveal - 59, // 48: taprpc.VerifyProofResponse.decoded_proof:type_name -> taprpc.DecodedProof - 59, // 49: taprpc.DecodeProofResponse.decoded_proof:type_name -> taprpc.DecodedProof - 78, // 50: taprpc.ExportProofRequest.outpoint:type_name -> taprpc.OutPoint - 47, // 51: taprpc.AddrEvent.addr:type_name -> taprpc.Addr - 6, // 52: taprpc.AddrEvent.status:type_name -> taprpc.AddrEventStatus - 6, // 53: taprpc.AddrReceivesRequest.filter_status:type_name -> taprpc.AddrEventStatus - 64, // 54: taprpc.AddrReceivesResponse.events:type_name -> taprpc.AddrEvent - 39, // 55: taprpc.SendAssetResponse.transfer:type_name -> taprpc.AssetTransfer - 39, // 56: taprpc.BurnAssetResponse.burn_transfer:type_name -> taprpc.AssetTransfer - 59, // 57: taprpc.BurnAssetResponse.burn_proof:type_name -> taprpc.DecodedProof - 76, // 58: taprpc.ListBurnsResponse.burns:type_name -> taprpc.AssetBurn - 47, // 59: taprpc.ReceiveEvent.address:type_name -> taprpc.Addr - 6, // 60: taprpc.ReceiveEvent.status:type_name -> taprpc.AddrEventStatus - 8, // 61: taprpc.SendEvent.parcel_type:type_name -> taprpc.ParcelType - 47, // 62: taprpc.SendEvent.addresses:type_name -> taprpc.Addr - 83, // 63: taprpc.SendEvent.anchor_transaction:type_name -> taprpc.AnchorTransaction - 39, // 64: taprpc.SendEvent.transfer:type_name -> taprpc.AssetTransfer - 78, // 65: taprpc.AnchorTransaction.lnd_locked_utxos:type_name -> taprpc.OutPoint - 26, // 66: taprpc.ListUtxosResponse.ManagedUtxosEntry.value:type_name -> taprpc.ManagedUtxo - 30, // 67: taprpc.ListGroupsResponse.GroupsEntry.value:type_name -> taprpc.GroupedAssets - 33, // 68: taprpc.ListBalancesResponse.AssetBalancesEntry.value:type_name -> taprpc.AssetBalance - 34, // 69: taprpc.ListBalancesResponse.AssetGroupBalancesEntry.value:type_name -> taprpc.AssetGroupBalance - 10, // 70: taprpc.TaprootAssets.ListAssets:input_type -> taprpc.ListAssetRequest - 25, // 71: taprpc.TaprootAssets.ListUtxos:input_type -> taprpc.ListUtxosRequest - 28, // 72: taprpc.TaprootAssets.ListGroups:input_type -> taprpc.ListGroupsRequest - 32, // 73: taprpc.TaprootAssets.ListBalances:input_type -> taprpc.ListBalancesRequest - 36, // 74: taprpc.TaprootAssets.ListTransfers:input_type -> taprpc.ListTransfersRequest - 43, // 75: taprpc.TaprootAssets.StopDaemon:input_type -> taprpc.StopRequest - 45, // 76: taprpc.TaprootAssets.DebugLevel:input_type -> taprpc.DebugLevelRequest - 48, // 77: taprpc.TaprootAssets.QueryAddrs:input_type -> taprpc.QueryAddrRequest - 50, // 78: taprpc.TaprootAssets.NewAddr:input_type -> taprpc.NewAddrRequest - 57, // 79: taprpc.TaprootAssets.DecodeAddr:input_type -> taprpc.DecodeAddrRequest - 65, // 80: taprpc.TaprootAssets.AddrReceives:input_type -> taprpc.AddrReceivesRequest - 58, // 81: taprpc.TaprootAssets.VerifyProof:input_type -> taprpc.ProofFile - 61, // 82: taprpc.TaprootAssets.DecodeProof:input_type -> taprpc.DecodeProofRequest - 63, // 83: taprpc.TaprootAssets.ExportProof:input_type -> taprpc.ExportProofRequest - 67, // 84: taprpc.TaprootAssets.SendAsset:input_type -> taprpc.SendAssetRequest - 73, // 85: taprpc.TaprootAssets.BurnAsset:input_type -> taprpc.BurnAssetRequest - 75, // 86: taprpc.TaprootAssets.ListBurns:input_type -> taprpc.ListBurnsRequest - 70, // 87: taprpc.TaprootAssets.GetInfo:input_type -> taprpc.GetInfoRequest - 72, // 88: taprpc.TaprootAssets.FetchAssetMeta:input_type -> taprpc.FetchAssetMetaRequest - 79, // 89: taprpc.TaprootAssets.SubscribeReceiveEvents:input_type -> taprpc.SubscribeReceiveEventsRequest - 81, // 90: taprpc.TaprootAssets.SubscribeSendEvents:input_type -> taprpc.SubscribeSendEventsRequest - 24, // 91: taprpc.TaprootAssets.ListAssets:output_type -> taprpc.ListAssetResponse - 27, // 92: taprpc.TaprootAssets.ListUtxos:output_type -> taprpc.ListUtxosResponse - 31, // 93: taprpc.TaprootAssets.ListGroups:output_type -> taprpc.ListGroupsResponse - 35, // 94: taprpc.TaprootAssets.ListBalances:output_type -> taprpc.ListBalancesResponse - 37, // 95: taprpc.TaprootAssets.ListTransfers:output_type -> taprpc.ListTransfersResponse - 44, // 96: taprpc.TaprootAssets.StopDaemon:output_type -> taprpc.StopResponse - 46, // 97: taprpc.TaprootAssets.DebugLevel:output_type -> taprpc.DebugLevelResponse - 49, // 98: taprpc.TaprootAssets.QueryAddrs:output_type -> taprpc.QueryAddrResponse - 47, // 99: taprpc.TaprootAssets.NewAddr:output_type -> taprpc.Addr - 47, // 100: taprpc.TaprootAssets.DecodeAddr:output_type -> taprpc.Addr - 66, // 101: taprpc.TaprootAssets.AddrReceives:output_type -> taprpc.AddrReceivesResponse - 60, // 102: taprpc.TaprootAssets.VerifyProof:output_type -> taprpc.VerifyProofResponse - 62, // 103: taprpc.TaprootAssets.DecodeProof:output_type -> taprpc.DecodeProofResponse - 58, // 104: taprpc.TaprootAssets.ExportProof:output_type -> taprpc.ProofFile - 69, // 105: taprpc.TaprootAssets.SendAsset:output_type -> taprpc.SendAssetResponse - 74, // 106: taprpc.TaprootAssets.BurnAsset:output_type -> taprpc.BurnAssetResponse - 77, // 107: taprpc.TaprootAssets.ListBurns:output_type -> taprpc.ListBurnsResponse - 71, // 108: taprpc.TaprootAssets.GetInfo:output_type -> taprpc.GetInfoResponse - 9, // 109: taprpc.TaprootAssets.FetchAssetMeta:output_type -> taprpc.AssetMeta - 80, // 110: taprpc.TaprootAssets.SubscribeReceiveEvents:output_type -> taprpc.ReceiveEvent - 82, // 111: taprpc.TaprootAssets.SubscribeSendEvents:output_type -> taprpc.SendEvent - 91, // [91:112] is the sub-list for method output_type - 70, // [70:91] is the sub-list for method input_type - 70, // [70:70] is the sub-list for extension type_name - 70, // [70:70] is the sub-list for extension extendee - 0, // [0:70] is the sub-list for field type_name + 13, // 4: taprpc.GroupKeyRequest.external_key:type_name -> taprpc.ExternalKey + 15, // 5: taprpc.GroupVirtualTx.prev_out:type_name -> taprpc.TxOut + 12, // 6: taprpc.GenesisReveal.genesis_base_reveal:type_name -> taprpc.GenesisInfo + 2, // 7: taprpc.Asset.version:type_name -> taprpc.AssetVersion + 12, // 8: taprpc.Asset.asset_genesis:type_name -> taprpc.GenesisInfo + 18, // 9: taprpc.Asset.asset_group:type_name -> taprpc.AssetGroup + 11, // 10: taprpc.Asset.chain_anchor:type_name -> taprpc.AnchorInfo + 23, // 11: taprpc.Asset.prev_witnesses:type_name -> taprpc.PrevWitness + 21, // 12: taprpc.Asset.decimal_display:type_name -> taprpc.DecimalDisplay + 69, // 13: taprpc.PrevWitness.prev_id:type_name -> taprpc.PrevInputAsset + 24, // 14: taprpc.PrevWitness.split_commitment:type_name -> taprpc.SplitCommitment + 22, // 15: taprpc.SplitCommitment.root_asset:type_name -> taprpc.Asset + 22, // 16: taprpc.ListAssetResponse.assets:type_name -> taprpc.Asset + 22, // 17: taprpc.ManagedUtxo.assets:type_name -> taprpc.Asset + 85, // 18: taprpc.ListUtxosResponse.managed_utxos:type_name -> taprpc.ListUtxosResponse.ManagedUtxosEntry + 0, // 19: taprpc.AssetHumanReadable.type:type_name -> taprpc.AssetType + 2, // 20: taprpc.AssetHumanReadable.version:type_name -> taprpc.AssetVersion + 30, // 21: taprpc.GroupedAssets.assets:type_name -> taprpc.AssetHumanReadable + 86, // 22: taprpc.ListGroupsResponse.groups:type_name -> taprpc.ListGroupsResponse.GroupsEntry + 12, // 23: taprpc.AssetBalance.asset_genesis:type_name -> taprpc.GenesisInfo + 87, // 24: taprpc.ListBalancesResponse.asset_balances:type_name -> taprpc.ListBalancesResponse.AssetBalancesEntry + 88, // 25: taprpc.ListBalancesResponse.asset_group_balances:type_name -> taprpc.ListBalancesResponse.AssetGroupBalancesEntry + 40, // 26: taprpc.ListTransfersResponse.transfers:type_name -> taprpc.AssetTransfer + 41, // 27: taprpc.AssetTransfer.inputs:type_name -> taprpc.TransferInput + 43, // 28: taprpc.AssetTransfer.outputs:type_name -> taprpc.TransferOutput + 39, // 29: taprpc.AssetTransfer.anchor_tx_block_hash:type_name -> taprpc.ChainHash + 42, // 30: taprpc.TransferOutput.anchor:type_name -> taprpc.TransferOutputAnchor + 3, // 31: taprpc.TransferOutput.output_type:type_name -> taprpc.OutputType + 2, // 32: taprpc.TransferOutput.asset_version:type_name -> taprpc.AssetVersion + 4, // 33: taprpc.TransferOutput.proof_delivery_status:type_name -> taprpc.ProofDeliveryStatus + 0, // 34: taprpc.Addr.asset_type:type_name -> taprpc.AssetType + 2, // 35: taprpc.Addr.asset_version:type_name -> taprpc.AssetVersion + 5, // 36: taprpc.Addr.address_version:type_name -> taprpc.AddrVersion + 48, // 37: taprpc.QueryAddrResponse.addrs:type_name -> taprpc.Addr + 52, // 38: taprpc.NewAddrRequest.script_key:type_name -> taprpc.ScriptKey + 54, // 39: taprpc.NewAddrRequest.internal_key:type_name -> taprpc.KeyDescriptor + 2, // 40: taprpc.NewAddrRequest.asset_version:type_name -> taprpc.AssetVersion + 5, // 41: taprpc.NewAddrRequest.address_version:type_name -> taprpc.AddrVersion + 54, // 42: taprpc.ScriptKey.key_desc:type_name -> taprpc.KeyDescriptor + 53, // 43: taprpc.KeyDescriptor.key_loc:type_name -> taprpc.KeyLocator + 56, // 44: taprpc.TapscriptFullTree.all_leaves:type_name -> taprpc.TapLeaf + 22, // 45: taprpc.DecodedProof.asset:type_name -> taprpc.Asset + 9, // 46: taprpc.DecodedProof.meta_reveal:type_name -> taprpc.AssetMeta + 20, // 47: taprpc.DecodedProof.genesis_reveal:type_name -> taprpc.GenesisReveal + 19, // 48: taprpc.DecodedProof.group_key_reveal:type_name -> taprpc.GroupKeyReveal + 60, // 49: taprpc.VerifyProofResponse.decoded_proof:type_name -> taprpc.DecodedProof + 60, // 50: taprpc.DecodeProofResponse.decoded_proof:type_name -> taprpc.DecodedProof + 79, // 51: taprpc.ExportProofRequest.outpoint:type_name -> taprpc.OutPoint + 48, // 52: taprpc.AddrEvent.addr:type_name -> taprpc.Addr + 6, // 53: taprpc.AddrEvent.status:type_name -> taprpc.AddrEventStatus + 6, // 54: taprpc.AddrReceivesRequest.filter_status:type_name -> taprpc.AddrEventStatus + 65, // 55: taprpc.AddrReceivesResponse.events:type_name -> taprpc.AddrEvent + 40, // 56: taprpc.SendAssetResponse.transfer:type_name -> taprpc.AssetTransfer + 40, // 57: taprpc.BurnAssetResponse.burn_transfer:type_name -> taprpc.AssetTransfer + 60, // 58: taprpc.BurnAssetResponse.burn_proof:type_name -> taprpc.DecodedProof + 77, // 59: taprpc.ListBurnsResponse.burns:type_name -> taprpc.AssetBurn + 48, // 60: taprpc.ReceiveEvent.address:type_name -> taprpc.Addr + 6, // 61: taprpc.ReceiveEvent.status:type_name -> taprpc.AddrEventStatus + 8, // 62: taprpc.SendEvent.parcel_type:type_name -> taprpc.ParcelType + 48, // 63: taprpc.SendEvent.addresses:type_name -> taprpc.Addr + 84, // 64: taprpc.SendEvent.anchor_transaction:type_name -> taprpc.AnchorTransaction + 40, // 65: taprpc.SendEvent.transfer:type_name -> taprpc.AssetTransfer + 79, // 66: taprpc.AnchorTransaction.lnd_locked_utxos:type_name -> taprpc.OutPoint + 27, // 67: taprpc.ListUtxosResponse.ManagedUtxosEntry.value:type_name -> taprpc.ManagedUtxo + 31, // 68: taprpc.ListGroupsResponse.GroupsEntry.value:type_name -> taprpc.GroupedAssets + 34, // 69: taprpc.ListBalancesResponse.AssetBalancesEntry.value:type_name -> taprpc.AssetBalance + 35, // 70: taprpc.ListBalancesResponse.AssetGroupBalancesEntry.value:type_name -> taprpc.AssetGroupBalance + 10, // 71: taprpc.TaprootAssets.ListAssets:input_type -> taprpc.ListAssetRequest + 26, // 72: taprpc.TaprootAssets.ListUtxos:input_type -> taprpc.ListUtxosRequest + 29, // 73: taprpc.TaprootAssets.ListGroups:input_type -> taprpc.ListGroupsRequest + 33, // 74: taprpc.TaprootAssets.ListBalances:input_type -> taprpc.ListBalancesRequest + 37, // 75: taprpc.TaprootAssets.ListTransfers:input_type -> taprpc.ListTransfersRequest + 44, // 76: taprpc.TaprootAssets.StopDaemon:input_type -> taprpc.StopRequest + 46, // 77: taprpc.TaprootAssets.DebugLevel:input_type -> taprpc.DebugLevelRequest + 49, // 78: taprpc.TaprootAssets.QueryAddrs:input_type -> taprpc.QueryAddrRequest + 51, // 79: taprpc.TaprootAssets.NewAddr:input_type -> taprpc.NewAddrRequest + 58, // 80: taprpc.TaprootAssets.DecodeAddr:input_type -> taprpc.DecodeAddrRequest + 66, // 81: taprpc.TaprootAssets.AddrReceives:input_type -> taprpc.AddrReceivesRequest + 59, // 82: taprpc.TaprootAssets.VerifyProof:input_type -> taprpc.ProofFile + 62, // 83: taprpc.TaprootAssets.DecodeProof:input_type -> taprpc.DecodeProofRequest + 64, // 84: taprpc.TaprootAssets.ExportProof:input_type -> taprpc.ExportProofRequest + 68, // 85: taprpc.TaprootAssets.SendAsset:input_type -> taprpc.SendAssetRequest + 74, // 86: taprpc.TaprootAssets.BurnAsset:input_type -> taprpc.BurnAssetRequest + 76, // 87: taprpc.TaprootAssets.ListBurns:input_type -> taprpc.ListBurnsRequest + 71, // 88: taprpc.TaprootAssets.GetInfo:input_type -> taprpc.GetInfoRequest + 73, // 89: taprpc.TaprootAssets.FetchAssetMeta:input_type -> taprpc.FetchAssetMetaRequest + 80, // 90: taprpc.TaprootAssets.SubscribeReceiveEvents:input_type -> taprpc.SubscribeReceiveEventsRequest + 82, // 91: taprpc.TaprootAssets.SubscribeSendEvents:input_type -> taprpc.SubscribeSendEventsRequest + 25, // 92: taprpc.TaprootAssets.ListAssets:output_type -> taprpc.ListAssetResponse + 28, // 93: taprpc.TaprootAssets.ListUtxos:output_type -> taprpc.ListUtxosResponse + 32, // 94: taprpc.TaprootAssets.ListGroups:output_type -> taprpc.ListGroupsResponse + 36, // 95: taprpc.TaprootAssets.ListBalances:output_type -> taprpc.ListBalancesResponse + 38, // 96: taprpc.TaprootAssets.ListTransfers:output_type -> taprpc.ListTransfersResponse + 45, // 97: taprpc.TaprootAssets.StopDaemon:output_type -> taprpc.StopResponse + 47, // 98: taprpc.TaprootAssets.DebugLevel:output_type -> taprpc.DebugLevelResponse + 50, // 99: taprpc.TaprootAssets.QueryAddrs:output_type -> taprpc.QueryAddrResponse + 48, // 100: taprpc.TaprootAssets.NewAddr:output_type -> taprpc.Addr + 48, // 101: taprpc.TaprootAssets.DecodeAddr:output_type -> taprpc.Addr + 67, // 102: taprpc.TaprootAssets.AddrReceives:output_type -> taprpc.AddrReceivesResponse + 61, // 103: taprpc.TaprootAssets.VerifyProof:output_type -> taprpc.VerifyProofResponse + 63, // 104: taprpc.TaprootAssets.DecodeProof:output_type -> taprpc.DecodeProofResponse + 59, // 105: taprpc.TaprootAssets.ExportProof:output_type -> taprpc.ProofFile + 70, // 106: taprpc.TaprootAssets.SendAsset:output_type -> taprpc.SendAssetResponse + 75, // 107: taprpc.TaprootAssets.BurnAsset:output_type -> taprpc.BurnAssetResponse + 78, // 108: taprpc.TaprootAssets.ListBurns:output_type -> taprpc.ListBurnsResponse + 72, // 109: taprpc.TaprootAssets.GetInfo:output_type -> taprpc.GetInfoResponse + 9, // 110: taprpc.TaprootAssets.FetchAssetMeta:output_type -> taprpc.AssetMeta + 81, // 111: taprpc.TaprootAssets.SubscribeReceiveEvents:output_type -> taprpc.ReceiveEvent + 83, // 112: taprpc.TaprootAssets.SubscribeSendEvents:output_type -> taprpc.SendEvent + 92, // [92:113] is the sub-list for method output_type + 71, // [71:92] is the sub-list for method input_type + 71, // [71:71] is the sub-list for extension type_name + 71, // [71:71] is the sub-list for extension extendee + 0, // [0:71] is the sub-list for field type_name } func init() { file_taprootassets_proto_init() } @@ -7273,7 +7377,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupKeyRequest); i { + switch v := v.(*ExternalKey); i { case 0: return &v.state case 1: @@ -7285,7 +7389,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TxOut); i { + switch v := v.(*GroupKeyRequest); i { case 0: return &v.state case 1: @@ -7297,7 +7401,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupVirtualTx); i { + switch v := v.(*TxOut); i { case 0: return &v.state case 1: @@ -7309,7 +7413,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupWitness); i { + switch v := v.(*GroupVirtualTx); i { case 0: return &v.state case 1: @@ -7321,7 +7425,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetGroup); i { + switch v := v.(*GroupWitness); i { case 0: return &v.state case 1: @@ -7333,7 +7437,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupKeyReveal); i { + switch v := v.(*AssetGroup); i { case 0: return &v.state case 1: @@ -7345,7 +7449,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GenesisReveal); i { + switch v := v.(*GroupKeyReveal); i { case 0: return &v.state case 1: @@ -7357,7 +7461,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecimalDisplay); i { + switch v := v.(*GenesisReveal); i { case 0: return &v.state case 1: @@ -7369,7 +7473,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Asset); i { + switch v := v.(*DecimalDisplay); i { case 0: return &v.state case 1: @@ -7381,7 +7485,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PrevWitness); i { + switch v := v.(*Asset); i { case 0: return &v.state case 1: @@ -7393,7 +7497,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SplitCommitment); i { + switch v := v.(*PrevWitness); i { case 0: return &v.state case 1: @@ -7405,7 +7509,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListAssetResponse); i { + switch v := v.(*SplitCommitment); i { case 0: return &v.state case 1: @@ -7417,7 +7521,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListUtxosRequest); i { + switch v := v.(*ListAssetResponse); i { case 0: return &v.state case 1: @@ -7429,7 +7533,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ManagedUtxo); i { + switch v := v.(*ListUtxosRequest); i { case 0: return &v.state case 1: @@ -7441,7 +7545,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListUtxosResponse); i { + switch v := v.(*ManagedUtxo); i { case 0: return &v.state case 1: @@ -7453,7 +7557,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListGroupsRequest); i { + switch v := v.(*ListUtxosResponse); i { case 0: return &v.state case 1: @@ -7465,7 +7569,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetHumanReadable); i { + switch v := v.(*ListGroupsRequest); i { case 0: return &v.state case 1: @@ -7477,7 +7581,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupedAssets); i { + switch v := v.(*AssetHumanReadable); i { case 0: return &v.state case 1: @@ -7489,7 +7593,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListGroupsResponse); i { + switch v := v.(*GroupedAssets); i { case 0: return &v.state case 1: @@ -7501,7 +7605,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBalancesRequest); i { + switch v := v.(*ListGroupsResponse); i { case 0: return &v.state case 1: @@ -7513,7 +7617,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetBalance); i { + switch v := v.(*ListBalancesRequest); i { case 0: return &v.state case 1: @@ -7525,7 +7629,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetGroupBalance); i { + switch v := v.(*AssetBalance); i { case 0: return &v.state case 1: @@ -7537,7 +7641,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBalancesResponse); i { + switch v := v.(*AssetGroupBalance); i { case 0: return &v.state case 1: @@ -7549,7 +7653,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListTransfersRequest); i { + switch v := v.(*ListBalancesResponse); i { case 0: return &v.state case 1: @@ -7561,7 +7665,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListTransfersResponse); i { + switch v := v.(*ListTransfersRequest); i { case 0: return &v.state case 1: @@ -7573,7 +7677,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChainHash); i { + switch v := v.(*ListTransfersResponse); i { case 0: return &v.state case 1: @@ -7585,7 +7689,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetTransfer); i { + switch v := v.(*ChainHash); i { case 0: return &v.state case 1: @@ -7597,7 +7701,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferInput); i { + switch v := v.(*AssetTransfer); i { case 0: return &v.state case 1: @@ -7609,7 +7713,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferOutputAnchor); i { + switch v := v.(*TransferInput); i { case 0: return &v.state case 1: @@ -7621,7 +7725,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferOutput); i { + switch v := v.(*TransferOutputAnchor); i { case 0: return &v.state case 1: @@ -7633,7 +7737,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StopRequest); i { + switch v := v.(*TransferOutput); i { case 0: return &v.state case 1: @@ -7645,7 +7749,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StopResponse); i { + switch v := v.(*StopRequest); i { case 0: return &v.state case 1: @@ -7657,7 +7761,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DebugLevelRequest); i { + switch v := v.(*StopResponse); i { case 0: return &v.state case 1: @@ -7669,7 +7773,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DebugLevelResponse); i { + switch v := v.(*DebugLevelRequest); i { case 0: return &v.state case 1: @@ -7681,7 +7785,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Addr); i { + switch v := v.(*DebugLevelResponse); i { case 0: return &v.state case 1: @@ -7693,7 +7797,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryAddrRequest); i { + switch v := v.(*Addr); i { case 0: return &v.state case 1: @@ -7705,7 +7809,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryAddrResponse); i { + switch v := v.(*QueryAddrRequest); i { case 0: return &v.state case 1: @@ -7717,7 +7821,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NewAddrRequest); i { + switch v := v.(*QueryAddrResponse); i { case 0: return &v.state case 1: @@ -7729,7 +7833,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ScriptKey); i { + switch v := v.(*NewAddrRequest); i { case 0: return &v.state case 1: @@ -7741,7 +7845,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*KeyLocator); i { + switch v := v.(*ScriptKey); i { case 0: return &v.state case 1: @@ -7753,7 +7857,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*KeyDescriptor); i { + switch v := v.(*KeyLocator); i { case 0: return &v.state case 1: @@ -7765,7 +7869,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TapscriptFullTree); i { + switch v := v.(*KeyDescriptor); i { case 0: return &v.state case 1: @@ -7777,7 +7881,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TapLeaf); i { + switch v := v.(*TapscriptFullTree); i { case 0: return &v.state case 1: @@ -7789,7 +7893,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TapBranch); i { + switch v := v.(*TapLeaf); i { case 0: return &v.state case 1: @@ -7801,7 +7905,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodeAddrRequest); i { + switch v := v.(*TapBranch); i { case 0: return &v.state case 1: @@ -7813,7 +7917,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ProofFile); i { + switch v := v.(*DecodeAddrRequest); i { case 0: return &v.state case 1: @@ -7825,7 +7929,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodedProof); i { + switch v := v.(*ProofFile); i { case 0: return &v.state case 1: @@ -7837,7 +7941,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VerifyProofResponse); i { + switch v := v.(*DecodedProof); i { case 0: return &v.state case 1: @@ -7849,7 +7953,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodeProofRequest); i { + switch v := v.(*VerifyProofResponse); i { case 0: return &v.state case 1: @@ -7861,7 +7965,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodeProofResponse); i { + switch v := v.(*DecodeProofRequest); i { case 0: return &v.state case 1: @@ -7873,7 +7977,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ExportProofRequest); i { + switch v := v.(*DecodeProofResponse); i { case 0: return &v.state case 1: @@ -7885,7 +7989,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AddrEvent); i { + switch v := v.(*ExportProofRequest); i { case 0: return &v.state case 1: @@ -7897,7 +8001,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AddrReceivesRequest); i { + switch v := v.(*AddrEvent); i { case 0: return &v.state case 1: @@ -7909,7 +8013,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AddrReceivesResponse); i { + switch v := v.(*AddrReceivesRequest); i { case 0: return &v.state case 1: @@ -7921,7 +8025,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SendAssetRequest); i { + switch v := v.(*AddrReceivesResponse); i { case 0: return &v.state case 1: @@ -7933,7 +8037,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PrevInputAsset); i { + switch v := v.(*SendAssetRequest); i { case 0: return &v.state case 1: @@ -7945,7 +8049,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SendAssetResponse); i { + switch v := v.(*PrevInputAsset); i { case 0: return &v.state case 1: @@ -7957,7 +8061,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetInfoRequest); i { + switch v := v.(*SendAssetResponse); i { case 0: return &v.state case 1: @@ -7969,7 +8073,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetInfoResponse); i { + switch v := v.(*GetInfoRequest); i { case 0: return &v.state case 1: @@ -7981,7 +8085,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FetchAssetMetaRequest); i { + switch v := v.(*GetInfoResponse); i { case 0: return &v.state case 1: @@ -7993,7 +8097,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BurnAssetRequest); i { + switch v := v.(*FetchAssetMetaRequest); i { case 0: return &v.state case 1: @@ -8005,7 +8109,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BurnAssetResponse); i { + switch v := v.(*BurnAssetRequest); i { case 0: return &v.state case 1: @@ -8017,7 +8121,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBurnsRequest); i { + switch v := v.(*BurnAssetResponse); i { case 0: return &v.state case 1: @@ -8029,7 +8133,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetBurn); i { + switch v := v.(*ListBurnsRequest); i { case 0: return &v.state case 1: @@ -8041,7 +8145,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBurnsResponse); i { + switch v := v.(*AssetBurn); i { case 0: return &v.state case 1: @@ -8053,7 +8157,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*OutPoint); i { + switch v := v.(*ListBurnsResponse); i { case 0: return &v.state case 1: @@ -8065,7 +8169,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SubscribeReceiveEventsRequest); i { + switch v := v.(*OutPoint); i { case 0: return &v.state case 1: @@ -8077,7 +8181,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReceiveEvent); i { + switch v := v.(*SubscribeReceiveEventsRequest); i { case 0: return &v.state case 1: @@ -8089,7 +8193,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SubscribeSendEventsRequest); i { + switch v := v.(*ReceiveEvent); i { case 0: return &v.state case 1: @@ -8101,7 +8205,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SendEvent); i { + switch v := v.(*SubscribeSendEventsRequest); i { case 0: return &v.state case 1: @@ -8113,6 +8217,18 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SendEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_taprootassets_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AnchorTransaction); i { case 0: return &v.state @@ -8125,17 +8241,17 @@ func file_taprootassets_proto_init() { } } } - file_taprootassets_proto_msgTypes[23].OneofWrappers = []interface{}{ + file_taprootassets_proto_msgTypes[24].OneofWrappers = []interface{}{ (*ListBalancesRequest_AssetId)(nil), (*ListBalancesRequest_GroupKey)(nil), } - file_taprootassets_proto_msgTypes[63].OneofWrappers = []interface{}{ + file_taprootassets_proto_msgTypes[64].OneofWrappers = []interface{}{ (*FetchAssetMetaRequest_AssetId)(nil), (*FetchAssetMetaRequest_MetaHash)(nil), (*FetchAssetMetaRequest_AssetIdStr)(nil), (*FetchAssetMetaRequest_MetaHashStr)(nil), } - file_taprootassets_proto_msgTypes[64].OneofWrappers = []interface{}{ + file_taprootassets_proto_msgTypes[65].OneofWrappers = []interface{}{ (*BurnAssetRequest_AssetId)(nil), (*BurnAssetRequest_AssetIdStr)(nil), } @@ -8145,7 +8261,7 @@ func file_taprootassets_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_taprootassets_proto_rawDesc, NumEnums: 9, - NumMessages: 79, + NumMessages: 80, NumExtensions: 0, NumServices: 1, }, diff --git a/taprpc/taprootassets.proto b/taprpc/taprootassets.proto index 5fec3f43f..ebdc43c53 100644 --- a/taprpc/taprootassets.proto +++ b/taprpc/taprootassets.proto @@ -255,8 +255,40 @@ message GenesisInfo { uint32 output_index = 6; } +/* +This message represents an external key used for deriving and managing +hierarchical deterministic (HD) wallet addresses according to BIP-86. +*/ +message ExternalKey { + /* + This field specifies the extended public key derived at depth 3 of the + BIP-86 hierarchy (e.g., m/86'/0'/0'). This key serves as the parent key for + deriving child public keys and addresses. + */ + string xpub = 1; + + /* + This field specifies the fingerprint of the master key, derived from the + first 4 bytes of the hash160 of the master public key. It is used to + identify the master key in BIP-86 derivation schemes. + */ + bytes master_fingerprint = 2; + + /* + This field specifies the extended BIP-86 derivation path used to derive a + child key from the XPub. Starting from the base path of the XPub + (e.g., m/86'/0'/0'), this path must contain exactly 5 components in total + (e.g., m/86'/0'/0'/0/0), with the additional components defining specific + child keys, such as individual addresses. + */ + string derivation_path = 3; +} + message GroupKeyRequest { - // The internal key for the asset group before any tweaks have been applied. + /* + The internal key for the asset group before any tweaks have been applied. + If this field is set then external_key must be empty, and vice versa. + */ KeyDescriptor raw_key = 1; /* @@ -279,6 +311,16 @@ message GroupKeyRequest { member of this asset group. */ bytes new_asset = 4; + + /* + The external key is an optional field that allows specifying an + external signing key for the group virtual transaction during minting. + This key enables signing operations to be performed externally, outside + the daemon. + + If this field is set then raw_key must be empty, and vice versa. + */ + ExternalKey external_key = 5; } message TxOut {