diff --git a/asset/asset.go b/asset/asset.go index 5a21ab9e96..e523ed288c 100644 --- a/asset/asset.go +++ b/asset/asset.go @@ -706,7 +706,7 @@ type GroupKeyRequest struct { // NewAsset is the asset which we are requesting group membership for. // A successful request will produce a witness that authorizes this - // to be a member of this asset group. + // asset to be a member of this asset group. NewAsset *Asset } @@ -752,6 +752,13 @@ type GroupKeyReveal struct { TapscriptRoot []byte } +// PendingGroupWitness specifies the asset group witness for an asset seedling +// in an unsealed minting batch. +type PendingGroupWitness struct { + GenID ID + Witness wire.TxWitness +} + // GroupPubKey returns the group public key derived from the group key reveal. func (g *GroupKeyReveal) GroupPubKey(assetID ID) (*btcec.PublicKey, error) { rawKey, err := g.RawKey.ToPubKey() diff --git a/cmd/tapcli/assets.go b/cmd/tapcli/assets.go index f8baf17de6..b191a9f003 100644 --- a/cmd/tapcli/assets.go +++ b/cmd/tapcli/assets.go @@ -127,6 +127,8 @@ var mintAssetCommand = cli.Command{ Action: mintAsset, Subcommands: []cli.Command{ listBatchesCommand, + fundBatchCommand, + sealBatchCommand, finalizeBatchCommand, cancelBatchCommand, }, @@ -176,6 +178,28 @@ func parseMetaType(metaType string, } } +func parseFeeRate(ctx *cli.Context) (uint32, error) { + if ctx.IsSet(feeRateName) { + userFeeRate := ctx.Uint64(feeRateName) + if userFeeRate > math.MaxUint32 { + return 0, fmt.Errorf("fee rate exceeds 2^32") + } + + // Convert from sat/vB to sat/kw. Round up to the fee floor if + // the specified feerate is too low. + feeRate := chainfee.SatPerKVByte(userFeeRate * 1000). + FeePerKWeight() + + if feeRate < chainfee.FeePerKwFloor { + feeRate = chainfee.FeePerKwFloor + } + + return uint32(feeRate), nil + } + + return uint32(0), nil +} + func mintAsset(ctx *cli.Context) error { switch { case ctx.String(assetTagName) == "": @@ -291,11 +315,14 @@ func mintAsset(ctx *cli.Context) error { return nil } -var finalizeBatchCommand = cli.Command{ - Name: "finalize", - ShortName: "f", - Usage: "finalize a batch", - Description: "Attempt to finalize a pending batch.", +var fundBatchCommand = cli.Command{ + Name: "fund", + Usage: "fund a batch", + Description: ` + Attempt to fund a pending batch, or create a new funded batch if no + batch exists yet. This is only needed if batch funding should happen + separately from batch finalization. Otherwise, finalize can be used. + `, Flags: []cli.Flag{ cli.BoolFlag{ Name: shortResponseName, @@ -310,29 +337,88 @@ var finalizeBatchCommand = cli.Command{ "the minting transaction", }, }, - Action: finalizeBatch, + Action: fundBatch, } -func parseFeeRate(ctx *cli.Context) (uint32, error) { - if ctx.IsSet(feeRateName) { - userFeeRate := ctx.Uint64(feeRateName) - if userFeeRate > math.MaxUint32 { - return 0, fmt.Errorf("fee rate exceeds 2^32") - } +func fundBatch(ctx *cli.Context) error { + ctxc := getContext() + client, cleanUp := getMintClient(ctx) + defer cleanUp() - // Convert from sat/vB to sat/kw. Round up to the fee floor if - // the specified feerate is too low. - feeRate := chainfee.SatPerKVByte(userFeeRate * 1000). - FeePerKWeight() + feeRate, err := parseFeeRate(ctx) + if err != nil { + return err + } - if feeRate < chainfee.FeePerKwFloor { - feeRate = chainfee.FeePerKwFloor - } + resp, err := client.FundBatch(ctxc, &mintrpc.FundBatchRequest{ + ShortResponse: ctx.Bool(shortResponseName), + FeeRate: feeRate, + }) + if err != nil { + return fmt.Errorf("unable to fund batch: %w", err) + } - return uint32(feeRate), nil + printRespJSON(resp) + return nil +} + +var sealBatchCommand = cli.Command{ + Name: "seal", + Usage: "seal a batch", + Description: ` + Attempt to seal the pending batch by creating asset group witnesses for + all assets in the batch. Custom witnesses can only be submitted via RPC. + This command is only needed if batch sealing should happen separately + from batch finalization. Otherwise, finalize can be used. + `, + Flags: []cli.Flag{ + cli.BoolFlag{ + Name: shortResponseName, + Usage: "if true, then the current assets within the " + + "batch will not be returned in the response " + + "in order to avoid printing a large amount " + + "of data in case of large batches", + }, + }, + Hidden: true, + Action: sealBatch, +} + +func sealBatch(ctx *cli.Context) error { + ctxc := getContext() + client, cleanUp := getMintClient(ctx) + defer cleanUp() + + resp, err := client.SealBatch(ctxc, &mintrpc.SealBatchRequest{ + ShortResponse: ctx.Bool(shortResponseName), + }) + if err != nil { + return fmt.Errorf("unable to seal batch: %w", err) } - return uint32(0), nil + printRespJSON(resp) + return nil +} + +var finalizeBatchCommand = cli.Command{ + Name: "finalize", + Usage: "finalize a batch", + Description: "Attempt to finalize a pending batch.", + Flags: []cli.Flag{ + cli.BoolFlag{ + Name: shortResponseName, + Usage: "if true, then the current assets within the " + + "batch will not be returned in the response " + + "in order to avoid printing a large amount " + + "of data in case of large batches", + }, + cli.Uint64Flag{ + Name: feeRateName, + Usage: "if set, the fee rate in sat/vB to use for " + + "the minting transaction", + }, + }, + Action: finalizeBatch, } func finalizeBatch(ctx *cli.Context) error { diff --git a/internal/test/helpers.go b/internal/test/helpers.go index fe747354c8..d9581efba5 100644 --- a/internal/test/helpers.go +++ b/internal/test/helpers.go @@ -32,6 +32,8 @@ var ( HexCompressedPubKeyLen = hex.EncodedLen(btcec.PubKeyBytesLenCompressed) HexTaprootPkScript = hex.EncodedLen(input.P2TRSize) + + DefaultHashLockWitness = []byte("foobar") ) // RandBool rolls a random boolean. @@ -426,8 +428,7 @@ func ReadTestDataFile(t *testing.T, fileName string) string { func BuildTapscriptTreeNoReveal(t *testing.T, internalKey *btcec.PublicKey) txscript.TapBranch { - hashLockWitness := []byte("foobar") - hashLockLeaf := ScriptHashLock(t, hashLockWitness) + hashLockLeaf := ScriptHashLock(t, bytes.Clone(DefaultHashLockWitness)) sigLeaf := ScriptSchnorrSig(t, internalKey) tree := txscript.AssembleTaprootScriptTree(hashLockLeaf, sigLeaf) @@ -445,9 +446,8 @@ func BuildTapscriptTree(t *testing.T, useHashLock, valid bool, // Let's create a taproot asset script now. This is a hash lock with a // simple preimage of "foobar". - hashLockWitness := []byte("foobar") invalidHashLockWitness := []byte("not-foobar") - hashLockLeaf := ScriptHashLock(t, hashLockWitness) + hashLockLeaf := ScriptHashLock(t, bytes.Clone(DefaultHashLockWitness)) // Let's add a second script output as well to test the partial reveal. sigLeaf := ScriptSchnorrSig(t, internalKey) @@ -465,7 +465,7 @@ func BuildTapscriptTree(t *testing.T, useHashLock, valid bool, testTapScript = input.TapscriptPartialReveal( internalKey, hashLockLeaf, inclusionProof[:], ) - scriptWitness = hashLockWitness + scriptWitness = DefaultHashLockWitness if !valid { scriptWitness = invalidHashLockWitness diff --git a/itest/assertions.go b/itest/assertions.go index 0df9c9d46b..3e6143d371 100644 --- a/itest/assertions.go +++ b/itest/assertions.go @@ -142,6 +142,79 @@ func AssetScriptKeyIsBurnCheck(isBurn bool) AssetCheck { } } +func AssetScriptKeyCheck(scriptKey *taprpc.ScriptKey) AssetCheck { + return func(a *taprpc.Asset) error { + if scriptKey == nil { + return nil + } + + if !bytes.Equal(scriptKey.PubKey, a.ScriptKey[1:]) { + return fmt.Errorf("unexpected script key, "+ + "wanted %x, got %x ", scriptKey.PubKey, + a.ScriptKey[1:]) + } + + return nil + } +} + +func AssetIsGroupedCheck(newGrouped, grouped bool) AssetCheck { + return func(a *taprpc.Asset) error { + needsGroup := newGrouped || grouped + if !needsGroup { + return nil + } + + if needsGroup && a.AssetGroup == nil { + return fmt.Errorf("unexpected missing asset group") + } + + return nil + } +} + +func AssetGroupInternalKeyCheck(key *taprpc.KeyDescriptor) AssetCheck { + return func(a *taprpc.Asset) error { + if key == nil { + return nil + } + + if a.AssetGroup == nil { + return fmt.Errorf("unexpected missing asset group") + } + + expectedKey := key.RawKeyBytes + groupInternal := a.AssetGroup.RawGroupKey + if !bytes.Equal(expectedKey, groupInternal) { + return fmt.Errorf("mistmatched group internal "+ + "key, wanted %x, got %x ", expectedKey, + groupInternal) + } + + return nil + } +} + +func AssetGroupTapscriptRootCheck(root []byte) AssetCheck { + return func(a *taprpc.Asset) error { + if len(root) == 0 { + return nil + } + + switch { + case a.AssetGroup == nil: + return fmt.Errorf("unexpected missing asset group") + + case !bytes.Equal(root, a.AssetGroup.TapscriptRoot): + return fmt.Errorf("mistmatched group tapscript roots, "+ + "wanted %x, got %x", + root, a.AssetGroup.TapscriptRoot) + } + + return nil + } +} + // AssetVersionCheck returns a check function that tests an asset's version. func AssetVersionCheck(version taprpc.AssetVersion) AssetCheck { return func(a *taprpc.Asset) error { @@ -316,9 +389,9 @@ func WaitForBatchState(t *testing.T, ctx context.Context, len(batchResp.Batches)) } - if batchResp.Batches[0].State != targetState { + if batchResp.Batches[0].Batch.State != targetState { return fmt.Errorf("expected batch state %v, got %v", - targetState, batchResp.Batches[0].State) + targetState, batchResp.Batches[0].Batch.State) } return nil @@ -1648,8 +1721,7 @@ func VerifyGroupAnchor(t *testing.T, assets []*taprpc.Asset, // AssertAssetsMinted makes sure all assets in the minting request were in fact // minted in the given anchor TX and block. The function returns the list of // minted assets. -func AssertAssetsMinted(t *testing.T, - tapClient TapdClient, +func AssertAssetsMinted(t *testing.T, tapClient TapdClient, assetRequests []*mintrpc.MintAssetRequest, mintTXID, blockHash chainhash.Hash) []*taprpc.Asset { @@ -1706,6 +1778,14 @@ func AssertAssetsMinted(t *testing.T, return nil }, + AssetScriptKeyCheck(assetRequest.Asset.ScriptKey), + AssetIsGroupedCheck( + assetRequest.Asset.NewGroupedAsset, + assetRequest.Asset.GroupedAsset, + ), + AssetGroupTapscriptRootCheck( + assetRequest.Asset.GroupTapscriptRoot, + ), ) assetList = append(assetList, mintedAsset) diff --git a/itest/assets_test.go b/itest/assets_test.go index 644f328dcb..e8b3bc8b1a 100644 --- a/itest/assets_test.go +++ b/itest/assets_test.go @@ -290,18 +290,20 @@ func testMintAssetNameCollisionError(t *harnessTest) { allBatches := rpcBatches.Batches require.Len(t.t, allBatches, 2) - isCollidingBatch := func(batch *mintrpc.MintingBatch) bool { - if len(batch.Assets) == 0 { + isCollidingBatch := func(batch *mintrpc.VerboseBatch) bool { + if len(batch.Batch.Assets) == 0 { return false } - return batch.Assets[0].AssetType == taprpc.AssetType_COLLECTIBLE + assetType := batch.Batch.Assets[0].AssetType + + return assetType == taprpc.AssetType_COLLECTIBLE } batchCollide, err := fn.First(allBatches, isCollidingBatch) require.NoError(t.t, err) - require.Len(t.t, batchCollide.Assets, 1) - equalityCheck(assetCollide.Asset, batchCollide.Assets[0]) + require.Len(t.t, batchCollide.Batch.Assets, 1) + equalityCheck(assetCollide.Asset, batchCollide.Batch.Assets[0]) cancelBatchKey, err := t.tapd.CancelBatch( ctxt, &mintrpc.CancelBatchRequest{}, @@ -323,11 +325,12 @@ func testMintAssetNameCollisionError(t *harnessTest) { require.Len(t.t, cancelBatch.Batches, 1) cancelBatchCollide := cancelBatch.Batches[0] - require.Len(t.t, cancelBatchCollide.Assets, 1) + require.Len(t.t, cancelBatchCollide.Batch.Assets, 1) equalityCheckSeedlings( - batchCollide.Assets[0], cancelBatchCollide.Assets[0], + batchCollide.Batch.Assets[0], + cancelBatchCollide.Batch.Assets[0], ) - cancelBatchState := cancelBatchCollide.State + cancelBatchState := cancelBatchCollide.Batch.State require.Equal( t.t, cancelBatchState, mintrpc.BatchState_BATCH_STATE_SEEDLING_CANCELLED, diff --git a/itest/mint_fund_seal_test.go b/itest/mint_fund_seal_test.go new file mode 100644 index 0000000000..13eaaa5fac --- /dev/null +++ b/itest/mint_fund_seal_test.go @@ -0,0 +1,760 @@ +package itest + +import ( + "bytes" + "context" + "encoding/hex" + "math" + "testing" + + "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/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/decred/dcrd/dcrec/secp256k1/v4" + taprootassets "github.com/lightninglabs/taproot-assets" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/fn" + "github.com/lightninglabs/taproot-assets/internal/test" + "github.com/lightninglabs/taproot-assets/tappsbt" + "github.com/lightninglabs/taproot-assets/taprpc" + wrpc "github.com/lightninglabs/taproot-assets/taprpc/assetwalletrpc" + "github.com/lightninglabs/taproot-assets/taprpc/mintrpc" + "github.com/lightninglabs/taproot-assets/tapsend" + "github.com/lightninglabs/taproot-assets/universe" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/keychain" + "github.com/lightningnetwork/lnd/lntest/rpc" + "github.com/stretchr/testify/require" +) + +// testMintFundSealAssets tests that we're able to mint assets with custom +// script keys, group keys, and group key tapscript roots. Once minted, we +// also want to reissue assets with a custom asset group witness, and spend +// an asset with a custom script key witness. An asset group with a tapscript +// root should also be imported into a new node correctly. +func testMintFundSealAssets(t *harnessTest) { + // We create a second tapd node that will be used to simulate a second + // party in the test. This tapd node is connected to lnd "Bob". + var ( + aliceTapd = t.tapd + aliceLnd = t.lndHarness.Alice + bobLnd = t.lndHarness.Bob + bobTapd = setupTapdHarness(t.t, t, bobLnd, t.universeServer) + ) + + aliceLndClient, err := t.newLndClient(aliceLnd) + require.NoError(t.t, err) + + defer func() { + require.NoError(t.t, bobTapd.stop(!*noDelete)) + }() + + ctxb := context.Background() + ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout) + defer cancel() + + aliceLndKeyRing := taprootassets.NewLndRpcKeyRing( + &aliceLndClient.LndServices, + ) + + // Let's derive the keys and tapscript trees we'll use. + // tweakedScript will have an internal key not managed by a tapd, and + // a tapscript root with a hashlock and a single sig script. + tweakedScriptDesc := deriveRandomKey(t.t, ctxt, aliceLndKeyRing) + tweakedScriptSigLock := test.ScriptSchnorrSig( + t.t, tweakedScriptDesc.PubKey, + ) + + tweakedScript, tweakedScriptTapTree := buildTweakedScriptKey( + t.t, &tweakedScriptDesc, test.DefaultHashLockWitness, + tweakedScriptDesc.PubKey, + ) + + // managedGroupInternal will be an internal key we generate via a tapd + // RPC call, and then set for a specific asset group. + _, managedGroupInternal := DeriveKeys(t.t, aliceTapd) + + // groupInternalSigLockKey will be an internal key used only for the + // signature locking script of an asset group. + _, groupInternalSigLockKey := DeriveKeys(t.t, aliceTapd) + groupInternalTweak, groupInternalHashLock, groupInternalTapTree := + computeGroupKeyTweak(t.t, groupInternalSigLockKey.PubKey, true) + + // groupExternal will be a group internal key not managed by a tapd, + // that will also have a tapscript tweak. + groupExternalDesc := deriveRandomKey(t.t, ctxt, aliceLndKeyRing) + + // groupExternalTweak will be the tapscript tweak we apply to + // groupExternal. We'll use random bytes as we don't intend to use the + // script spend path at all. + groupExternalTweak := test.RandBytes(32) + + // firstAnchorInternal and secondAnchorInternal will be the two keys + // used in the multisig for the genesis output. + _, firstAnchorInternal := DeriveKeys(t.t, aliceTapd) + _, secondAnchorInternal := DeriveKeys(t.t, aliceTapd) + + // The tapscript sibling of the anchor will be a 2-of-2 multisig script. + anchorMultisigScript, siblingReq := buildMultisigTapLeaf( + t.t, firstAnchorInternal.PubKey, secondAnchorInternal.PubKey, + ) + + // Now, let's build our asset requests. We'll modify each of the + // standard asset requests used across the itests. + // Asset 0 will have no asset group, and an external script key with a + // tapscript root. + assetReqWithScriptKey := CopyRequest(simpleAssets[0]) + assetReqWithScriptKey.Asset.ScriptKey = taprpc.MarshalScriptKey( + tweakedScript, + ) + + // Asset 1 will have a specific internal group key with a tapscript + // root. This asset will be a group anchor. + assetReqGroupedInternalTweaked := CopyRequest(simpleAssets[1]) + assetReqGroupedInternalTweaked.Asset.NewGroupedAsset = true + assetReqGroupedInternalTweaked.Asset.GroupInternalKey = taprpc. + MarshalKeyDescriptor(managedGroupInternal) + assetReqGroupedInternalTweaked.Asset. + GroupTapscriptRoot = groupInternalTweak + + // Asset 2 will have an external group key with a tapscript root. + assetReqGroupedExternal := CopyRequest(issuableAssets[0]) + assetReqGroupedExternal.Asset.GroupInternalKey = taprpc. + MarshalKeyDescriptor(groupExternalDesc) + assetReqGroupedExternal.Asset.GroupTapscriptRoot = groupExternalTweak[:] + + // Asset 3 will be a member of the asset group created by Asset 1. + assetReqGroupMember := CopyRequest(issuableAssets[1]) + assetReqGroupMember.Asset.NewGroupedAsset = false + assetReqGroupMember.Asset.GroupedAsset = true + assetReqGroupMember.Asset.GroupAnchor = assetReqGroupedInternalTweaked. + Asset.Name + + assetReqs := []*mintrpc.MintAssetRequest{ + assetReqWithScriptKey, assetReqGroupedInternalTweaked, + assetReqGroupedExternal, assetReqGroupMember, + } + + // Let's fund a batch, adding the multisig tapscript sibling we + // constructed earlier. + fundReq := &mintrpc.FundBatchRequest{ + BatchSibling: &siblingReq, + } + fundResp, err := aliceTapd.FundBatch(ctxt, fundReq) + require.NoError(t.t, err) + require.NotEmpty(t.t, fundResp.Batch) + require.Equal( + t.t, mintrpc.BatchState_BATCH_STATE_PENDING, + fundResp.Batch.State, + ) + require.NotEmpty(t.t, fundResp.Batch.BatchPsbt) + + // Now we can add all the asset requests created above. + BuildMintingBatch(t.t, aliceTapd, assetReqs) + + // If we request a verbose list of batches, we should receive asset + // group information for exactly 3 assets. + listBatchResp, err := aliceTapd.ListBatches( + ctxt, &mintrpc.ListBatchRequest{ + Verbose: true, + }) + require.NoError(t.t, err) + require.Len(t.t, listBatchResp.Batches, 1) + + unsealedAssets := listBatchResp.Batches[0].UnsealedAssets + unsealedAssetCount := fn.Count( + unsealedAssets, func(a *mintrpc.UnsealedAsset) bool { + return a.GroupKeyRequest != nil && + a.GroupVirtualTx != nil + }, + ) + require.Equal(t.t, 3, unsealedAssetCount) + + findUnsealedAsset := func(name string, + assets []*mintrpc.UnsealedAsset) *mintrpc.UnsealedAsset { + + targetAsset, err := fn.First( + assets, func(a *mintrpc.UnsealedAsset) bool { + return a.Asset.Name == name + }, + ) + require.NoError(t.t, err) + + return targetAsset + } + + // Fetch the responses that match the three grouped asset requests. + assetGroupedInternalTweaked := findUnsealedAsset( + assetReqGroupedInternalTweaked.Asset.Name, unsealedAssets, + ) + assetGroupedExternal := findUnsealedAsset( + assetReqGroupedExternal.Asset.Name, unsealedAssets, + ) + assetGroupMember := findUnsealedAsset( + assetReqGroupMember.Asset.Name, unsealedAssets, + ) + + // Since Asset 3 set Asset 1 as its group anchor, their group key + // requests should overlap. The internal group key and anchor genesis + // should match, but the new asset should differ. + AssertAssetGenesis( + t.t, assetGroupedInternalTweaked.GroupKeyRequest.AnchorGenesis, + assetGroupMember.GroupKeyRequest.AnchorGenesis, + ) + require.Equal( + t.t, assetGroupedInternalTweaked.GroupKeyRequest.RawKey, + assetGroupMember.GroupKeyRequest.RawKey, + ) + require.NotEqual( + t.t, assetGroupedInternalTweaked.GroupKeyRequest.NewAsset, + assetGroupMember.GroupKeyRequest.NewAsset, + ) + + // Now we can construct any asset group witnesses needed. Before + // performing any signing, we'll create a GenesisSigner backed by + // Alice's LND node, which also derived all keypairs so far. + aliceLndSigner := taprootassets.NewLndRpcVirtualTxSigner( + &aliceLndClient.LndServices, + ) + + // For Asset 2, we'll derive a standard signature (key spend path). + groupedExternalGroupKeyRequest, groupedExternalVirtualTx := + unmarshalPendingAssetGroup(t.t, assetGroupedExternal) + groupedExternalAssetID, groupedExternalProtoAsset := + fetchProtoAssetInfo(groupedExternalGroupKeyRequest) + + groupedExternalGroupKey, err := asset.DeriveGroupKey( + aliceLndSigner, groupedExternalVirtualTx, + groupedExternalGroupKeyRequest, nil, + ) + require.NoError(t.t, err) + + validateGroupWitness( + t.t, groupedExternalProtoAsset, groupedExternalGroupKey, + ) + + groupedExternalWitness := taprpc.GroupWitness{ + GenesisId: groupedExternalAssetID[:], + Witness: groupedExternalGroupKey.Witness, + } + + // For Asset 3, we'll use a hash preimage as the asset group witness. + groupMemberGroupKeyRequest, groupMemberVirtualTx := + unmarshalPendingAssetGroup(t.t, assetGroupMember) + groupMemberAssetID, groupMemberProtoAsset := + fetchProtoAssetInfo(groupMemberGroupKeyRequest) + + // To build the control block for the hash lock, we first need to + // derive the singly tweaked group key. From there we can build the + // partial reveal of the hash lock script, and then finally the control + // block. + groupMemberAnchorID := groupMemberGroupKeyRequest.AnchorGen.ID() + groupMemberGroupInternalKey := groupMemberGroupKeyRequest.RawKey + groupMemberSinglyTweakedKey := input.TweakPubKeyWithTweak( + groupMemberGroupInternalKey.PubKey, groupMemberAnchorID[:], + ) + hashLockControlBlock, err := buildScriptSpendControlBlock( + groupMemberSinglyTweakedKey, groupInternalHashLock, + groupInternalTapTree, + ) + require.NoError(t.t, err) + + // With the control block, we can construct the full asset group + // witness, apply it to the asset, and verify it before submitting it + // to tapd. + hashLockWitness := wire.TxWitness{ + test.DefaultHashLockWitness, groupInternalHashLock.Script, + hashLockControlBlock, + } + groupMemberWitness := taprpc.GroupWitness{ + GenesisId: groupMemberAssetID[:], + Witness: hashLockWitness, + } + groupMemberGroupKey := &asset.GroupKey{ + RawKey: groupMemberGroupInternalKey, + GroupPubKey: groupMemberVirtualTx.TweakedKey, + TapscriptRoot: groupMemberGroupKeyRequest.TapscriptRoot, + Witness: hashLockWitness, + } + + validateGroupWitness( + t.t, groupMemberProtoAsset, groupMemberGroupKey, + ) + t.Logf("Asset 3 group witness:\n%v", toJSON(t.t, &groupMemberWitness)) + + // With the two group witnesses, we can seal the batch. This will + // validate the witnesses given, generate a witness for Asset 1, and + // persist these witnesses to be used during batch finalization. + sealReq := mintrpc.SealBatchRequest{ + GroupWitnesses: []*taprpc.GroupWitness{ + &groupMemberWitness, &groupedExternalWitness, + }, + } + sealResp, err := aliceTapd.SealBatch(ctxt, &sealReq) + require.NoError(t.t, err) + require.NotEmpty(t.t, sealResp.Batch) + + // With the batch sealed successfully, we can now finalize it and + // broadcast the anchor TX. + ctxc, streamCancel := context.WithCancel(context.Background()) + stream, err := aliceTapd.SubscribeMintEvents( + ctxc, &mintrpc.SubscribeMintEventsRequest{}, + ) + require.NoError(t.t, err) + sub := &EventSubscription[*mintrpc.MintEvent]{ + ClientEventStream: stream, + Cancel: streamCancel, + } + + batchTXID, batchKey := FinalizeBatchUnconfirmed( + t.t, t.lndHarness.Miner.Client, aliceTapd, assetReqs, + ) + batchAssets := ConfirmBatch( + t.t, t.lndHarness.Miner.Client, aliceTapd, assetReqs, sub, + batchTXID, batchKey, + ) + assetTweakedScriptKey, err := fn.First( + batchAssets, func(a *taprpc.Asset) bool { + return assetReqWithScriptKey.Asset.Name == + a.AssetGenesis.Name + }) + require.NoError(t.t, err) + + // We should have one group with two assets and a balance of 2. The + // other should have one asset with a balance of 5000. + collectibleGroupKey := groupMemberVirtualTx.TweakedKey + collectibleGroupKeyHex := hex.EncodeToString( + collectibleGroupKey.SerializeCompressed(), + ) + normalGroupKey := assetGroupedExternal.GroupVirtualTx.TweakedKey + groupCount := 2 + AssertNumGroups(t.t, aliceTapd, groupCount) + AssertBalanceByGroup(t.t, aliceTapd, collectibleGroupKeyHex, 2) + AssertBalanceByGroup( + t.t, aliceTapd, hex.EncodeToString(normalGroupKey), 5000, + ) + + // Let's make sure Bob receives minting proofs for this batch, and + // verify that he syncs the assets correctly. + SyncUniverses( + ctxt, t.t, bobTapd, aliceTapd, aliceTapd.rpcHost(), + defaultTimeout, + ) + + // If we fetch issuance leaves for the collectible asset group, we + // should have synced the asset group witnesses for each asset. + collectibleGroupUniID := universe.Identifier{ + GroupKey: &collectibleGroupKey, + ProofType: universe.ProofTypeIssuance, + } + rpcCollectibleGroupUniID, err := taprootassets.MarshalUniID( + collectibleGroupUniID, + ) + require.NoError(t.t, err) + collectibleGroupLeaves, err := bobTapd.AssetLeaves( + ctxt, rpcCollectibleGroupUniID, + ) + require.NoError(t.t, err) + require.Len(t.t, collectibleGroupLeaves.Leaves, 2) + + // We can then assert that Bob received and verified the hash lock asset + // group witness we created earlier. + matchingLeaf := false + for _, leaf := range collectibleGroupLeaves.Leaves { + leafGroupWitness := leaf.Asset.PrevWitnesses[0].TxWitness + for i, witElem := range hashLockWitness { + if !bytes.Equal(leafGroupWitness[i], witElem) { + break + } + } + + matchingLeaf = true + break + } + require.True(t.t, matchingLeaf) + + // Now, let's try to transfer the ungrouped asset minted with a tweaked + // script key to Bob. We'll use the PSBT flow to add witnesses for the + // asset script key and minting anchor output. + bobAddr, err := bobTapd.NewAddr(ctxt, &taprpc.NewAddrRequest{ + AssetId: assetTweakedScriptKey.AssetGenesis.AssetId, + Amt: assetTweakedScriptKey.Amount / 2, + }) + require.NoError(t.t, err) + signedAddrPsbt, signedPassivePsbts := signTransferWithTweakedScriptKey( + t, ctxt, aliceTapd, bobAddr, &tweakedScript, 2, + tweakedScriptSigLock, tweakedScriptTapTree, + ) + + // With all assets signed, we can now create the anchor PSBT for the + // transfer. We'll make a template PSBT first, and then Alice's tapd + // will commit all virtual transactions to that PSBT. If needed, an + // input and change output will be added to cover chain fees. + allSignedPsbts := append(signedAddrPsbt, signedPassivePsbts...) + transferTemplatePkt, err := tapsend.PrepareAnchoringTemplate( + allSignedPsbts, + ) + require.NoError(t.t, err) + + transferPkt, bobVpsbt, passiveVpsbts, commitResp := CommitVirtualPsbts( + t.t, aliceTapd, transferTemplatePkt, signedAddrPsbt, + signedPassivePsbts, -1, + ) + + // The last step is constructing a witness for the transfer anchor + // input, which is the genesis output from the minting batch. We'll + // satisfy the 2-of-2 multisig script we specified when funding the + // batch. + // To build the control block, we need the internal key from that + // output, and the Taproot Asset root hash used for that batch. This + // output is currently leased for the transfer we're constructing. + assetInputIdx := uint32(0) + aliceUtxoResp, err := aliceTapd.ListUtxos( + ctxt, &taprpc.ListUtxosRequest{ + IncludeLeased: true, + }, + ) + require.NoError(t.t, err) + require.Len(t.t, aliceUtxoResp.ManagedUtxos, 1) + anchorOutpoint := wire.OutPoint{ + Hash: batchTXID, + Index: 0, + } + anchorUTXO, ok := aliceUtxoResp.ManagedUtxos[anchorOutpoint.String()] + require.True(t.t, ok) + + anchorInputWitness := signMultisigAnchorScript( + t.t, aliceLnd.RPC, regtestParams, transferPkt, assetInputIdx, + firstAnchorInternal, secondAnchorInternal, anchorUTXO, + anchorMultisigScript, + ) + + var witBuf bytes.Buffer + err = psbt.WriteTxWitness(&witBuf, anchorInputWitness) + require.NoError(t.t, err) + + transferPkt.Inputs[assetInputIdx].FinalScriptWitness = witBuf.Bytes() + + // Finalize and publish the transfer anchor TX. + signedPkt := FinalizePacket(t.t, aliceLnd.RPC, transferPkt) + logResp := LogAndPublish( + t.t, aliceTapd, signedPkt, bobVpsbt, passiveVpsbts, + commitResp, + ) + t.Logf("Logged transaction: %v", toJSON(t.t, logResp)) + + // Mine a block and confirm that Alice registers the transfer correctly. + transferAmount := assetTweakedScriptKey.Amount / 2 + numOutputs := 2 + ConfirmAndAssertOutboundTransferWithOutputs( + t.t, t.lndHarness.Miner.Client, aliceTapd, logResp, + assetTweakedScriptKey.AssetGenesis.AssetId, + []uint64{transferAmount, transferAmount}, 0, 1, numOutputs, + ) + + // Bob should have detected the transfer, and now own half of the total + // asset supply. + AssertAddrEvent(t.t, bobTapd, bobAddr, 1, statusCompleted) + AssertNonInteractiveRecvComplete(t.t, bobTapd, 1) + AssertBalanceByID( + t.t, bobTapd, assetTweakedScriptKey.AssetGenesis.AssetId, + assetTweakedScriptKey.Amount/2, + ) + + // Alice's balance for the passive assets should be the same. + AssertNumGroups(t.t, aliceTapd, groupCount) + AssertBalanceByGroup(t.t, aliceTapd, collectibleGroupKeyHex, 2) + AssertBalanceByGroup( + t.t, aliceTapd, hex.EncodeToString(normalGroupKey), 5000, + ) + + // None of the anchor outputs should have a tapscript sibling. + fn.All(logResp.Transfer.Outputs, func(out *taprpc.TransferOutput) bool { + anchor := out.Anchor + return bytes.Equal(anchor.TaprootAssetRoot, anchor.MerkleRoot) + }) +} + +// 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, + keyRing *taprootassets.LndRpcKeyRing) keychain.KeyDescriptor { + + var ( + randFam = test.RandInt31n(math.MaxInt32) + randInd = test.RandInt31n(255) + desc keychain.KeyDescriptor + err error + ) + + // Ensure that we use a different key family from tapd. + for randFam == asset.TaprootAssetsKeyFamily { + randFam = test.RandInt31n(math.MaxInt32) + } + + desc, err = keyRing.DeriveNextKey( + ctxt, keychain.KeyFamily(randFam), + ) + require.NoError(t, err) + + // Set the desired key index to always be beyond the current + // index. + randInd += int32(desc.KeyLocator.Index) + for i := int32(0); i < randInd; i++ { + desc, err = keyRing.DeriveNextKey( + ctxt, keychain.KeyFamily(randFam), + ) + require.NoError(t, err) + } + + return desc +} + +func buildTweakedScriptKey(t *testing.T, internalKey *keychain.KeyDescriptor, + hashLockWitness []byte, sigLockKey *btcec.PublicKey) (asset.ScriptKey, + *txscript.IndexedTapScriptTree) { + + tweakedScriptHashLock := test.ScriptHashLock( + t, bytes.Clone(hashLockWitness), + ) + tweakedScriptSigLock := test.ScriptSchnorrSig(t, sigLockKey) + tapTree := txscript.AssembleTaprootScriptTree( + tweakedScriptHashLock, tweakedScriptSigLock, + ) + scriptTweak := tapTree.RootNode.TapHash() + tweakedPubKey := txscript.ComputeTaprootOutputKey( + internalKey.PubKey, scriptTweak[:], + ) + + tweakedScriptKey := asset.ScriptKey{ + PubKey: tweakedPubKey, + TweakedScriptKey: &asset.TweakedScriptKey{ + RawKey: *internalKey, + Tweak: scriptTweak[:], + }, + } + + return tweakedScriptKey, tapTree +} + +func computeGroupKeyTweak(t *testing.T, sigLockKey *btcec.PublicKey, + useHashLock bool) ([]byte, txscript.TapLeaf, + *txscript.IndexedTapScriptTree) { + + hashLock := test.ScriptHashLock( + t, bytes.Clone(test.DefaultHashLockWitness), + ) + sigLock := test.ScriptSchnorrSig(t, sigLockKey) + tapTree := txscript.AssembleTaprootScriptTree(hashLock, sigLock) + tapTweak := tapTree.RootNode.TapHash() + + if useHashLock { + return tapTweak[:], hashLock, tapTree + } + + return tapTweak[:], sigLock, tapTree +} + +func buildMultisigTapLeaf(t *testing.T, + pubkey1, pubkey2 *btcec.PublicKey) ([]byte, + mintrpc.FundBatchRequest_FullTree) { + + multisigScript, err := txscript.NewScriptBuilder(). + AddData(schnorr.SerializePubKey(pubkey1)). + AddOp(txscript.OP_CHECKSIG). + AddData(schnorr.SerializePubKey(pubkey2)). + AddOp(txscript.OP_CHECKSIGADD). + AddInt64(2). + AddOp(txscript.OP_EQUAL). + Script() + require.NoError(t, err) + + multisigLeaf := txscript.TapLeaf{ + LeafVersion: txscript.BaseLeafVersion, + Script: multisigScript, + } + rpcLeaf := taprpc.TapLeaf{ + Script: multisigLeaf.Script, + } + siblingReq := mintrpc.FundBatchRequest_FullTree{ + FullTree: &taprpc.TapscriptFullTree{ + AllLeaves: []*taprpc.TapLeaf{&rpcLeaf}, + }, + } + + return multisigScript, siblingReq +} + +func unmarshalPendingAssetGroup(t *testing.T, + a *mintrpc.UnsealedAsset) (asset.GroupKeyRequest, + asset.GroupVirtualTx) { + + require.NotNil(t, a.GroupVirtualTx) + virtualTx, err := taprpc.UnmarshalGroupVirtualTx(a.GroupVirtualTx) + require.NoError(t, err) + + require.NotNil(t, a.GroupKeyRequest) + keyReq, err := taprpc.UnmarshalGroupKeyRequest(a.GroupKeyRequest) + require.NoError(t, err) + + return *keyReq, *virtualTx +} + +func buildScriptSpendControlBlock(singlyTweakedKey *btcec.PublicKey, + usedLeaf txscript.TapLeaf, + tapTree *txscript.IndexedTapScriptTree) ([]byte, error) { + + leafTapHash := usedLeaf.TapHash() + tapscriptProofIdx := tapTree.LeafProofIndex[leafTapHash] + tapscriptProof := tapTree.LeafMerkleProofs[tapscriptProofIdx] + partialReveal := input.TapscriptPartialReveal( + singlyTweakedKey, usedLeaf, tapscriptProof.InclusionProof, + ) + + return partialReveal.ControlBlock.ToBytes() +} + +func signTransferWithTweakedScriptKey(t *harnessTest, ctxt context.Context, + sender *tapdHarness, addr *taprpc.Addr, scriptKey *asset.ScriptKey, + passiveAssetCount int, sigLockLeaf txscript.TapLeaf, + tapTree *txscript.IndexedTapScriptTree) ([]*tappsbt.VPacket, + []*tappsbt.VPacket) { + + encodeVpsbt := func(psbt *tappsbt.VPacket) []byte { + var b bytes.Buffer + require.NoError(t.t, psbt.Serialize(&b)) + return b.Bytes() + } + decodeVpsbt := func(psbt []byte) *tappsbt.VPacket { + vpsbt, err := tappsbt.NewFromRawBytes( + bytes.NewReader(psbt), false, + ) + require.NoError(t.t, err) + return vpsbt + } + + // The sender will build a set of vPSBTs representing the transfer and + // moving the other assets from the same minting batch. + fundAddrResp := fundAddressSendPacket(t, sender, addr) + fundedPacket := decodeVpsbt(fundAddrResp.FundedPsbt) + require.Len(t.t, fundAddrResp.PassiveAssetPsbts, passiveAssetCount+1) + + // We'll use the sig lock of the tweaked script key to build our + // asset transfer witness. + tweakedScriptControlBlock, err := buildScriptSpendControlBlock( + scriptKey.RawKey.PubKey, sigLockLeaf, tapTree, + ) + require.NoError(t.t, err) + + fundedPacket.Inputs[0].TaprootLeafScript = []*psbt.TaprootTapLeafScript{ + { + ControlBlock: tweakedScriptControlBlock, + Script: sigLockLeaf.Script, + LeafVersion: sigLockLeaf.LeafVersion, + }, + } + sigLockLeafHash := sigLockLeaf.TapHash() + fundedPacket.Inputs[0].TaprootBip32Derivation[0].LeafHashes = [][]byte{ + sigLockLeafHash[:], + } + + // With the sig lock information added, the sender's tapd can create the + // sig lock witness. + signedAddrResp, err := sender.SignVirtualPsbt( + ctxt, &wrpc.SignVirtualPsbtRequest{ + FundedPsbt: encodeVpsbt(fundedPacket), + }, + ) + require.NoError(t.t, err) + require.Contains(t.t, signedAddrResp.SignedInputs, uint32(0)) + + // We also need to sign a transfer for the other assets of the minting + // batch. + signedAddrPsbt := []*tappsbt.VPacket{ + decodeVpsbt(signedAddrResp.SignedPsbt), + } + signedPassivePsbts := []*tappsbt.VPacket{} + for i := range fundAddrResp.PassiveAssetPsbts { + passiveResp, err := sender.SignVirtualPsbt( + ctxt, &wrpc.SignVirtualPsbtRequest{ + FundedPsbt: fundAddrResp.PassiveAssetPsbts[i], + }, + ) + require.NoError(t.t, err) + + signedPassivePsbts = append( + signedPassivePsbts, decodeVpsbt(passiveResp.SignedPsbt), + ) + } + + return signedAddrPsbt, signedPassivePsbts +} + +func signMultisigAnchorScript(t *testing.T, lnd *rpc.HarnessRPC, + params *chaincfg.Params, pkt *psbt.Packet, inputIndex uint32, + key1, key2 keychain.KeyDescriptor, utxo *taprpc.ManagedUtxo, + multisigScript []byte) wire.TxWitness { + + anchorInputInternalKey, err := btcec.ParsePubKey(utxo.InternalKey) + require.NoError(t, err) + + anchorInputOutputKey := txscript.ComputeTaprootOutputKey( + anchorInputInternalKey, utxo.MerkleRoot, + ) + anchorKeyYIsOdd := anchorInputOutputKey.SerializeCompressed()[0] == + secp256k1.PubKeyFormatCompressedOdd + + anchorInputControlBlock := txscript.ControlBlock{ + InternalKey: anchorInputInternalKey, + OutputKeyYIsOdd: anchorKeyYIsOdd, + LeafVersion: txscript.BaseLeafVersion, + InclusionProof: utxo.TaprootAssetRoot, + } + anchorInputControlBlockBytes, err := anchorInputControlBlock.ToBytes() + require.NoError(t, err) + + // With our control block, we can generate the two needed signatures + // and construct the anchor witness. + anchorMultisigLeaf := txscript.TapLeaf{ + LeafVersion: txscript.BaseLeafVersion, + Script: multisigScript, + } + firstKeyPartialSig := partialSignWithKey( + t, lnd, params, pkt, inputIndex, key1, + anchorInputControlBlockBytes, anchorMultisigLeaf, + ) + secondKeyPartialSig := partialSignWithKey( + t, lnd, params, pkt, inputIndex, key2, + anchorInputControlBlockBytes, anchorMultisigLeaf, + ) + + anchorInputWitness := wire.TxWitness{ + secondKeyPartialSig, + firstKeyPartialSig, + multisigScript, + anchorInputControlBlockBytes, + } + + return anchorInputWitness +} + +func fetchProtoAssetInfo(groupReq asset.GroupKeyRequest) (asset.ID, + *asset.Asset) { + + return groupReq.NewAsset.ID(), groupReq.NewAsset +} + +func validateGroupWitness(t *testing.T, protoAsset *asset.Asset, + newGroup *asset.GroupKey) { + + assetWithGroup := protoAsset.Copy() + assetWithGroup.GroupKey = newGroup + assetWithGroup.PrevWitnesses[0].TxWitness = newGroup.Witness + + witnessValidator := taprootassets.ValidatorV0{} + err := witnessValidator.Execute(assetWithGroup, nil, nil) + require.NoError(t, err) +} diff --git a/itest/multisig.go b/itest/multisig.go index 560b0ec2ab..fc6d68c61b 100644 --- a/itest/multisig.go +++ b/itest/multisig.go @@ -17,7 +17,6 @@ import ( "github.com/davecgh/go-spew/spew" "github.com/decred/dcrd/dcrec/secp256k1/v4" "github.com/lightninglabs/lndclient" - tap "github.com/lightninglabs/taproot-assets" "github.com/lightninglabs/taproot-assets/asset" "github.com/lightninglabs/taproot-assets/commitment" "github.com/lightninglabs/taproot-assets/fn" @@ -171,7 +170,7 @@ func MultiSigTest(t *testing.T, ctx context.Context, aliceTapd, muSig2Addr, err := bobTapd.NewAddr(ctxt, &taprpc.NewAddrRequest{ AssetId: firstBatchGenesis.AssetId, Amt: assetsToSend, - ScriptKey: tap.MarshalScriptKey(tapScriptKey), + ScriptKey: taprpc.MarshalScriptKey(tapScriptKey), InternalKey: &taprpc.KeyDescriptor{ RawKeyBytes: pubKeyBytes(btcInternalKey), }, @@ -372,7 +371,7 @@ func DeriveKeys(t *testing.T, tapd TapdClient) (asset.ScriptKey, }, ) require.NoError(t, err) - scriptKey, err := tap.UnmarshalScriptKey(scriptKeyDesc.ScriptKey) + scriptKey, err := taprpc.UnmarshalScriptKey(scriptKeyDesc.ScriptKey) require.NoError(t, err) internalKeyDesc, err := tapd.NextInternalKey( @@ -381,7 +380,7 @@ func DeriveKeys(t *testing.T, tapd TapdClient) (asset.ScriptKey, }, ) require.NoError(t, err) - internalKeyLnd, err := tap.UnmarshalKeyDescriptor( + internalKeyLnd, err := taprpc.UnmarshalKeyDescriptor( internalKeyDesc.InternalKey, ) require.NoError(t, err) diff --git a/itest/psbt_test.go b/itest/psbt_test.go index 5212c3f441..e9d0dff99f 100644 --- a/itest/psbt_test.go +++ b/itest/psbt_test.go @@ -2184,11 +2184,13 @@ func sendToTapscriptAddr(ctx context.Context, t *harnessTest, alice, Amt: numUnits, AssetVersion: mintedAsset.Version, ScriptKey: &taprpc.ScriptKey{ - PubKey: schnorr.SerializePubKey(bobAssetScriptKey), - KeyDesc: lndKeyDescToTap(bobScriptKey.RawKey), + PubKey: schnorr.SerializePubKey(bobAssetScriptKey), + KeyDesc: taprpc.MarshalKeyDescriptor( + bobScriptKey.RawKey, + ), TapTweak: rootHash, }, - InternalKey: lndKeyDescToTap(bobInternalKey), + InternalKey: taprpc.MarshalKeyDescriptor(bobInternalKey), }) require.NoError(t.t, err) diff --git a/itest/test_harness.go b/itest/test_harness.go index 3d6a50c909..45a20146a2 100644 --- a/itest/test_harness.go +++ b/itest/test_harness.go @@ -20,7 +20,6 @@ import ( "github.com/lightninglabs/taproot-assets/taprpc" unirpc "github.com/lightninglabs/taproot-assets/taprpc/universerpc" "github.com/lightningnetwork/lnd/build" - "github.com/lightningnetwork/lnd/keychain" "github.com/lightningnetwork/lnd/lntest" "github.com/lightningnetwork/lnd/lntest/node" "github.com/lightningnetwork/lnd/lntest/wait" @@ -531,17 +530,6 @@ func toJSON(t *testing.T, resp proto.Message) string { return jsonStr } -// lndKeyDescToTap converts an lnd key descriptor to a tap key descriptor. -func lndKeyDescToTap(lnd keychain.KeyDescriptor) *taprpc.KeyDescriptor { - return &taprpc.KeyDescriptor{ - RawKeyBytes: lnd.PubKey.SerializeCompressed(), - KeyLoc: &taprpc.KeyLocator{ - KeyFamily: int32(lnd.Family), - KeyIndex: int32(lnd.Index), - }, - } -} - // LogfTimestamped logs the given message with the current timestamp. func LogfTimestamped(t *testing.T, format string, args ...interface{}) { timestamp := time.Now().Format(time.RFC3339Nano) diff --git a/itest/test_list_on_test.go b/itest/test_list_on_test.go index 69f30050fe..b7e58477b5 100644 --- a/itest/test_list_on_test.go +++ b/itest/test_list_on_test.go @@ -21,6 +21,10 @@ var testCases = []*testCase{ name: "mint assets with tap sibling", test: testMintAssetsWithTapscriptSibling, }, + { + name: "mint fund seal assets", + test: testMintFundSealAssets, + }, { name: "addresses", test: testAddresses, diff --git a/itest/utils.go b/itest/utils.go index aa4ddc1e00..4e01f8ea7a 100644 --- a/itest/utils.go +++ b/itest/utils.go @@ -282,12 +282,8 @@ func WithSiblingTree(tree mintrpc.FinalizeBatchRequest_FullTree) MintOption { } } -// MintAssetUnconfirmed is a helper function that mints a batch of assets and -// waits until the minting transaction is in the mempool but does not mine a -// block. -func MintAssetUnconfirmed(t *testing.T, minerClient *rpcclient.Client, - tapClient TapdClient, assetRequests []*mintrpc.MintAssetRequest, - opts ...MintOption) (chainhash.Hash, []byte) { +func BuildMintingBatch(t *testing.T, tapClient TapdClient, + assetRequests []*mintrpc.MintAssetRequest, opts ...MintOption) { options := DefaultMintOptions() for _, opt := range opts { @@ -305,6 +301,20 @@ func MintAssetUnconfirmed(t *testing.T, minerClient *rpcclient.Client, require.NotEmpty(t, assetResp.PendingBatch) require.Len(t, assetResp.PendingBatch.Assets, idx+1) } +} + +func FinalizeBatchUnconfirmed(t *testing.T, minerClient *rpcclient.Client, + tapClient TapdClient, assetRequests []*mintrpc.MintAssetRequest, + opts ...MintOption) (chainhash.Hash, []byte) { + + options := DefaultMintOptions() + for _, opt := range opts { + opt(options) + } + + ctxb := context.Background() + ctxt, cancel := context.WithTimeout(ctxb, options.mintingTimeout) + defer cancel() finalizeReq := &mintrpc.FinalizeBatchRequest{} @@ -366,12 +376,35 @@ func MintAssetUnconfirmed(t *testing.T, minerClient *rpcclient.Client, AssetAnchorCheck(*hashes[0], zeroHash), AssetScriptKeyIsLocalCheck(true), AssetVersionCheck(assetRequest.Asset.AssetVersion), + AssetScriptKeyCheck(assetRequest.Asset.ScriptKey), + AssetIsGroupedCheck( + assetRequest.Asset.NewGroupedAsset, + assetRequest.Asset.GroupedAsset, + ), + AssetGroupTapscriptRootCheck( + assetRequest.Asset.GroupTapscriptRoot, + ), ) } return *hashes[0], batchResp.Batch.BatchKey } +// MintAssetUnconfirmed is a helper function that mints a batch of assets and +// waits until the minting transaction is in the mempool but does not mine a +// block. +func MintAssetUnconfirmed(t *testing.T, minerClient *rpcclient.Client, + tapClient TapdClient, assetRequests []*mintrpc.MintAssetRequest, + opts ...MintOption) (chainhash.Hash, []byte) { + + // Submit all the assets in the same batch. + BuildMintingBatch(t, tapClient, assetRequests, opts...) + + return FinalizeBatchUnconfirmed( + t, minerClient, tapClient, assetRequests, opts..., + ) +} + // MintAssetsConfirmBatch mints all given assets in the same batch, confirms the // batch and verifies all asset proofs of the minted assets. func MintAssetsConfirmBatch(t *testing.T, minerClient *rpcclient.Client, @@ -392,6 +425,17 @@ func MintAssetsConfirmBatch(t *testing.T, minerClient *rpcclient.Client, t, minerClient, tapClient, assetRequests, opts..., ) + return ConfirmBatch( + t, minerClient, tapClient, assetRequests, sub, mintTXID, + batchKey, opts..., + ) +} + +func ConfirmBatch(t *testing.T, minerClient *rpcclient.Client, + tapClient TapdClient, assetRequests []*mintrpc.MintAssetRequest, + sub *EventSubscription[*mintrpc.MintEvent], mintTXID chainhash.Hash, + batchKey []byte, opts ...MintOption) []*taprpc.Asset { + options := DefaultMintOptions() for _, opt := range opts { opt(options) @@ -422,7 +466,7 @@ func MintAssetsConfirmBatch(t *testing.T, minerClient *rpcclient.Client, require.Len(t, batchResp.Batches, 1) batch := batchResp.Batches[0] - require.NotEmpty(t, batch.BatchTxid) + require.NotEmpty(t, batch.Batch.BatchTxid) return AssertAssetsMinted( t, tapClient, assetRequests, mintTXID, blockHash, diff --git a/monitoring/garden_collector.go b/monitoring/garden_collector.go index c37e96e838..feca942993 100644 --- a/monitoring/garden_collector.go +++ b/monitoring/garden_collector.go @@ -73,7 +73,9 @@ func (a *gardenCollector) Collect(ch chan<- prometheus.Metric) { a.completedBatches.Set(0) // Get the number of pending batches. - batches, err := a.cfg.AssetMinter.ListBatches(nil) + batches, err := a.cfg.AssetMinter.ListBatches( + tapgarden.ListBatchesParams{}, + ) if err != nil { log.Errorf("unable to list batches: %v", err) return diff --git a/perms/perms.go b/perms/perms.go index a4f754a39c..fad39de303 100644 --- a/perms/perms.go +++ b/perms/perms.go @@ -140,6 +140,14 @@ var ( Entity: "mint", Action: "write", }}, + "/mintrpc.Mint/FundBatch": {{ + Entity: "mint", + Action: "write", + }}, + "/mintrpc.Mint/SealBatch": {{ + Entity: "mint", + Action: "write", + }}, "/mintrpc.Mint/FinalizeBatch": {{ Entity: "mint", Action: "write", diff --git a/rpcserver.go b/rpcserver.go index bd0fe1a0db..b94a22d716 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -19,7 +19,6 @@ import ( "github.com/btcsuite/btcd/btcec/v2/schnorr" "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/wtxmgr" "github.com/davecgh/go-spew/spew" @@ -56,6 +55,7 @@ import ( "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/routing/route" "github.com/lightningnetwork/lnd/signal" + "golang.org/x/exp/maps" "golang.org/x/time/rate" "google.golang.org/grpc" ) @@ -425,6 +425,16 @@ func (r *rpcServer) MintAsset(ctx context.Context, specificGroupKey := len(req.Asset.GroupKey) != 0 specificGroupAnchor := len(req.Asset.GroupAnchor) != 0 + specificGroupInternalKey := req.Asset.GroupInternalKey != nil + groupTapscriptRootSize := len(req.Asset.GroupTapscriptRoot) + + // A group tapscript root must be 32 bytes. + if groupTapscriptRootSize != 0 && + groupTapscriptRootSize != sha256.Size { + + return nil, fmt.Errorf("group tapscript root must be %d bytes", + sha256.Size) + } switch { // New grouped asset and grouped asset cannot both be set. @@ -440,8 +450,19 @@ func (r *rpcServer) MintAsset(ctx context.Context, "specify a group") } + // A group tapscript root cannot be specified if emission is disabled. + case !req.Asset.NewGroupedAsset && groupTapscriptRootSize != 0: + return nil, fmt.Errorf("cannot specify a group tapscript root" + + "with emission disabled") + + // A group internal key cannot be specified if emission is disabled. + case !req.Asset.NewGroupedAsset && specificGroupInternalKey: + return nil, fmt.Errorf("cannot specify a group internal key" + + "with emission disabled") + // If the asset is intended to be part of an existing group, a group key - // or anchor must be specified, but not both. + // or anchor must be specified, but not both. Neither a group tapscript + // root nor group internal key can be specified. case req.Asset.GroupedAsset: if !specificGroupKey && !specificGroupAnchor { return nil, fmt.Errorf("must specify a group key or" + @@ -453,6 +474,16 @@ func (r *rpcServer) MintAsset(ctx context.Context, "key and a group anchor") } + if groupTapscriptRootSize != 0 { + return nil, fmt.Errorf("cannot specify a group " + + "tapscript root with emission disabled") + } + + if specificGroupInternalKey { + return nil, fmt.Errorf("cannot specify a group " + + "internal key with emission disabled") + } + // A group was specified without GroupedAsset being set. case specificGroupKey || specificGroupAnchor: return nil, fmt.Errorf("must set grouped asset to mint into " + @@ -466,6 +497,33 @@ func (r *rpcServer) MintAsset(ctx context.Context, return nil, err } + // Parse the optional script key and group internal key. The group + // tapscript root was length-checked above. + var ( + scriptKey *asset.ScriptKey + groupInternalKey keychain.KeyDescriptor + groupTapscriptRoot []byte + ) + if req.Asset.ScriptKey != nil { + scriptKey, err = taprpc.UnmarshalScriptKey(req.Asset.ScriptKey) + if err != nil { + return nil, err + } + } + + if specificGroupInternalKey { + groupInternalKey, err = taprpc.UnmarshalKeyDescriptor( + req.Asset.GroupInternalKey, + ) + if err != nil { + return nil, err + } + } + + if groupTapscriptRootSize != 0 { + groupTapscriptRoot = bytes.Clone(req.Asset.GroupTapscriptRoot) + } + seedling := &tapgarden.Seedling{ AssetVersion: assetVersion, AssetType: asset.Type(req.Asset.AssetType), @@ -478,6 +536,18 @@ func (r *rpcServer) MintAsset(ctx context.Context, "issuance=%v", seedling.AssetVersion, seedling.AssetType, seedling.AssetName, seedling.Amount, seedling.EnableEmission) + if scriptKey != nil { + seedling.ScriptKey = *scriptKey + } + + if specificGroupInternalKey { + seedling.GroupInternalKey = &groupInternalKey + } + + if groupTapscriptRootSize != 0 { + seedling.GroupTapscriptRoot = groupTapscriptRoot + } + switch { // If a group key is provided, parse the provided group public key // before creating the asset seedling. @@ -580,12 +650,9 @@ func checkFeeRateSanity(rpcFeeRate uint32) (*chainfee.SatPerKWeight, error) { } } -// FinalizeBatch attempts to finalize the current pending batch. -func (r *rpcServer) FinalizeBatch(_ context.Context, - req *mintrpc.FinalizeBatchRequest) (*mintrpc.FinalizeBatchResponse, - error) { - - var batchSibling *asset.TapscriptTreeNodes +// FundBatch attempts to fund the current pending batch. +func (r *rpcServer) FundBatch(_ context.Context, + req *mintrpc.FundBatchRequest) (*mintrpc.FundBatchResponse, error) { feeRate, err := checkFeeRateSanity(req.FeeRate) if err != nil { @@ -593,29 +660,89 @@ func (r *rpcServer) FinalizeBatch(_ context.Context, } feeRateOpt := fn.MaybeSome(feeRate) - batchTapscriptTree := req.GetFullTree() - batchTapBranch := req.GetBranch() + tapTreeOpt, err := taprpc.UnmarshalTapscriptSibling( + req.GetFullTree(), req.GetBranch(), + ) + if err != nil { + return nil, err + } - switch { - case batchTapscriptTree != nil && batchTapBranch != nil: - return nil, fmt.Errorf("cannot specify both tapscript tree " + - "and tapscript tree branches") + batch, err := r.cfg.AssetMinter.FundBatch( + tapgarden.FundParams{ + FeeRate: feeRateOpt, + SiblingTapTree: tapTreeOpt, + }, + ) + if err != nil { + return nil, fmt.Errorf("unable to fund batch: %w", err) + } - case batchTapscriptTree != nil: - batchSibling, err = marshalTapscriptFullTree(batchTapscriptTree) - if err != nil { - return nil, fmt.Errorf("invalid tapscript tree: %w", - err) - } + // If there was no batch to fund, return an empty response. + if batch == nil { + return &mintrpc.FundBatchResponse{}, nil + } - case batchTapBranch != nil: - batchSibling, err = marshalTapscriptBranch(batchTapBranch) + rpcBatch, err := marshalMintingBatch(batch, req.ShortResponse) + if err != nil { + return nil, err + } + + return &mintrpc.FundBatchResponse{ + Batch: rpcBatch, + }, nil +} + +// SealBatch attempts to seal the current pending batch, validating provided +// asset group witnesses and generating asset group witnesses as needed. +func (r *rpcServer) SealBatch(ctx context.Context, + req *mintrpc.SealBatchRequest) (*mintrpc.SealBatchResponse, error) { + + var groupWitnesses []asset.PendingGroupWitness + for i := range req.GroupWitnesses { + wit, err := taprpc.UnmarshalGroupWitness(req.GroupWitnesses[i]) if err != nil { - return nil, fmt.Errorf("invalid tapscript branch: %w", - err) + return nil, err } + + groupWitnesses = append(groupWitnesses, *wit) + } + + batch, err := r.cfg.AssetMinter.SealBatch( + tapgarden.SealParams{ + GroupWitnesses: groupWitnesses, + }, + ) + if err != nil { + return nil, err + } + + rpcBatch, err := marshalMintingBatch(batch, req.ShortResponse) + if err != nil { + return nil, err + } + + return &mintrpc.SealBatchResponse{ + Batch: rpcBatch, + }, nil +} + +// FinalizeBatch attempts to finalize the current pending batch. +func (r *rpcServer) FinalizeBatch(_ context.Context, + req *mintrpc.FinalizeBatchRequest) (*mintrpc.FinalizeBatchResponse, + error) { + + feeRate, err := checkFeeRateSanity(req.FeeRate) + if err != nil { + return nil, err + } + feeRateOpt := fn.MaybeSome(feeRate) + + tapTreeOpt, err := taprpc.UnmarshalTapscriptSibling( + req.GetFullTree(), req.GetBranch(), + ) + if err != nil { + return nil, err } - tapTreeOpt := fn.MaybeSome(batchSibling) batch, err := r.cfg.AssetMinter.FinalizeBatch( tapgarden.FinalizeParams{ @@ -664,7 +791,7 @@ func (r *rpcServer) CancelBatch(_ context.Context, // ListBatches lists the set of batches submitted for minting, including pending // and cancelled batches. -func (r *rpcServer) ListBatches(_ context.Context, +func (r *rpcServer) ListBatches(ctx context.Context, req *mintrpc.ListBatchRequest) (*mintrpc.ListBatchResponse, error) { var ( @@ -696,15 +823,21 @@ func (r *rpcServer) ListBatches(_ context.Context, } } - batches, err := r.cfg.AssetMinter.ListBatches(batchKey) + batches, err := r.cfg.AssetMinter.ListBatches( + tapgarden.ListBatchesParams{ + BatchKey: batchKey, + Verbose: req.Verbose, + }, + ) if err != nil { return nil, fmt.Errorf("unable to list batches: %w", err) } rpcBatches, err := fn.MapErr( - batches, - func(b *tapgarden.MintingBatch) (*mintrpc.MintingBatch, error) { - return marshalMintingBatch(b, false) + batches, func(b *tapgarden.VerboseBatch) (*mintrpc.VerboseBatch, + error) { + + return marshalVerboseBatch(ctx, b, req.Verbose, false) }, ) if err != nil { @@ -1237,7 +1370,7 @@ func (r *rpcServer) NewAddr(ctx context.Context, // Both the script and internal keys were specified. default: - scriptKey, err := UnmarshalScriptKey(req.ScriptKey) + scriptKey, err := taprpc.UnmarshalScriptKey(req.ScriptKey) if err != nil { return nil, fmt.Errorf("unable to decode script key: "+ "%w", err) @@ -1255,7 +1388,9 @@ func (r *rpcServer) NewAddr(ctx context.Context, scriptKey.RawKey.PubKey.SerializeCompressed(), scriptKey.Tweak[:]) - internalKey, err := UnmarshalKeyDescriptor(req.InternalKey) + internalKey, err := taprpc.UnmarshalKeyDescriptor( + req.InternalKey, + ) if err != nil { return nil, fmt.Errorf("unable to decode internal "+ "key: %w", err) @@ -2537,7 +2672,7 @@ func (r *rpcServer) NextInternalKey(ctx context.Context, } return &wrpc.NextInternalKeyResponse{ - InternalKey: marshalKeyDescriptor(keyDesc), + InternalKey: taprpc.MarshalKeyDescriptor(keyDesc), }, nil } @@ -2563,7 +2698,7 @@ func (r *rpcServer) NextScriptKey(ctx context.Context, } return &wrpc.NextScriptKeyResponse{ - ScriptKey: MarshalScriptKey(scriptKey), + ScriptKey: taprpc.MarshalScriptKey(scriptKey), }, nil } @@ -2611,7 +2746,7 @@ func (r *rpcServer) QueryInternalKey(ctx context.Context, } return &wrpc.QueryInternalKeyResponse{ - InternalKey: marshalKeyDescriptor(keychain.KeyDescriptor{ + InternalKey: taprpc.MarshalKeyDescriptor(keychain.KeyDescriptor{ PubKey: internalKey, KeyLocator: keyLocator, }), @@ -2721,7 +2856,7 @@ func (r *rpcServer) QueryScriptKey(ctx context.Context, } return &wrpc.QueryScriptKeyResponse{ - ScriptKey: MarshalScriptKey(asset.ScriptKey{ + ScriptKey: taprpc.MarshalScriptKey(asset.ScriptKey{ PubKey: scriptKey, TweakedScriptKey: tweakedKey, }), @@ -3714,6 +3849,42 @@ func marshalSendEvent(event fn.Event) (*taprpc.SendEvent, error) { return result, nil } +// marshalVerboseBatch marshals a minting batch into the RPC counterpart. +func marshalVerboseBatch(ctx context.Context, batch *tapgarden.VerboseBatch, + verbose bool, skipSeedlings bool) (*mintrpc.VerboseBatch, error) { + + rpcMintingBatch, err := marshalMintingBatch( + batch.MintingBatch, skipSeedlings, + ) + if err != nil { + return nil, err + } + + rpcBatch := &mintrpc.VerboseBatch{ + Batch: rpcMintingBatch, + } + + // If we don't need to include the seedlings, we can return here. + if skipSeedlings { + return rpcBatch, nil + } + + // No sprouts, so we marshal the seedlings. + // We only need to convert the seedlings to unsealed seedlings. + if len(batch.UnsealedSeedlings) > 0 { + rpcBatch.UnsealedAssets, err = marshalUnsealedSeedlings( + ctx, verbose, batch.UnsealedSeedlings, + ) + if err != nil { + return nil, err + } + + rpcBatch.Batch.Assets = nil + } + + return rpcBatch, nil +} + // marshalMintingBatch marshals a minting batch into the RPC counterpart. func marshalMintingBatch(batch *tapgarden.MintingBatch, skipSeedlings bool) (*mintrpc.MintingBatch, error) { @@ -3733,18 +3904,21 @@ func marshalMintingBatch(batch *tapgarden.MintingBatch, // If we have the genesis packet available (funded+signed), then we'll // display the txid as well. if batch.GenesisPacket != nil { - batchTx, err := psbt.Extract(batch.GenesisPacket.Pkt) - if err == nil { - rpcBatch.BatchTxid = batchTx.TxHash().String() - } else { - rpcsLog.Errorf("unable to extract batch tx: %v", err) - } - rpcBatch.BatchPsbt, err = serialize(batch.GenesisPacket.Pkt) if err != nil { return nil, fmt.Errorf("error serializing batch PSBT: "+ "%w", err) } + + if batch.State() > tapgarden.BatchStateFrozen { + batchTx, err := psbt.Extract(batch.GenesisPacket.Pkt) + if err == nil { + rpcBatch.BatchTxid = batchTx.TxHash().String() + } else { + rpcsLog.Errorf("unable to extract batch tx: %v", + err) + } + } } // If we don't need to include the seedlings, we can return here. @@ -3776,55 +3950,129 @@ func marshalMintingBatch(batch *tapgarden.MintingBatch, return rpcBatch, nil } -// marshalSeedlings marshals the seedlings into the RPC counterpart. -func marshalSeedlings( - seedlings map[string]*tapgarden.Seedling) ([]*mintrpc.PendingAsset, +// marshalSeedling marshals a seedling into the RPC counterpart. +func marshalSeedling(seedling *tapgarden.Seedling) (*mintrpc.PendingAsset, error) { - rpcAssets := make([]*mintrpc.PendingAsset, 0, len(seedlings)) - for _, seedling := range seedlings { - var groupKeyBytes []byte - if seedling.HasGroupKey() { - groupKey := seedling.GroupInfo.GroupKey - groupPubKey := groupKey.GroupPubKey - groupKeyBytes = groupPubKey.SerializeCompressed() - } + var ( + groupKeyBytes []byte + groupInternalKey *taprpc.KeyDescriptor + groupAnchor string + seedlingMeta *taprpc.AssetMeta + newGroupedAsset bool + ) - var groupAnchor string - if seedling.GroupAnchor != nil { - groupAnchor = *seedling.GroupAnchor - } + if seedling.HasGroupKey() { + groupKey := seedling.GroupInfo.GroupKey + groupKeyBytes = groupKey.GroupPubKey.SerializeCompressed() + } - var seedlingMeta *taprpc.AssetMeta - if seedling.Meta != nil { - seedlingMeta = &taprpc.AssetMeta{ - MetaHash: fn.ByteSlice( - seedling.Meta.MetaHash(), - ), - Data: seedling.Meta.Data, - Type: taprpc.AssetMetaType(seedling.Meta.Type), - } + if seedling.GroupInternalKey != nil { + groupInternalKey = taprpc.MarshalKeyDescriptor( + *seedling.GroupInternalKey, + ) + } + + if seedling.GroupAnchor != nil { + groupAnchor = *seedling.GroupAnchor + } + + if seedling.EnableEmission { + newGroupedAsset = true + } + + if seedling.Meta != nil { + seedlingMeta = &taprpc.AssetMeta{ + MetaHash: fn.ByteSlice( + seedling.Meta.MetaHash(), + ), + Data: seedling.Meta.Data, + Type: taprpc.AssetMetaType(seedling.Meta.Type), } + } - assetVersion, err := taprpc.MarshalAssetVersion( - seedling.AssetVersion, + assetVersion, err := taprpc.MarshalAssetVersion( + seedling.AssetVersion, + ) + if err != nil { + return nil, err + } + + return &mintrpc.PendingAsset{ + AssetType: taprpc.AssetType(seedling.AssetType), + AssetVersion: assetVersion, + Name: seedling.AssetName, + AssetMeta: seedlingMeta, + Amount: seedling.Amount, + ScriptKey: taprpc.MarshalScriptKey(seedling.ScriptKey), + GroupKey: groupKeyBytes, + GroupAnchor: groupAnchor, + GroupInternalKey: groupInternalKey, + GroupTapscriptRoot: seedling.GroupTapscriptRoot, + NewGroupedAsset: newGroupedAsset, + }, nil +} + +// marshalUnsealedSeedling marshals an unsealed seedling into the RPC +// counterpart. +func marshalUnsealedSeedling(ctx context.Context, verbose bool, + seedling *tapgarden.UnsealedSeedling) (*mintrpc.UnsealedAsset, error) { + + var ( + groupVirtualTx *taprpc.GroupVirtualTx + groupReq *taprpc.GroupKeyRequest + err error + ) + + rpcSeedling, err := marshalSeedling(seedling.Seedling) + if err != nil { + return nil, err + } + + if verbose && seedling.PendingAssetGroup != nil { + groupVirtualTx, err = taprpc.MarshalGroupVirtualTx( + &seedling.PendingAssetGroup.GroupVirtualTx, ) if err != nil { return nil, err } - nextSeedling := &mintrpc.PendingAsset{ - AssetType: taprpc.AssetType(seedling.AssetType), - AssetVersion: assetVersion, - Name: seedling.AssetName, - AssetMeta: seedlingMeta, - Amount: seedling.Amount, - GroupKey: groupKeyBytes, - GroupAnchor: groupAnchor, + groupReq, err = taprpc.MarshalGroupKeyRequest( + ctx, &seedling.PendingAssetGroup.GroupKeyRequest, + ) + if err != nil { + return nil, err } + } - if seedling.EnableEmission { - nextSeedling.NewGroupedAsset = true + return &mintrpc.UnsealedAsset{ + Asset: rpcSeedling, + GroupVirtualTx: groupVirtualTx, + GroupKeyRequest: groupReq, + }, nil +} + +// marshalSeedlings marshals the seedlings into the RPC counterpart. +func marshalSeedlings( + seedlings map[string]*tapgarden.Seedling) ([]*mintrpc.PendingAsset, + error) { + + return fn.MapErr(maps.Values(seedlings), marshalSeedling) +} + +// marshalUnsealedSeedlings marshals the unsealed seedlings into the RPC +// counterpart. +func marshalUnsealedSeedlings(ctx context.Context, verbose bool, + seedlings map[string]*tapgarden.UnsealedSeedling) ( + []*mintrpc.UnsealedAsset, error) { + + rpcAssets := make([]*mintrpc.UnsealedAsset, 0, len(seedlings)) + for _, seedling := range seedlings { + nextSeedling, err := marshalUnsealedSeedling( + ctx, verbose, seedling, + ) + if err != nil { + return nil, err } rpcAssets = append(rpcAssets, nextSeedling) @@ -3839,11 +4087,18 @@ func marshalSprouts(sprouts []*asset.Asset, rpcAssets := make([]*mintrpc.PendingAsset, 0, len(sprouts)) for _, sprout := range sprouts { - scriptKey := asset.ToSerialized(sprout.ScriptKey.PubKey) + var ( + groupKeyBytes []byte + groupTapscriptRoot []byte + groupInternalKey *taprpc.KeyDescriptor + assetMeta *taprpc.AssetMeta + ) - var assetMeta *taprpc.AssetMeta if metas != nil { - if m, ok := metas[scriptKey]; ok && m != nil { + serializedScriptKey := asset.ToSerialized( + sprout.ScriptKey.PubKey, + ) + if m, ok := metas[serializedScriptKey]; ok && m != nil { assetMeta = &taprpc.AssetMeta{ MetaHash: fn.ByteSlice(m.MetaHash()), Data: m.Data, @@ -3852,18 +4107,26 @@ func marshalSprouts(sprouts []*asset.Asset, } } - var groupKeyBytes []byte if sprout.GroupKey != nil { - gpk := sprout.GroupKey.GroupPubKey - groupKeyBytes = gpk.SerializeCompressed() + grp := sprout.GroupKey + groupKeyBytes = grp.GroupPubKey.SerializeCompressed() + groupTapscriptRoot = grp.TapscriptRoot + groupInternalKey = taprpc.MarshalKeyDescriptor( + grp.RawKey, + ) } rpcAssets = append(rpcAssets, &mintrpc.PendingAsset{ - AssetType: taprpc.AssetType(sprout.Type), - Name: sprout.Tag, - AssetMeta: assetMeta, - Amount: sprout.Amount, - GroupKey: groupKeyBytes, + AssetType: taprpc.AssetType(sprout.Type), + Name: sprout.Tag, + AssetMeta: assetMeta, + Amount: sprout.Amount, + GroupKey: groupKeyBytes, + GroupInternalKey: groupInternalKey, + GroupTapscriptRoot: groupTapscriptRoot, + ScriptKey: taprpc.MarshalScriptKey( + sprout.ScriptKey, + ), }) } @@ -3902,77 +4165,6 @@ func marshalBatchState(state tapgarden.BatchState) (mintrpc.BatchState, error) { } } -func marshalTapscriptFullTree(tree *taprpc.TapscriptFullTree) ( - *asset.TapscriptTreeNodes, error) { - - rpcLeaves := tree.GetAllLeaves() - leaves := fn.Map(rpcLeaves, func(l *taprpc.TapLeaf) txscript.TapLeaf { - return txscript.NewBaseTapLeaf(l.Script) - }) - - return asset.TapTreeNodesFromLeaves(leaves) -} - -func marshalTapscriptBranch(branch *taprpc.TapBranch) (*asset.TapscriptTreeNodes, - error) { - - branchData := [][]byte{branch.LeftTaphash, branch.RightTaphash} - tapBranch, err := asset.DecodeTapBranchNodes(branchData) - if err != nil { - return nil, err - } - - return fn.Ptr(asset.FromBranch(*tapBranch)), nil -} - -// UnmarshalScriptKey parses the RPC script key into the native counterpart. -func UnmarshalScriptKey(rpcKey *taprpc.ScriptKey) (*asset.ScriptKey, error) { - var ( - scriptKey asset.ScriptKey - err error - ) - - // The script public key is a Taproot key, so 32-byte x-only. - scriptKey.PubKey, err = schnorr.ParsePubKey(rpcKey.PubKey) - if err != nil { - return nil, err - } - - // The key descriptor is optional for script keys that are completely - // independent of the backing wallet. - if rpcKey.KeyDesc != nil { - keyDesc, err := UnmarshalKeyDescriptor(rpcKey.KeyDesc) - if err != nil { - return nil, err - } - scriptKey.TweakedScriptKey = &asset.TweakedScriptKey{ - RawKey: keyDesc, - - // The tweak is optional, if it's empty it means the key - // is derived using BIP-0086. - Tweak: rpcKey.TapTweak, - } - } - - return &scriptKey, nil -} - -// MarshalScriptKey marshals the native script key into the RPC counterpart. -func MarshalScriptKey(scriptKey asset.ScriptKey) *taprpc.ScriptKey { - rpcScriptKey := &taprpc.ScriptKey{ - PubKey: schnorr.SerializePubKey(scriptKey.PubKey), - } - - if scriptKey.TweakedScriptKey != nil { - rpcScriptKey.KeyDesc = marshalKeyDescriptor( - scriptKey.TweakedScriptKey.RawKey, - ) - rpcScriptKey.TapTweak = scriptKey.TweakedScriptKey.Tweak - } - - return rpcScriptKey -} - // parseUserKey parses a user-provided script or group key, which can be in // either the Schnorr or Compressed format. func parseUserKey(scriptKey []byte) (*btcec.PublicKey, error) { @@ -3990,49 +4182,6 @@ func parseUserKey(scriptKey []byte) (*btcec.PublicKey, error) { } } -// marshalKeyDescriptor marshals the native key descriptor into the RPC -// counterpart. -func marshalKeyDescriptor(desc keychain.KeyDescriptor) *taprpc.KeyDescriptor { - return &taprpc.KeyDescriptor{ - RawKeyBytes: desc.PubKey.SerializeCompressed(), - KeyLoc: &taprpc.KeyLocator{ - KeyFamily: int32(desc.KeyLocator.Family), - KeyIndex: int32(desc.KeyLocator.Index), - }, - } -} - -// UnmarshalKeyDescriptor parses the RPC key descriptor into the native -// counterpart. -func UnmarshalKeyDescriptor( - rpcDesc *taprpc.KeyDescriptor) (keychain.KeyDescriptor, error) { - - var ( - desc keychain.KeyDescriptor - err error - ) - - // The public key of a key descriptor is mandatory. It is enough to - // locate the corresponding private key in the backing wallet. But to - // speed things up (and for additional context), the locator should - // still be provided if available. - desc.PubKey, err = btcec.ParsePubKey(rpcDesc.RawKeyBytes) - if err != nil { - return desc, err - } - - if rpcDesc.KeyLoc != nil { - desc.KeyLocator = keychain.KeyLocator{ - Family: keychain.KeyFamily(rpcDesc.KeyLoc.KeyFamily), - Index: uint32(rpcDesc.KeyLoc.KeyIndex), - } - } - - return desc, nil -} - -// FetchAssetMeta allows a caller to fetch the reveal meta data for an asset -// either by the asset ID for that asset, or a meta hash. func (r *rpcServer) FetchAssetMeta(ctx context.Context, req *taprpc.FetchAssetMetaRequest) (*taprpc.AssetMeta, error) { diff --git a/tapdb/asset_minting.go b/tapdb/asset_minting.go index 88b990bdb1..bdfb7f347e 100644 --- a/tapdb/asset_minting.go +++ b/tapdb/asset_minting.go @@ -1271,6 +1271,13 @@ func (a *AssetMintingStore) FetchSeedlingGroups(ctx context.Context, for i := range seedlingGens { genID, err := fetchGenesisID(ctx, q, *seedlingGens[i]) if err != nil { + // Re-map the error about a missing asset + // genesis so it can be better handled in the + // planter. + if errors.Is(err, ErrFetchGenesisID) { + return tapgarden.ErrNoGenesis + } + return err } diff --git a/tapdb/assets_common.go b/tapdb/assets_common.go index 6df7270a9f..3ed05e5c64 100644 --- a/tapdb/assets_common.go +++ b/tapdb/assets_common.go @@ -116,6 +116,10 @@ var ( // ErrTapscriptRootSize is returned when the given tapscript root is not // exactly 32 bytes. ErrTapscriptRootSize = errors.New("tapscript root invalid: wrong size") + + // ErrFetchGenesisAsset is returned when fetching the database ID for an + // asset genesis fails. + ErrFetchGenesisID = errors.New("unable to fetch genesis asset") ) // upsertGenesis imports a new genesis point into the database or returns the @@ -181,7 +185,7 @@ func fetchGenesisID(ctx context.Context, q UpsertAssetStore, PrevOut: genPoint, }) if err != nil { - return 0, fmt.Errorf("unable to fetch genesis asset: %w", err) + return 0, fmt.Errorf("%w: %w", ErrFetchGenesisID, err) } return genAssetID, nil diff --git a/tapdb/assets_store.go b/tapdb/assets_store.go index d24d1ff66c..9ae5e8ec55 100644 --- a/tapdb/assets_store.go +++ b/tapdb/assets_store.go @@ -576,6 +576,11 @@ func (a *AssetStore) dbAssetsToChainAssets(dbAssets []ConfirmedAsset, return nil, err } + var tapscriptRoot []byte + if len(sprout.TapscriptRoot) != 0 { + tapscriptRoot = sprout.TapscriptRoot + } + groupKey = &asset.GroupKey{ RawKey: keychain.KeyDescriptor{ PubKey: rawGroupKey, @@ -588,8 +593,9 @@ func (a *AssetStore) dbAssetsToChainAssets(dbAssets []ConfirmedAsset, ), }, }, - GroupPubKey: *tweakedGroupKey, - Witness: groupWitness, + GroupPubKey: *tweakedGroupKey, + Witness: groupWitness, + TapscriptRoot: tapscriptRoot, } } diff --git a/tapgarden/batch.go b/tapgarden/batch.go index df8b4e7a4e..850d67ada3 100644 --- a/tapgarden/batch.go +++ b/tapgarden/batch.go @@ -76,6 +76,14 @@ type MintingBatch struct { taprootAssetScriptRoot []byte } +// VerboseBatch is a MintingBatch that includes seedlings with their pending +// asset group information. The Seedlings map is empty, and all seedlings are +// stored as UnsealedSeedlings. +type VerboseBatch struct { + *MintingBatch + UnsealedSeedlings map[string]*UnsealedSeedling +} + // Copy creates a deep copy of the batch. func (m *MintingBatch) Copy() *MintingBatch { batchCopy := &MintingBatch{ @@ -217,6 +225,28 @@ func (m *MintingBatch) UpdateTapSibling(sibling *chainhash.Hash) { m.tapSibling = sibling } +// IsFunded checks if the batch already has a funded genesis packet. func (m *MintingBatch) IsFunded() bool { return m.GenesisPacket != nil } + +// HasSeedlings checks if the batch has any seedlings. A batch with no seedlings +// cannot be sealed nor finalized. +func (m *MintingBatch) HasSeedlings() bool { + return len(m.Seedlings) != 0 +} + +// ToMintingBatch creates a new MintingBatch from a VerboseBatch. +func (v *VerboseBatch) ToMintingBatch() *MintingBatch { + newBatch := v.MintingBatch.Copy() + if v.UnsealedSeedlings != nil { + newBatch.Seedlings = make( + map[string]*Seedling, len(v.UnsealedSeedlings), + ) + for k, v := range v.UnsealedSeedlings { + newBatch.Seedlings[k] = v.Seedling + } + } + + return newBatch +} diff --git a/tapgarden/interface.go b/tapgarden/interface.go index e20fce0c51..1859d782af 100644 --- a/tapgarden/interface.go +++ b/tapgarden/interface.go @@ -2,6 +2,7 @@ package tapgarden import ( "context" + "errors" "fmt" "github.com/btcsuite/btcd/btcec/v2" @@ -32,7 +33,7 @@ type Planter interface { // ListBatches lists the set of batches submitted for minting, or the // details of a specific batch. - ListBatches(batchKey *btcec.PublicKey) ([]*MintingBatch, error) + ListBatches(params ListBatchesParams) ([]*VerboseBatch, error) // CancelSeedling attempts to cancel the creation of a new asset // identified by its name. If the seedling has already progressed to a @@ -378,3 +379,8 @@ type KeyRing interface { // and can be derived by it. IsLocalKey(context.Context, keychain.KeyDescriptor) bool } + +var ( + // ErrNoGenesis is returned when fetching an asset genesis fails. + ErrNoGenesis = errors.New("unable to fetch genesis asset") +) diff --git a/tapgarden/planter.go b/tapgarden/planter.go index a441d55f07..76b7dd75be 100644 --- a/tapgarden/planter.go +++ b/tapgarden/planter.go @@ -3,7 +3,9 @@ package tapgarden import ( "bytes" "context" + "errors" "fmt" + "strings" "sync" "time" @@ -125,6 +127,27 @@ type stateParamReq[T, S any] struct { param S } +// ListBatchesParams are the options available to specify which minting batches +// are listed, and how verbose the listing should be. +type ListBatchesParams struct { + BatchKey *btcec.PublicKey + Verbose bool +} + +// PendingAssetGroup is the group key request and virtual TX necessary to +// produce an asset group witness for a seedling. +type PendingAssetGroup struct { + asset.GroupKeyRequest + asset.GroupVirtualTx +} + +// UnsealedSeedling is a previously submitted seedling and its associated +// PendingAssetGroup, which can be used to produce an asset group witness. +type UnsealedSeedling struct { + *Seedling + *PendingAssetGroup +} + // FinalizeParams are the options available to change how a batch is finalized, // and how the genesis TX is constructed. type FinalizeParams struct { @@ -137,20 +160,11 @@ type FinalizeParams struct { type FundParams struct { FeeRate fn.Option[chainfee.SatPerKWeight] SiblingTapTree fn.Option[asset.TapscriptTreeNodes] - // TODO(jhb): follow-up PR: accept a PSBT here -} - -// groupSeal specifies the group witness for a seedling in a funded batch. -type groupSeal struct { - GroupMember asset.ID - GroupWitness []wire.TxWitness } // SealParams change how asset groups in a minting batch are created. type SealParams struct { - GroupWitnesses []groupSeal - // TODO(jhb): follow-up PR: accept a witness for the genesis point here - // to enable script-path spends + GroupWitnesses []asset.PendingGroupWitness } func newStateParamReq[T, S any](req reqType, param S) *stateParamReq[T, S] { @@ -520,8 +534,8 @@ func filterSeedlingsWithGroup( // buildGroupReqs creates group key requests and asset group genesis TXs for // seedlings that are part of a funded batch. -func (c *ChainPlanter) buildGroupReqs(genesisPoint wire.OutPoint, - assetOutputIndex uint32, +func buildGroupReqs(genesisPoint wire.OutPoint, assetOutputIndex uint32, + genBuilder asset.GenesisTxBuilder, groupSeedlings map[string]*Seedling) ([]asset.GroupKeyRequest, []asset.GroupVirtualTx, error) { @@ -606,7 +620,7 @@ func (c *ChainPlanter) buildGroupReqs(genesisPoint wire.OutPoint, } genTx, err := groupReq.BuildGroupVirtualTx( - c.cfg.GenTxBuilder, + genBuilder, ) if err != nil { return nil, nil, err @@ -635,7 +649,7 @@ func (c *ChainPlanter) buildGroupReqs(genesisPoint wire.OutPoint, } genTx, err := groupReq.BuildGroupVirtualTx( - c.cfg.GenTxBuilder, + genBuilder, ) if err != nil { return nil, nil, err @@ -644,11 +658,14 @@ func (c *ChainPlanter) buildGroupReqs(genesisPoint wire.OutPoint, groupReqs = append(groupReqs, *groupReq) genTXs = append(genTXs, *genTx) + newGroupKey := &asset.GroupKey{ + RawKey: *seedling.GroupInternalKey, + TapscriptRoot: seedling.GroupTapscriptRoot, + } + newGroups[seedlingName] = &asset.AssetGroup{ - Genesis: &assetGen, - GroupKey: &asset.GroupKey{ - RawKey: *seedling.GroupInternalKey, - }, + Genesis: &assetGen, + GroupKey: newGroupKey, } } } @@ -678,18 +695,130 @@ func freezeMintingBatch(ctx context.Context, batchStore MintingStore, // ListBatches returns the single batch specified by the batch key, or the set // of batches not yet finalized on disk. func listBatches(ctx context.Context, batchStore MintingStore, - batchKey *btcec.PublicKey) ([]*MintingBatch, error) { + genBuilder asset.GenesisTxBuilder, + params ListBatchesParams) ([]*VerboseBatch, error) { - if batchKey == nil { - return batchStore.FetchAllBatches(ctx) - } + var ( + batches []*MintingBatch + err error + ) - batch, err := batchStore.FetchMintingBatch(ctx, batchKey) + switch { + case params.BatchKey == nil: + batches, err = batchStore.FetchAllBatches(ctx) + default: + var batch *MintingBatch + batch, err = batchStore.FetchMintingBatch(ctx, params.BatchKey) + batches = []*MintingBatch{batch} + } if err != nil { return nil, err } - return []*MintingBatch{batch}, nil + verboseBatches := fn.Map(batches, func(b *MintingBatch) *VerboseBatch { + return &VerboseBatch{ + MintingBatch: b, + UnsealedSeedlings: nil, + } + }) + + // Return the batches without any extra asset group info. + if !params.Verbose { + return verboseBatches, nil + } + + for _, batch := range verboseBatches { + currentBatch := batch + + // The batch must be pending, funded, and have seedlings for us + // to show pending asset group information. + switch { + case currentBatch.State() != BatchStatePending: + continue + case !currentBatch.IsFunded(): + continue + case len(currentBatch.Seedlings) == 0: + continue + 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 + } + + // Before we can build the group key requests for each seedling, + // we must fetch the genesis point and anchor index for the + // batch. + anchorOutputIndex := uint32(0) + if currentBatch.GenesisPacket.ChangeOutputIndex == 0 { + anchorOutputIndex = 1 + } + + 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 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, + } + } + + // 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) + } + + seedling.PendingAssetGroup = &PendingAssetGroup{ + GroupKeyRequest: groupReqs[i], + GroupVirtualTx: genTXs[i], + } + } + + // Clear the original batch seedlings so each asset is only + // represented once. + currentBatch.Seedlings = nil + } + + return verboseBatches, nil } // canCancelBatch returns a batch key if the planter is in a state where a batch @@ -859,16 +988,18 @@ func (c *ChainPlanter) gardener() { req.Resolve(len(c.caretakers)) case reqTypeListBatches: - batchKey, err := typedParam[*btcec.PublicKey](req) + listBatchesParams, err := + typedParam[ListBatchesParams](req) if err != nil { - req.Error(fmt.Errorf("bad batch key: "+ - "%w", err)) + req.Error(fmt.Errorf("bad list batch "+ + "params: %w", err)) break } ctx, cancel := c.WithCtxQuit() batches, err := listBatches( - ctx, c.cfg.Log, *batchKey, + ctx, c.cfg.Log, c.cfg.GenTxBuilder, + *listBatchesParams, ) cancel() if err != nil { @@ -906,13 +1037,38 @@ func (c *ChainPlanter) gardener() { req.Resolve(c.pendingBatch) - // TODO(jhb): follow-up PR: Implement SealBatch command case reqTypeSealBatch: - req.Error(fmt.Errorf("not yet implemented")) + if c.pendingBatch == nil { + req.Error(fmt.Errorf("no pending " + + "batch")) + break + } + + sealReqParams, err := + typedParam[SealParams](req) + if err != nil { + req.Error(fmt.Errorf("bad seal "+ + "params: %w", err)) + break + } + + ctx, cancel := c.WithCtxQuit() + sealedBatch, err := c.sealBatch( + ctx, *sealReqParams, + ) + cancel() + if err != nil { + req.Error(fmt.Errorf("unable to seal "+ + "minting batch: %w", err)) + break + } + + req.Resolve(sealedBatch) case reqTypeFinalizeBatch: if c.pendingBatch == nil { - req.Error(fmt.Errorf("no pending batch")) + req.Error(fmt.Errorf("no pending " + + "batch")) break } @@ -1098,19 +1254,17 @@ func (c *ChainPlanter) fundBatch(ctx context.Context, params FundParams) error { // possible if they are not provided. After all asset group witnesses have been // validated, they are saved to disk to be used by the caretaker during batch // finalization. -func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error { +func (c *ChainPlanter) sealBatch(ctx context.Context, + params SealParams) (*MintingBatch, error) { + // A batch should exist with 1+ seedlings and be funded before being // sealed. - if c.pendingBatch == nil { - return fmt.Errorf("no pending batch") - } - - if len(c.pendingBatch.Seedlings) == 0 { - return fmt.Errorf("no seedlings in batch") + if !c.pendingBatch.HasSeedlings() { + return nil, fmt.Errorf("no seedlings in batch") } if !c.pendingBatch.IsFunded() { - return fmt.Errorf("batch is not funded") + return nil, fmt.Errorf("batch is not funded") } // Filter the batch seedlings to only consider those that will become @@ -1118,7 +1272,7 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error { // to seal and no action is needed. groupSeedlings, _ := filterSeedlingsWithGroup(c.pendingBatch.Seedlings) if len(groupSeedlings) == 0 { - return nil + return c.pendingBatch, nil } // Before we can build the group key requests for each seedling, we must @@ -1132,29 +1286,98 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error { c.pendingBatch.GenesisPacket.Pkt.UnsignedTx, ) + // Check if the batch is already sealed by picking a random grouped + // seedling and trying to fetch the full asset group. + var singleSeedling []*Seedling + for _, seedling := range groupSeedlings { + singleSeedling = append(singleSeedling, seedling) + break + } + + // If the batch was previously sealed, each grouped seedling will have + // its asset genesis already stored on disk. + existingGroups, err := c.cfg.Log.FetchSeedlingGroups( + ctx, genesisPoint, anchorOutputIndex, singleSeedling, + ) + + switch { + case len(existingGroups) != 0: + return nil, fmt.Errorf("batch is already sealed") + case err != nil: + // The only expected error is for a missing asset genesis. + if !errors.Is(err, ErrNoGenesis) { + return nil, err + } + } + // 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 := c.buildGroupReqs( - genesisPoint, anchorOutputIndex, groupSeedlings, + groupReqs, genTXs, err := buildGroupReqs( + genesisPoint, anchorOutputIndex, c.cfg.GenTxBuilder, + groupSeedlings, ) if err != nil { - return fmt.Errorf("unable to build group requests: %w", err) + 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") + } + + // Each provided group witness must have a corresponding seedling in the + // current batch. + seedlingAssetIDs := fn.NewSet(fn.Map( + groupReqs, func(req asset.GroupKeyRequest) asset.ID { + return req.NewAsset.ID() + })..., + ) + + externalWitnesses := make(map[asset.ID]asset.PendingGroupWitness) + for _, wit := range params.GroupWitnesses { + if !seedlingAssetIDs.Contains(wit.GenID) { + return nil, fmt.Errorf("witness has no matching "+ + "seedling: %v", wit) + } + externalWitnesses[wit.GenID] = wit } assetGroups := make([]*asset.AssetGroup, 0, len(groupReqs)) for i := 0; i < len(groupReqs); i++ { - // Derive the asset group witness. - groupKey, err := asset.DeriveGroupKey( - c.cfg.GenSigner, genTXs[i], groupReqs[i], nil, + var ( + genTX = genTXs[i] + groupReq = groupReqs[i] + protoAsset = groupReq.NewAsset + groupKey *asset.GroupKey + err error ) - if err != nil { - return err - } + // Check for an externally-provided asset group witness before + // trying to derive a witness. + reqAssetID := protoAsset.ID() + groupWitness, ok := externalWitnesses[reqAssetID] + switch { + case ok: + // Set the provided witness; it will be validated below. + groupKey = &asset.GroupKey{ + RawKey: groupReq.RawKey, + GroupPubKey: genTX.TweakedKey, + TapscriptRoot: groupReq.TapscriptRoot, + Witness: groupWitness.Witness, + } + + default: + // Derive the asset group witness. + groupKey, err = asset.DeriveGroupKey( + c.cfg.GenSigner, genTX, groupReq, nil, + ) + if err != nil { + return nil, err + } + } // Recreate the asset with the populated group key and validate // the asset group witness. - protoAsset := groupReqs[i].NewAsset groupedAsset, err := asset.New( protoAsset.Genesis, protoAsset.Amount, protoAsset.LockTime, protoAsset.RelativeLockTime, @@ -1162,17 +1385,17 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error { asset.WithAssetVersion(protoAsset.Version), ) if err != nil { - return err + return nil, err } err = c.cfg.TxValidator.Execute(groupedAsset, nil, nil) if err != nil { - return fmt.Errorf("unable to verify asset "+ - "group witness: %w", err) + return nil, fmt.Errorf("unable to verify asset group"+ + "witness: %s, %w", reqAssetID.String(), err) } newGroup := &asset.AssetGroup{ - Genesis: &groupReqs[i].NewAsset.Genesis, + Genesis: &protoAsset.Genesis, GroupKey: groupKey, } @@ -1183,10 +1406,18 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error { // to disk. err = c.cfg.Log.AddSeedlingGroups(ctx, genesisPoint, assetGroups) if err != nil { - return fmt.Errorf("unable to write seedling groups: %w", err) + return nil, fmt.Errorf("unable to write seedling groups: "+ + "%w", err) } - return nil + // Populate the group info for each seedling, to display to the caller. + batchWithGroupInfo := c.pendingBatch.Copy() + for _, group := range assetGroups { + assetName := group.Genesis.Tag + batchWithGroupInfo.Seedlings[assetName].GroupInfo = group + } + + return batchWithGroupInfo, nil } // finalizeBatch creates a new caretaker for the batch and starts it. @@ -1242,10 +1473,15 @@ func (c *ChainPlanter) finalizeBatch(params FinalizeParams) (*BatchCaretaker, } } - // TODO(jhb): follow-up PR: detect batches that were already sealed - err = c.sealBatch(ctx, SealParams{}) + // If the batch needs to be sealed, we'll use the default behavior for + // generating asset group witnesses. Any custom behavior requires + // calling SealBatch() explicitly, before batch finalization. + _, err = c.sealBatch(ctx, SealParams{}) if err != nil { - return nil, err + errMsg := err.Error() + if !strings.Contains(errMsg, "batch is already sealed") { + return nil, err + } } // Now that the batch has been frozen on disk, we can update the batch @@ -1286,10 +1522,10 @@ func (c *ChainPlanter) NumActiveBatches() (int, error) { // ListBatches returns the single batch specified by the batch key, or the set // of batches not yet finalized on disk. -func (c *ChainPlanter) ListBatches(batchKey *btcec.PublicKey) ([]*MintingBatch, +func (c *ChainPlanter) ListBatches(params ListBatchesParams) ([]*VerboseBatch, error) { - req := newStateParamReq[[]*MintingBatch](reqTypeListBatches, batchKey) + req := newStateParamReq[[]*VerboseBatch](reqTypeListBatches, 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 83f2baeaca..3bb98ae172 100644 --- a/tapgarden/planter_test.go +++ b/tapgarden/planter_test.go @@ -33,10 +33,12 @@ import ( "github.com/lightninglabs/taproot-assets/tapscript" "github.com/lightninglabs/taproot-assets/tapsend" "github.com/lightningnetwork/lnd/build" + "github.com/lightningnetwork/lnd/input" "github.com/lightningnetwork/lnd/keychain" "github.com/lightningnetwork/lnd/lntest/wait" "github.com/lightningnetwork/lnd/lnwallet/chainfee" "github.com/stretchr/testify/require" + "golang.org/x/exp/maps" ) // Default to a large interval so the planter never actually ticks and only @@ -429,16 +431,21 @@ func (t *mintingTestHarness) finalizeBatchAssertFrozen( // Before we tick the batch, we record all existing batches, so we can // make sure a new one was created. - existingBatches, err := t.planter.ListBatches(nil) + existingBatches, err := t.planter.ListBatches( + tapgarden.ListBatchesParams{}, + ) require.NoError(t, err) // We only want to know if a new batch gets to the frozen state. So the // list of existing batches should only contain the already frozen. - existingBatches = fn.Filter( - existingBatches, func(batch *tapgarden.MintingBatch) bool { - return batch.State() == tapgarden.BatchStateFrozen - }, - ) + var existingFrozenBatches []*tapgarden.MintingBatch + fn.ForEach(existingBatches, func(batch *tapgarden.VerboseBatch) { + if batch.State() == tapgarden.BatchStateFrozen { + existingFrozenBatches = append( + existingFrozenBatches, batch.ToMintingBatch(), + ) + } + }) var ( wg sync.WaitGroup @@ -453,7 +460,7 @@ func (t *mintingTestHarness) finalizeBatchAssertFrozen( } // Check that the batch was frozen and then funded. - newBatch := t.assertNewBatchFrozen(existingBatches) + newBatch := t.assertNewBatchFrozen(existingFrozenBatches) _ = t.assertGenesisTxFunded(nil) // Fetch the batch again after funding. @@ -698,7 +705,7 @@ func (t *mintingTestHarness) assertLastBatchState(numBatches int, batchState tapgarden.BatchState) { t.Helper() - batches, err := t.planter.ListBatches(nil) + batches, err := t.planter.ListBatches(tapgarden.ListBatchesParams{}) require.NoError(t, err) require.Len(t, batches, numBatches) @@ -969,18 +976,24 @@ func (t *mintingTestHarness) queueInitialBatch( // Before we tick the batch, we record all existing batches, so we can // make sure a new one was created. - existingBatches, err := t.planter.ListBatches(nil) + existingBatches, err := t.planter.ListBatches( + tapgarden.ListBatchesParams{}, + ) require.NoError(t, err) // We only want to know if a new batch gets to the frozen state. So the // list of existing batches should only contain the already frozen. - existingBatches = fn.Filter( - existingBatches, func(batch *tapgarden.MintingBatch) bool { - return batch.State() == tapgarden.BatchStatePending - }, - ) - require.Len(t, existingBatches, 1) - batchKey := existingBatches[0].BatchKey.PubKey + var pendingBatches []*tapgarden.MintingBatch + fn.ForEach(existingBatches, func(batch *tapgarden.VerboseBatch) { + if batch.State() == tapgarden.BatchStatePending { + pendingBatches = append( + pendingBatches, batch.ToMintingBatch(), + ) + } + }) + + require.Len(t, pendingBatches, 1) + batchKey := pendingBatches[0].BatchKey.PubKey t.assertSeedlingsExist(seedlings, batchKey) @@ -1534,7 +1547,7 @@ func testFinalizeWithTapscriptTree(t *mintingTestHarness) { t.assertMintOutputKey(batchWithSibling, siblingHash) } -func testFundBeforeFinalize(t *mintingTestHarness) { +func testFundSealBeforeFinalize(t *mintingTestHarness) { // First, create a new chain planter instance using the supplied test // harness. t.refreshChainPlanter() @@ -1571,8 +1584,13 @@ func testFundBeforeFinalize(t *mintingTestHarness) { // We'll use the default test tapscript tree for both the batch // tapscript sibling and a tapscript root for one asset group. - defaultTapBranch := test.BuildTapscriptTreeNoReveal( - t.T, groupInternalKeyDesc.PubKey, + hashLockLeaf := test.ScriptHashLock( + t.T, bytes.Clone(test.DefaultHashLockWitness), + ) + sigLeaf := test.ScriptSchnorrSig(t.T, groupInternalKeyDesc.PubKey) + tapTree := txscript.AssembleTaprootScriptTree(hashLockLeaf, sigLeaf) + defaultTapBranch := txscript.NewTapBranch( + tapTree.RootNode.Left(), tapTree.RootNode.Right(), ) defaultTapTree := asset.TapTreeNodesFromBranch(defaultTapBranch) defaultPreimage := commitment.NewPreimageFromBranch(defaultTapBranch) @@ -1593,6 +1611,7 @@ func testFundBeforeFinalize(t *mintingTestHarness) { // Set a group tapscript root for the third seedling. seedlings[2].EnableEmission = true seedlings[2].GroupTapscriptRoot = defaultTapHash[:] + secondSeedling := seedlings[2].AssetName // Set the fourth seedling to be a member of the second seedling's // asset group. @@ -1603,6 +1622,7 @@ func testFundBeforeFinalize(t *mintingTestHarness) { // Set the final seedling to be ungrouped. seedlings[4].EnableEmission = false + groupCount := 3 // Fund a batch with a tapscript sibling and a manual feerate. This // should create a new batch. @@ -1619,16 +1639,18 @@ func testFundBeforeFinalize(t *mintingTestHarness) { // After funding, the planter should have persisted the batch. The new // batch should be funded but have no seedlings. - fundedBatches, err := t.planter.ListBatches(nil) + fundedBatches, err := t.planter.ListBatches( + tapgarden.ListBatchesParams{}, + ) require.NoError(t, err) require.Len(t, fundedBatches, 1) - fundedBatch := fundedBatches[0] - require.Len(t, fundedBatch.Seedlings, 0) - require.NotNil(t, fundedBatch.GenesisPacket) - t.assertBatchGenesisTx(fundedBatch.GenesisPacket) - require.Equal(t, defaultTapHash[:], fundedBatch.TapSibling()) - require.True(t, fundedBatch.State() == tapgarden.BatchStatePending) + fundedEmptyBatch := fundedBatches[0] + require.Len(t, fundedEmptyBatch.Seedlings, 0) + require.NotNil(t, fundedEmptyBatch.GenesisPacket) + t.assertBatchGenesisTx(fundedEmptyBatch.GenesisPacket) + require.Equal(t, defaultTapHash[:], fundedEmptyBatch.TapSibling()) + require.True(t, fundedEmptyBatch.State() == tapgarden.BatchStatePending) // Trying to fund a batch again should fail, as there is a pending batch // that is already funded. @@ -1657,6 +1679,88 @@ func testFundBeforeFinalize(t *mintingTestHarness) { t.assertPendingBatchExists(numSeedlings) t.assertSeedlingsExist(seedlings, nil) + verboseBatches, err := t.planter.ListBatches( + tapgarden.ListBatchesParams{ + Verbose: true, + }, + ) + require.NoError(t, err) + require.Len(t, verboseBatches, 1) + + fundedBatch := verboseBatches[0] + + // Assert that ListBatches showed the correct number of asset groups. + observedGroupCount := 0 + for _, seedling := range maps.Values(fundedBatch.UnsealedSeedlings) { + if seedling.PendingAssetGroup != nil { + observedGroupCount++ + } + } + + require.Equal(t, groupCount, observedGroupCount) + + // Let's use the hash lock to authorize group membership for the second + // seedling. First we need the seedling asset ID and group internal key. + seedlingWithGroupTapscriptRoot := fundedBatch. + UnsealedSeedlings[secondSeedling] + seedlingAssetID := seedlingWithGroupTapscriptRoot.NewAsset.ID() + derivedInternalKey := seedlingWithGroupTapscriptRoot.GroupInternalKey + + // Now we can build the control block for using the hash lock script. + // The control block is built with the singly-tweaked group key, or the + // group internal key tweaked with the seedling asset ID. + groupSinglyTweakedKey := input.TweakPubKeyWithTweak( + derivedInternalKey.PubKey, seedlingAssetID[:], + ) + hashLockTapHash := hashLockLeaf.TapHash() + hashLockTapscriptProof := tapTree. + LeafMerkleProofs[tapTree.LeafProofIndex[hashLockTapHash]] + hashLockTapScript := input.TapscriptPartialReveal( + groupSinglyTweakedKey, hashLockLeaf, + hashLockTapscriptProof.InclusionProof, + ) + hashLockControlBlock, err := hashLockTapScript.ControlBlock.ToBytes() + require.NoError(t, err) + + // With the control block, we can build the full group witness for the + // seedling. + hashLockWitness := wire.TxWitness{ + test.DefaultHashLockWitness, hashLockLeaf.Script, + hashLockControlBlock, + } + seedlingWitness := asset.PendingGroupWitness{ + GenID: seedlingAssetID, + Witness: hashLockWitness, + } + + sealedBatch, err := t.planter.SealBatch(tapgarden.SealParams{ + GroupWitnesses: []asset.PendingGroupWitness{seedlingWitness}, + }) + require.NoError(t, err) + + // After batch sealing, we should have 3 asset groups, and the second + // seedling should have the hash lock witness set. + sealedGroupCount := 0 + for _, seedling := range sealedBatch.Seedlings { + if seedling.GroupInfo != nil { + sealedGroupCount++ + } + } + require.Equal(t, groupCount, sealedGroupCount) + + sealedSeedling := sealedBatch.Seedlings[secondSeedling] + groupWithHashLock := sealedSeedling.GroupInfo + require.Equal( + t, defaultTapHash[:], groupWithHashLock.GroupKey.TapscriptRoot, + ) + require.Equal(t, hashLockWitness, groupWithHashLock.GroupKey.Witness) + + // Trying to seal the batch again should fail. + _, err = t.planter.SealBatch(tapgarden.SealParams{ + GroupWitnesses: []asset.PendingGroupWitness{seedlingWitness}, + }) + require.ErrorContains(t, err, "batch is already sealed") + // Finally, finalize the batch and check that the resulting assets match // the seedlings. t.finalizeBatch(&wg, finalizeRespChan, nil) @@ -1705,8 +1809,8 @@ var testCases = []mintingStoreTestCase{ testFunc: testFinalizeWithTapscriptTree, }, { - name: "fund_before_finalize", - testFunc: testFundBeforeFinalize, + name: "fund_seal_before_finalize", + testFunc: testFundSealBeforeFinalize, }, } diff --git a/taprpc/marshal.go b/taprpc/marshal.go index 3da7e3a89c..28988e6106 100644 --- a/taprpc/marshal.go +++ b/taprpc/marshal.go @@ -1,10 +1,19 @@ package taprpc import ( + "bytes" "context" + "crypto/sha256" "fmt" + "github.com/btcsuite/btcd/blockchain" + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/fn" "github.com/lightningnetwork/lnd/keychain" ) @@ -16,6 +25,102 @@ type KeyLookup interface { IsLocalKey(ctx context.Context, desc keychain.KeyDescriptor) bool } +// marshalKeyDescriptor marshals the native key descriptor into the RPC +// counterpart. +func MarshalKeyDescriptor(desc keychain.KeyDescriptor) *KeyDescriptor { + var rawKeyBytes []byte + if desc.PubKey != nil { + rawKeyBytes = desc.PubKey.SerializeCompressed() + } + + return &KeyDescriptor{ + RawKeyBytes: rawKeyBytes, + KeyLoc: &KeyLocator{ + KeyFamily: int32(desc.KeyLocator.Family), + KeyIndex: int32(desc.KeyLocator.Index), + }, + } +} + +// UnmarshalKeyDescriptor parses the RPC key descriptor into the native +// counterpart. +func UnmarshalKeyDescriptor(rpcDesc *KeyDescriptor) (keychain.KeyDescriptor, + error) { + + var ( + desc keychain.KeyDescriptor + err error + ) + + // The public key of a key descriptor is mandatory. It is enough to + // locate the corresponding private key in the backing wallet. But to + // speed things up (and for additional context), the locator should + // still be provided if available. + desc.PubKey, err = btcec.ParsePubKey(rpcDesc.RawKeyBytes) + if err != nil { + return desc, err + } + + if rpcDesc.KeyLoc != nil { + desc.KeyLocator = keychain.KeyLocator{ + Family: keychain.KeyFamily(rpcDesc.KeyLoc.KeyFamily), + Index: uint32(rpcDesc.KeyLoc.KeyIndex), + } + } + + return desc, nil +} + +// FetchAssetMeta allows a caller to fetch the reveal meta data for an asset +// either by the asset ID for that asset, or a meta hash. +// UnmarshalScriptKey parses the RPC script key into the native counterpart. +func UnmarshalScriptKey(rpcKey *ScriptKey) (*asset.ScriptKey, error) { + var ( + scriptKey asset.ScriptKey + err error + ) + + // The script public key is a Taproot key, so 32-byte x-only. + scriptKey.PubKey, err = schnorr.ParsePubKey(rpcKey.PubKey) + if err != nil { + return nil, err + } + + // The key descriptor is optional for script keys that are completely + // independent of the backing wallet. + if rpcKey.KeyDesc != nil { + keyDesc, err := UnmarshalKeyDescriptor(rpcKey.KeyDesc) + if err != nil { + return nil, err + } + scriptKey.TweakedScriptKey = &asset.TweakedScriptKey{ + RawKey: keyDesc, + + // The tweak is optional, if it's empty it means the key + // is derived using BIP-0086. + Tweak: rpcKey.TapTweak, + } + } + + return &scriptKey, nil +} + +// MarshalScriptKey marshals the native script key into the RPC counterpart. +func MarshalScriptKey(scriptKey asset.ScriptKey) *ScriptKey { + rpcScriptKey := &ScriptKey{ + PubKey: schnorr.SerializePubKey(scriptKey.PubKey), + } + + if scriptKey.TweakedScriptKey != nil { + rpcScriptKey.KeyDesc = MarshalKeyDescriptor( + scriptKey.TweakedScriptKey.RawKey, + ) + rpcScriptKey.TapTweak = scriptKey.TweakedScriptKey.Tweak + } + + return rpcScriptKey +} + // UnmarshalAssetVersion parses an asset version from the RPC variant. func UnmarshalAssetVersion(version AssetVersion) (asset.Version, error) { // For now we'll only support two asset versions. The ones in the @@ -50,11 +155,258 @@ func MarshalAssetVersion(version asset.Version) (AssetVersion, error) { } } +// MarshalGenesisInfo marshals the native asset genesis into the RPC +// counterpart. +func MarshalGenesisInfo(gen *asset.Genesis, assetType asset.Type) *GenesisInfo { + return &GenesisInfo{ + GenesisPoint: gen.FirstPrevOut.String(), + AssetType: AssetType(assetType), + Name: gen.Tag, + MetaHash: gen.MetaHash[:], + AssetId: fn.ByteSlice(gen.ID()), + OutputIndex: gen.OutputIndex, + } +} + +// UnmarshalGenesisInfo parses an asset Genesis from the RPC variant. +func UnmarshalGenesisInfo(rpcGen *GenesisInfo) (*asset.Genesis, error) { + firstPrevOut, err := wire.NewOutPointFromString(rpcGen.GenesisPoint) + if err != nil { + return nil, err + } + + if len(rpcGen.MetaHash) != sha256.Size { + return nil, fmt.Errorf("meta hash must be %d bytes", + sha256.Size) + } + + return &asset.Genesis{ + FirstPrevOut: *firstPrevOut, + Tag: rpcGen.Name, + MetaHash: fn.ToArray[[32]byte](rpcGen.MetaHash), + OutputIndex: rpcGen.OutputIndex, + Type: asset.Type(rpcGen.AssetType), + }, nil +} + +// UnmarshalTapscriptFullTree parses a Tapscript tree from the RPC variant. +func UnmarshalTapscriptFullTree(tree *TapscriptFullTree) ( + *asset.TapscriptTreeNodes, error) { + + rpcLeaves := tree.GetAllLeaves() + leaves := make([]txscript.TapLeaf, len(rpcLeaves)) + + // Check that none of the leaves are a Taproot Asset Commitment. + for i, leaf := range rpcLeaves { + if commitment.IsTaprootAssetCommitmentScript(leaf.Script) { + return nil, fmt.Errorf("tapscript leaf is a Taproot " + + "Asset Commitment") + } + + leaves[i] = txscript.NewBaseTapLeaf(leaf.Script) + } + + tapTreeNodes, err := asset.TapTreeNodesFromLeaves(leaves) + if err != nil { + return nil, fmt.Errorf("invalid tapscript tree: %w", err) + } + + return tapTreeNodes, nil +} + +// UnmarshalTapscriptBranch parses a Tapscript branch from the RPC variant. +func UnmarshalTapscriptBranch(branch *TapBranch) (*asset.TapscriptTreeNodes, + error) { + + branchData := [][]byte{branch.LeftTaphash, branch.RightTaphash} + tapBranch, err := asset.DecodeTapBranchNodes(branchData) + if err != nil { + return nil, fmt.Errorf("invalid tapscript branch: %w", err) + } + + return fn.Ptr(asset.FromBranch(*tapBranch)), nil +} + +// UnmarshalTapscriptSibling parses a Tapscript sibling from the RPC variant. +func UnmarshalTapscriptSibling(rpcTree *TapscriptFullTree, + rpcBranch *TapBranch) (fn.Option[asset.TapscriptTreeNodes], error) { + + var ( + tapSibling *asset.TapscriptTreeNodes + err error + ) + switch { + case rpcTree != nil && rpcBranch != nil: + err = fmt.Errorf("cannot specify both tapscript tree and " + + "tapscript tree branches") + + case rpcTree != nil: + tapSibling, err = UnmarshalTapscriptFullTree(rpcTree) + + case rpcBranch != nil: + tapSibling, err = UnmarshalTapscriptBranch(rpcBranch) + } + + if err != nil { + return fn.None[asset.TapscriptTreeNodes](), err + } + + return fn.MaybeSome(tapSibling), nil +} + +// UnmarshalGroupKeyRequest parses a group key request from the RPC variant. +func UnmarshalGroupKeyRequest(req *GroupKeyRequest) (*asset.GroupKeyRequest, + error) { + + rawKey, err := UnmarshalKeyDescriptor(req.RawKey) + if err != nil { + return nil, err + } + + anchorGen, err := UnmarshalGenesisInfo(req.AnchorGenesis) + if err != nil { + return nil, err + } + + if len(req.TapscriptRoot) != 0 && + len(req.TapscriptRoot) != sha256.Size { + + return nil, fmt.Errorf("tapscript root must be %d bytes", + sha256.Size) + } + + var newAsset asset.Asset + err = newAsset.Decode(bytes.NewReader(req.NewAsset)) + if err != nil { + return nil, err + } + + return &asset.GroupKeyRequest{ + RawKey: rawKey, + AnchorGen: *anchorGen, + TapscriptRoot: req.TapscriptRoot, + NewAsset: &newAsset, + }, nil +} + +// MarshalGroupKeyRequest marshals the native group key request into the RPC +// counterpart. +func MarshalGroupKeyRequest(ctx context.Context, + req *asset.GroupKeyRequest) (*GroupKeyRequest, error) { + + err := req.Validate() + if err != nil { + return nil, err + } + + var assetBuf bytes.Buffer + err = req.NewAsset.Encode(&assetBuf) + if err != nil { + return nil, err + } + + return &GroupKeyRequest{ + RawKey: MarshalKeyDescriptor(req.RawKey), + AnchorGenesis: MarshalGenesisInfo( + &req.AnchorGen, req.NewAsset.Type, + ), + TapscriptRoot: req.TapscriptRoot, + NewAsset: assetBuf.Bytes(), + }, nil +} + +// MarshalGroupVirtualTx marshals the native asset group virtual transaction +// into the RPC counterpart. +func MarshalGroupVirtualTx(genTx *asset.GroupVirtualTx) (*GroupVirtualTx, + error) { + + var groupTxBuf bytes.Buffer + err := genTx.Tx.Serialize(&groupTxBuf) + if err != nil { + return nil, err + } + + rpcPrevOut := TxOut{ + Value: genTx.PrevOut.Value, + PkScript: genTx.PrevOut.PkScript, + } + + return &GroupVirtualTx{ + Transaction: groupTxBuf.Bytes(), + PrevOut: &rpcPrevOut, + GenesisId: fn.ByteSlice(genTx.GenID), + TweakedKey: genTx.TweakedKey.SerializeCompressed(), + }, nil +} + +// UnmarshalGroupVirtualTx parses a group virtual transaction from the RPC +// variant. +func UnmarshalGroupVirtualTx(genTx *GroupVirtualTx) (*asset.GroupVirtualTx, + error) { + + var virtualTx wire.MsgTx + err := virtualTx.Deserialize(bytes.NewReader(genTx.Transaction)) + if err != nil { + return nil, err + } + + if genTx.PrevOut == nil { + return nil, fmt.Errorf("prevout cannot be empty") + } + + prevOut := wire.TxOut{ + Value: genTx.PrevOut.Value, + PkScript: genTx.PrevOut.PkScript, + } + if len(genTx.GenesisId) != sha256.Size { + return nil, fmt.Errorf("genesis id must be %d bytes", + sha256.Size) + } + + tweakedKey, err := btcec.ParsePubKey(genTx.TweakedKey) + if err != nil { + return nil, err + } + + return &asset.GroupVirtualTx{ + Tx: virtualTx, + PrevOut: prevOut, + GenID: asset.ID(genTx.GenesisId), + TweakedKey: *tweakedKey, + }, nil +} + +// UnmarshalGroupWitness parses an asset group witness from the RPC variant. +func UnmarshalGroupWitness(wit *GroupWitness) (*asset.PendingGroupWitness, + error) { + + if len(wit.GenesisId) != sha256.Size { + return nil, fmt.Errorf("invalid genesis id length: "+ + "%d, %x", len(wit.GenesisId), wit.GenesisId) + } + + // Assert that a given witness stack does not exceed the limit used by + // the VM. + witSize := 0 + for _, witItem := range wit.Witness { + witSize += len(witItem) + } + + if witSize > blockchain.MaxBlockWeight { + return nil, fmt.Errorf("asset group witness too large: %d", + witSize) + } + + return &asset.PendingGroupWitness{ + GenID: asset.ID(wit.GenesisId), + Witness: wit.Witness, + }, nil +} + // MarshalAsset converts an asset to its rpc representation. func MarshalAsset(ctx context.Context, a *asset.Asset, isSpent, withWitness bool, keyRing KeyLookup) (*Asset, error) { - assetID := a.Genesis.ID() scriptKeyIsLocal := false if a.ScriptKey.TweakedScriptKey != nil && keyRing != nil { scriptKeyIsLocal = keyRing.IsLocalKey( @@ -68,15 +420,8 @@ func MarshalAsset(ctx context.Context, a *asset.Asset, } rpcAsset := &Asset{ - Version: assetVersion, - AssetGenesis: &GenesisInfo{ - GenesisPoint: a.Genesis.FirstPrevOut.String(), - AssetType: AssetType(a.Type), - Name: a.Genesis.Tag, - MetaHash: a.Genesis.MetaHash[:], - AssetId: assetID[:], - OutputIndex: a.Genesis.OutputIndex, - }, + Version: assetVersion, + AssetGenesis: MarshalGenesisInfo(&a.Genesis, a.Type), Amount: a.Amount, LockTime: int32(a.LockTime), RelativeLockTime: int32(a.RelativeLockTime), @@ -89,9 +434,10 @@ func MarshalAsset(ctx context.Context, a *asset.Asset, if a.GroupKey != nil { var ( - rawKey []byte - groupWitness []byte - err error + rawKey []byte + groupWitness []byte + tapscriptRoot []byte + err error ) if a.GroupKey.RawKey.PubKey != nil { @@ -105,10 +451,15 @@ func MarshalAsset(ctx context.Context, a *asset.Asset, return nil, err } } + if len(a.GroupKey.TapscriptRoot) != 0 { + tapscriptRoot = a.GroupKey.TapscriptRoot[:] + } rpcAsset.AssetGroup = &AssetGroup{ - RawGroupKey: rawKey, - TweakedGroupKey: a.GroupKey.GroupPubKey.SerializeCompressed(), - AssetWitness: groupWitness, + RawGroupKey: rawKey, + TweakedGroupKey: a.GroupKey.GroupPubKey. + SerializeCompressed(), + AssetWitness: groupWitness, + TapscriptRoot: tapscriptRoot, } } diff --git a/taprpc/mintrpc/mint.pb.go b/taprpc/mintrpc/mint.pb.go index 123797f8eb..30709ada00 100644 --- a/taprpc/mintrpc/mint.pb.go +++ b/taprpc/mintrpc/mint.pb.go @@ -108,11 +108,21 @@ type PendingAsset struct { // If true, then the asset will be created with a new group key, which allows // for future asset issuance. NewGroupedAsset bool `protobuf:"varint,6,opt,name=new_grouped_asset,json=newGroupedAsset,proto3" json:"new_grouped_asset,omitempty"` - // The specific group key this asset should be minted with. + // The specific existing group key this asset should be minted with. GroupKey []byte `protobuf:"bytes,7,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` // The name of the asset in the batch that will anchor a new asset group. // This asset will be minted with the same group key as the anchor asset. GroupAnchor string `protobuf:"bytes,8,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. + GroupInternalKey *taprpc.KeyDescriptor `protobuf:"bytes,9,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. + GroupTapscriptRoot []byte `protobuf:"bytes,10,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. + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,11,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` } func (x *PendingAsset) Reset() { @@ -203,6 +213,93 @@ func (x *PendingAsset) GetGroupAnchor() string { return "" } +func (x *PendingAsset) GetGroupInternalKey() *taprpc.KeyDescriptor { + if x != nil { + return x.GroupInternalKey + } + return nil +} + +func (x *PendingAsset) GetGroupTapscriptRoot() []byte { + if x != nil { + return x.GroupTapscriptRoot + } + return nil +} + +func (x *PendingAsset) GetScriptKey() *taprpc.ScriptKey { + if x != nil { + return x.ScriptKey + } + return nil +} + +type UnsealedAsset struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The pending asset with an unsealed asset group. + Asset *PendingAsset `protobuf:"bytes,1,opt,name=asset,proto3" json:"asset,omitempty"` + // The group key request for the asset. + 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"` +} + +func (x *UnsealedAsset) Reset() { + *x = UnsealedAsset{} + if protoimpl.UnsafeEnabled { + mi := &file_mintrpc_mint_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UnsealedAsset) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnsealedAsset) ProtoMessage() {} + +func (x *UnsealedAsset) ProtoReflect() protoreflect.Message { + mi := &file_mintrpc_mint_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnsealedAsset.ProtoReflect.Descriptor instead. +func (*UnsealedAsset) Descriptor() ([]byte, []int) { + return file_mintrpc_mint_proto_rawDescGZIP(), []int{1} +} + +func (x *UnsealedAsset) GetAsset() *PendingAsset { + if x != nil { + return x.Asset + } + return nil +} + +func (x *UnsealedAsset) GetGroupKeyRequest() *taprpc.GroupKeyRequest { + if x != nil { + return x.GroupKeyRequest + } + return nil +} + +func (x *UnsealedAsset) GetGroupVirtualTx() *taprpc.GroupVirtualTx { + if x != nil { + return x.GroupVirtualTx + } + return nil +} + type MintAsset struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -226,17 +323,27 @@ type MintAsset struct { // If true, then a group key or group anchor can be set to mint this asset into // an existing asset group. GroupedAsset bool `protobuf:"varint,7,opt,name=grouped_asset,json=groupedAsset,proto3" json:"grouped_asset,omitempty"` - // The specific group key this asset should be minted with. + // The specific existing group key this asset should be minted with. GroupKey []byte `protobuf:"bytes,8,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` // The name of the asset in the batch that will anchor a new asset group. // This asset will be minted with the same group key as the anchor asset. 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. + 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. + 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. + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,12,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` } func (x *MintAsset) Reset() { *x = MintAsset{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[1] + mi := &file_mintrpc_mint_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -249,7 +356,7 @@ func (x *MintAsset) String() string { func (*MintAsset) ProtoMessage() {} func (x *MintAsset) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[1] + mi := &file_mintrpc_mint_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -262,7 +369,7 @@ func (x *MintAsset) ProtoReflect() protoreflect.Message { // Deprecated: Use MintAsset.ProtoReflect.Descriptor instead. func (*MintAsset) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{1} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{2} } func (x *MintAsset) GetAssetVersion() taprpc.AssetVersion { @@ -328,6 +435,27 @@ func (x *MintAsset) GetGroupAnchor() string { return "" } +func (x *MintAsset) GetGroupInternalKey() *taprpc.KeyDescriptor { + if x != nil { + return x.GroupInternalKey + } + return nil +} + +func (x *MintAsset) GetGroupTapscriptRoot() []byte { + if x != nil { + return x.GroupTapscriptRoot + } + return nil +} + +func (x *MintAsset) GetScriptKey() *taprpc.ScriptKey { + if x != nil { + return x.ScriptKey + } + return nil +} + type MintAssetRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -344,7 +472,7 @@ type MintAssetRequest struct { func (x *MintAssetRequest) Reset() { *x = MintAssetRequest{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[2] + mi := &file_mintrpc_mint_proto_msgTypes[3] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -357,7 +485,7 @@ func (x *MintAssetRequest) String() string { func (*MintAssetRequest) ProtoMessage() {} func (x *MintAssetRequest) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[2] + mi := &file_mintrpc_mint_proto_msgTypes[3] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -370,7 +498,7 @@ func (x *MintAssetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintAssetRequest.ProtoReflect.Descriptor instead. func (*MintAssetRequest) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{2} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{3} } func (x *MintAssetRequest) GetAsset() *MintAsset { @@ -399,7 +527,7 @@ type MintAssetResponse struct { func (x *MintAssetResponse) Reset() { *x = MintAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[3] + mi := &file_mintrpc_mint_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -412,7 +540,7 @@ func (x *MintAssetResponse) String() string { func (*MintAssetResponse) ProtoMessage() {} func (x *MintAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[3] + mi := &file_mintrpc_mint_proto_msgTypes[4] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -425,7 +553,7 @@ func (x *MintAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintAssetResponse.ProtoReflect.Descriptor instead. func (*MintAssetResponse) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{3} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{4} } func (x *MintAssetResponse) GetPendingBatch() *MintingBatch { @@ -463,7 +591,7 @@ type MintingBatch struct { func (x *MintingBatch) Reset() { *x = MintingBatch{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[4] + mi := &file_mintrpc_mint_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -476,7 +604,7 @@ func (x *MintingBatch) String() string { func (*MintingBatch) ProtoMessage() {} func (x *MintingBatch) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[4] + mi := &file_mintrpc_mint_proto_msgTypes[5] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -489,7 +617,7 @@ func (x *MintingBatch) ProtoReflect() protoreflect.Message { // Deprecated: Use MintingBatch.ProtoReflect.Descriptor instead. func (*MintingBatch) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{4} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{5} } func (x *MintingBatch) GetBatchKey() []byte { @@ -541,6 +669,326 @@ func (x *MintingBatch) GetBatchPsbt() []byte { return nil } +type VerboseBatch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The minting batch, without any assets. + Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + // The assets that are part of the batch. + UnsealedAssets []*UnsealedAsset `protobuf:"bytes,2,rep,name=unsealed_assets,json=unsealedAssets,proto3" json:"unsealed_assets,omitempty"` +} + +func (x *VerboseBatch) Reset() { + *x = VerboseBatch{} + if protoimpl.UnsafeEnabled { + mi := &file_mintrpc_mint_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VerboseBatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VerboseBatch) ProtoMessage() {} + +func (x *VerboseBatch) ProtoReflect() protoreflect.Message { + mi := &file_mintrpc_mint_proto_msgTypes[6] + 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 VerboseBatch.ProtoReflect.Descriptor instead. +func (*VerboseBatch) Descriptor() ([]byte, []int) { + return file_mintrpc_mint_proto_rawDescGZIP(), []int{6} +} + +func (x *VerboseBatch) GetBatch() *MintingBatch { + if x != nil { + return x.Batch + } + return nil +} + +func (x *VerboseBatch) GetUnsealedAssets() []*UnsealedAsset { + if x != nil { + return x.UnsealedAssets + } + return nil +} + +type FundBatchRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // If true, then the assets currently in the batch won't be returned in the + // response. This is mainly to avoid a lot of data being transmitted and + // possibly printed on the command line in the case of a very large batch. + ShortResponse bool `protobuf:"varint,1,opt,name=short_response,json=shortResponse,proto3" json:"short_response,omitempty"` + // The optional fee rate to use for the minting transaction, in sat/kw. + FeeRate uint32 `protobuf:"varint,2,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` + // The optional tapscript sibling that will be used when deriving the genesis + // output for the batch. This sibling is a tapscript tree, which allows the + // minter to encumber future transfers of assets in the batch with Tapscript. + // + // Types that are assignable to BatchSibling: + // + // *FundBatchRequest_FullTree + // *FundBatchRequest_Branch + BatchSibling isFundBatchRequest_BatchSibling `protobuf_oneof:"batch_sibling"` +} + +func (x *FundBatchRequest) Reset() { + *x = FundBatchRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_mintrpc_mint_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FundBatchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FundBatchRequest) ProtoMessage() {} + +func (x *FundBatchRequest) ProtoReflect() protoreflect.Message { + mi := &file_mintrpc_mint_proto_msgTypes[7] + 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 FundBatchRequest.ProtoReflect.Descriptor instead. +func (*FundBatchRequest) Descriptor() ([]byte, []int) { + return file_mintrpc_mint_proto_rawDescGZIP(), []int{7} +} + +func (x *FundBatchRequest) GetShortResponse() bool { + if x != nil { + return x.ShortResponse + } + return false +} + +func (x *FundBatchRequest) GetFeeRate() uint32 { + if x != nil { + return x.FeeRate + } + return 0 +} + +func (m *FundBatchRequest) GetBatchSibling() isFundBatchRequest_BatchSibling { + if m != nil { + return m.BatchSibling + } + return nil +} + +func (x *FundBatchRequest) GetFullTree() *taprpc.TapscriptFullTree { + if x, ok := x.GetBatchSibling().(*FundBatchRequest_FullTree); ok { + return x.FullTree + } + return nil +} + +func (x *FundBatchRequest) GetBranch() *taprpc.TapBranch { + if x, ok := x.GetBatchSibling().(*FundBatchRequest_Branch); ok { + return x.Branch + } + return nil +} + +type isFundBatchRequest_BatchSibling interface { + isFundBatchRequest_BatchSibling() +} + +type FundBatchRequest_FullTree struct { + // An ordered list of TapLeafs, which will be used to construct a + // Tapscript tree. + FullTree *taprpc.TapscriptFullTree `protobuf:"bytes,3,opt,name=full_tree,json=fullTree,proto3,oneof"` +} + +type FundBatchRequest_Branch struct { + // A TapBranch that represents a Tapscript tree managed externally. + Branch *taprpc.TapBranch `protobuf:"bytes,4,opt,name=branch,proto3,oneof"` +} + +func (*FundBatchRequest_FullTree) isFundBatchRequest_BatchSibling() {} + +func (*FundBatchRequest_Branch) isFundBatchRequest_BatchSibling() {} + +type FundBatchResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The funded batch. + Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` +} + +func (x *FundBatchResponse) Reset() { + *x = FundBatchResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_mintrpc_mint_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FundBatchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FundBatchResponse) ProtoMessage() {} + +func (x *FundBatchResponse) ProtoReflect() protoreflect.Message { + mi := &file_mintrpc_mint_proto_msgTypes[8] + 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 FundBatchResponse.ProtoReflect.Descriptor instead. +func (*FundBatchResponse) Descriptor() ([]byte, []int) { + return file_mintrpc_mint_proto_rawDescGZIP(), []int{8} +} + +func (x *FundBatchResponse) GetBatch() *MintingBatch { + if x != nil { + return x.Batch + } + return nil +} + +type SealBatchRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // If true, then the assets currently in the batch won't be returned in the + // response. This is mainly to avoid a lot of data being transmitted and + // possibly printed on the command line in the case of a very large batch. + ShortResponse bool `protobuf:"varint,1,opt,name=short_response,json=shortResponse,proto3" json:"short_response,omitempty"` + // The assetID, witness pairs that authorize asset membership in a group. + GroupWitnesses []*taprpc.GroupWitness `protobuf:"bytes,2,rep,name=group_witnesses,json=groupWitnesses,proto3" json:"group_witnesses,omitempty"` +} + +func (x *SealBatchRequest) Reset() { + *x = SealBatchRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_mintrpc_mint_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SealBatchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SealBatchRequest) ProtoMessage() {} + +func (x *SealBatchRequest) ProtoReflect() protoreflect.Message { + mi := &file_mintrpc_mint_proto_msgTypes[9] + 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 SealBatchRequest.ProtoReflect.Descriptor instead. +func (*SealBatchRequest) Descriptor() ([]byte, []int) { + return file_mintrpc_mint_proto_rawDescGZIP(), []int{9} +} + +func (x *SealBatchRequest) GetShortResponse() bool { + if x != nil { + return x.ShortResponse + } + return false +} + +func (x *SealBatchRequest) GetGroupWitnesses() []*taprpc.GroupWitness { + if x != nil { + return x.GroupWitnesses + } + return nil +} + +type SealBatchResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The sealed batch. + Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` +} + +func (x *SealBatchResponse) Reset() { + *x = SealBatchResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_mintrpc_mint_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SealBatchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SealBatchResponse) ProtoMessage() {} + +func (x *SealBatchResponse) ProtoReflect() protoreflect.Message { + mi := &file_mintrpc_mint_proto_msgTypes[10] + 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 SealBatchResponse.ProtoReflect.Descriptor instead. +func (*SealBatchResponse) Descriptor() ([]byte, []int) { + return file_mintrpc_mint_proto_rawDescGZIP(), []int{10} +} + +func (x *SealBatchResponse) GetBatch() *MintingBatch { + if x != nil { + return x.Batch + } + return nil +} + type FinalizeBatchRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -566,7 +1014,7 @@ type FinalizeBatchRequest struct { func (x *FinalizeBatchRequest) Reset() { *x = FinalizeBatchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[5] + mi := &file_mintrpc_mint_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -579,7 +1027,7 @@ func (x *FinalizeBatchRequest) String() string { func (*FinalizeBatchRequest) ProtoMessage() {} func (x *FinalizeBatchRequest) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[5] + mi := &file_mintrpc_mint_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -592,7 +1040,7 @@ func (x *FinalizeBatchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeBatchRequest.ProtoReflect.Descriptor instead. func (*FinalizeBatchRequest) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{5} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{11} } func (x *FinalizeBatchRequest) GetShortResponse() bool { @@ -661,7 +1109,7 @@ type FinalizeBatchResponse struct { func (x *FinalizeBatchResponse) Reset() { *x = FinalizeBatchResponse{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[6] + mi := &file_mintrpc_mint_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -674,7 +1122,7 @@ func (x *FinalizeBatchResponse) String() string { func (*FinalizeBatchResponse) ProtoMessage() {} func (x *FinalizeBatchResponse) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[6] + mi := &file_mintrpc_mint_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -687,7 +1135,7 @@ func (x *FinalizeBatchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeBatchResponse.ProtoReflect.Descriptor instead. func (*FinalizeBatchResponse) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{6} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{12} } func (x *FinalizeBatchResponse) GetBatch() *MintingBatch { @@ -706,7 +1154,7 @@ type CancelBatchRequest struct { func (x *CancelBatchRequest) Reset() { *x = CancelBatchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[7] + mi := &file_mintrpc_mint_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -719,7 +1167,7 @@ func (x *CancelBatchRequest) String() string { func (*CancelBatchRequest) ProtoMessage() {} func (x *CancelBatchRequest) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[7] + mi := &file_mintrpc_mint_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -732,7 +1180,7 @@ func (x *CancelBatchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CancelBatchRequest.ProtoReflect.Descriptor instead. func (*CancelBatchRequest) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{7} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{13} } type CancelBatchResponse struct { @@ -747,7 +1195,7 @@ type CancelBatchResponse struct { func (x *CancelBatchResponse) Reset() { *x = CancelBatchResponse{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[8] + mi := &file_mintrpc_mint_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -760,7 +1208,7 @@ func (x *CancelBatchResponse) String() string { func (*CancelBatchResponse) ProtoMessage() {} func (x *CancelBatchResponse) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[8] + mi := &file_mintrpc_mint_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -773,7 +1221,7 @@ func (x *CancelBatchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CancelBatchResponse.ProtoReflect.Descriptor instead. func (*CancelBatchResponse) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{8} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{14} } func (x *CancelBatchResponse) GetBatchKey() []byte { @@ -795,12 +1243,15 @@ type ListBatchRequest struct { // *ListBatchRequest_BatchKey // *ListBatchRequest_BatchKeyStr Filter isListBatchRequest_Filter `protobuf_oneof:"filter"` + // If true, pending asset group information will be shown for the pending + // batch. + Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` } func (x *ListBatchRequest) Reset() { *x = ListBatchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[9] + mi := &file_mintrpc_mint_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -813,7 +1264,7 @@ func (x *ListBatchRequest) String() string { func (*ListBatchRequest) ProtoMessage() {} func (x *ListBatchRequest) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[9] + mi := &file_mintrpc_mint_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -826,7 +1277,7 @@ func (x *ListBatchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBatchRequest.ProtoReflect.Descriptor instead. func (*ListBatchRequest) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{9} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{15} } func (m *ListBatchRequest) GetFilter() isListBatchRequest_Filter { @@ -850,6 +1301,13 @@ func (x *ListBatchRequest) GetBatchKeyStr() string { return "" } +func (x *ListBatchRequest) GetVerbose() bool { + if x != nil { + return x.Verbose + } + return false +} + type isListBatchRequest_Filter interface { isListBatchRequest_Filter() } @@ -875,13 +1333,13 @@ type ListBatchResponse struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Batches []*MintingBatch `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"` + Batches []*VerboseBatch `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"` } func (x *ListBatchResponse) Reset() { *x = ListBatchResponse{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[10] + mi := &file_mintrpc_mint_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -894,7 +1352,7 @@ func (x *ListBatchResponse) String() string { func (*ListBatchResponse) ProtoMessage() {} func (x *ListBatchResponse) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[10] + mi := &file_mintrpc_mint_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -907,10 +1365,10 @@ func (x *ListBatchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBatchResponse.ProtoReflect.Descriptor instead. func (*ListBatchResponse) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{10} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{16} } -func (x *ListBatchResponse) GetBatches() []*MintingBatch { +func (x *ListBatchResponse) GetBatches() []*VerboseBatch { if x != nil { return x.Batches } @@ -931,7 +1389,7 @@ type SubscribeMintEventsRequest struct { func (x *SubscribeMintEventsRequest) Reset() { *x = SubscribeMintEventsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[11] + mi := &file_mintrpc_mint_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -944,7 +1402,7 @@ func (x *SubscribeMintEventsRequest) String() string { func (*SubscribeMintEventsRequest) ProtoMessage() {} func (x *SubscribeMintEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[11] + mi := &file_mintrpc_mint_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -957,7 +1415,7 @@ func (x *SubscribeMintEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubscribeMintEventsRequest.ProtoReflect.Descriptor instead. func (*SubscribeMintEventsRequest) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{11} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{17} } func (x *SubscribeMintEventsRequest) GetShortResponse() bool { @@ -987,7 +1445,7 @@ type MintEvent struct { func (x *MintEvent) Reset() { *x = MintEvent{} if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[12] + mi := &file_mintrpc_mint_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1000,7 +1458,7 @@ func (x *MintEvent) String() string { func (*MintEvent) ProtoMessage() {} func (x *MintEvent) ProtoReflect() protoreflect.Message { - mi := &file_mintrpc_mint_proto_msgTypes[12] + mi := &file_mintrpc_mint_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1013,7 +1471,7 @@ func (x *MintEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use MintEvent.ProtoReflect.Descriptor instead. func (*MintEvent) Descriptor() ([]byte, []int) { - return file_mintrpc_mint_proto_rawDescGZIP(), []int{12} + return file_mintrpc_mint_proto_rawDescGZIP(), []int{18} } func (x *MintEvent) GetTimestamp() int64 { @@ -1050,7 +1508,7 @@ var file_mintrpc_mint_proto_rawDesc = []byte{ 0x0a, 0x12, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2f, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x07, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x1a, 0x13, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x22, 0xc5, 0x02, 0x0a, 0x0c, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x73, + 0x74, 0x6f, 0x22, 0xee, 0x03, 0x0a, 0x0c, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 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, @@ -1070,150 +1528,230 @@ var file_mintrpc_mint_proto_rawDesc = []byte{ 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x07, 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, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x67, - 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x22, 0xe7, 0x02, 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, 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, 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, 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, 0x61, 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, 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, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 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, + 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, 0x09, 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, 0x0a, 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, + 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, + 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, + 0x65, 0x74, 0x12, 0x43, 0x0a, 0x11, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x40, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, + 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, 0x90, 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, 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, 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, 0xfc, 0x02, 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, 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, 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, + 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, 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, 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, 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 ( @@ -1229,60 +1767,89 @@ func file_mintrpc_mint_proto_rawDescGZIP() []byte { } var file_mintrpc_mint_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_mintrpc_mint_proto_msgTypes = make([]protoimpl.MessageInfo, 13) +var file_mintrpc_mint_proto_msgTypes = make([]protoimpl.MessageInfo, 19) var file_mintrpc_mint_proto_goTypes = []interface{}{ (BatchState)(0), // 0: mintrpc.BatchState (*PendingAsset)(nil), // 1: mintrpc.PendingAsset - (*MintAsset)(nil), // 2: mintrpc.MintAsset - (*MintAssetRequest)(nil), // 3: mintrpc.MintAssetRequest - (*MintAssetResponse)(nil), // 4: mintrpc.MintAssetResponse - (*MintingBatch)(nil), // 5: mintrpc.MintingBatch - (*FinalizeBatchRequest)(nil), // 6: mintrpc.FinalizeBatchRequest - (*FinalizeBatchResponse)(nil), // 7: mintrpc.FinalizeBatchResponse - (*CancelBatchRequest)(nil), // 8: mintrpc.CancelBatchRequest - (*CancelBatchResponse)(nil), // 9: mintrpc.CancelBatchResponse - (*ListBatchRequest)(nil), // 10: mintrpc.ListBatchRequest - (*ListBatchResponse)(nil), // 11: mintrpc.ListBatchResponse - (*SubscribeMintEventsRequest)(nil), // 12: mintrpc.SubscribeMintEventsRequest - (*MintEvent)(nil), // 13: mintrpc.MintEvent - (taprpc.AssetVersion)(0), // 14: taprpc.AssetVersion - (taprpc.AssetType)(0), // 15: taprpc.AssetType - (*taprpc.AssetMeta)(nil), // 16: taprpc.AssetMeta - (*taprpc.TapscriptFullTree)(nil), // 17: taprpc.TapscriptFullTree - (*taprpc.TapBranch)(nil), // 18: taprpc.TapBranch + (*UnsealedAsset)(nil), // 2: mintrpc.UnsealedAsset + (*MintAsset)(nil), // 3: mintrpc.MintAsset + (*MintAssetRequest)(nil), // 4: mintrpc.MintAssetRequest + (*MintAssetResponse)(nil), // 5: mintrpc.MintAssetResponse + (*MintingBatch)(nil), // 6: mintrpc.MintingBatch + (*VerboseBatch)(nil), // 7: mintrpc.VerboseBatch + (*FundBatchRequest)(nil), // 8: mintrpc.FundBatchRequest + (*FundBatchResponse)(nil), // 9: mintrpc.FundBatchResponse + (*SealBatchRequest)(nil), // 10: mintrpc.SealBatchRequest + (*SealBatchResponse)(nil), // 11: mintrpc.SealBatchResponse + (*FinalizeBatchRequest)(nil), // 12: mintrpc.FinalizeBatchRequest + (*FinalizeBatchResponse)(nil), // 13: mintrpc.FinalizeBatchResponse + (*CancelBatchRequest)(nil), // 14: mintrpc.CancelBatchRequest + (*CancelBatchResponse)(nil), // 15: mintrpc.CancelBatchResponse + (*ListBatchRequest)(nil), // 16: mintrpc.ListBatchRequest + (*ListBatchResponse)(nil), // 17: mintrpc.ListBatchResponse + (*SubscribeMintEventsRequest)(nil), // 18: mintrpc.SubscribeMintEventsRequest + (*MintEvent)(nil), // 19: mintrpc.MintEvent + (taprpc.AssetVersion)(0), // 20: taprpc.AssetVersion + (taprpc.AssetType)(0), // 21: taprpc.AssetType + (*taprpc.AssetMeta)(nil), // 22: taprpc.AssetMeta + (*taprpc.KeyDescriptor)(nil), // 23: taprpc.KeyDescriptor + (*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 } var file_mintrpc_mint_proto_depIdxs = []int32{ - 14, // 0: mintrpc.PendingAsset.asset_version:type_name -> taprpc.AssetVersion - 15, // 1: mintrpc.PendingAsset.asset_type:type_name -> taprpc.AssetType - 16, // 2: mintrpc.PendingAsset.asset_meta:type_name -> taprpc.AssetMeta - 14, // 3: mintrpc.MintAsset.asset_version:type_name -> taprpc.AssetVersion - 15, // 4: mintrpc.MintAsset.asset_type:type_name -> taprpc.AssetType - 16, // 5: mintrpc.MintAsset.asset_meta:type_name -> taprpc.AssetMeta - 2, // 6: mintrpc.MintAssetRequest.asset:type_name -> mintrpc.MintAsset - 5, // 7: mintrpc.MintAssetResponse.pending_batch:type_name -> mintrpc.MintingBatch - 0, // 8: mintrpc.MintingBatch.state:type_name -> mintrpc.BatchState - 1, // 9: mintrpc.MintingBatch.assets:type_name -> mintrpc.PendingAsset - 17, // 10: mintrpc.FinalizeBatchRequest.full_tree:type_name -> taprpc.TapscriptFullTree - 18, // 11: mintrpc.FinalizeBatchRequest.branch:type_name -> taprpc.TapBranch - 5, // 12: mintrpc.FinalizeBatchResponse.batch:type_name -> mintrpc.MintingBatch - 5, // 13: mintrpc.ListBatchResponse.batches:type_name -> mintrpc.MintingBatch - 0, // 14: mintrpc.MintEvent.batch_state:type_name -> mintrpc.BatchState - 5, // 15: mintrpc.MintEvent.batch:type_name -> mintrpc.MintingBatch - 3, // 16: mintrpc.Mint.MintAsset:input_type -> mintrpc.MintAssetRequest - 6, // 17: mintrpc.Mint.FinalizeBatch:input_type -> mintrpc.FinalizeBatchRequest - 8, // 18: mintrpc.Mint.CancelBatch:input_type -> mintrpc.CancelBatchRequest - 10, // 19: mintrpc.Mint.ListBatches:input_type -> mintrpc.ListBatchRequest - 12, // 20: mintrpc.Mint.SubscribeMintEvents:input_type -> mintrpc.SubscribeMintEventsRequest - 4, // 21: mintrpc.Mint.MintAsset:output_type -> mintrpc.MintAssetResponse - 7, // 22: mintrpc.Mint.FinalizeBatch:output_type -> mintrpc.FinalizeBatchResponse - 9, // 23: mintrpc.Mint.CancelBatch:output_type -> mintrpc.CancelBatchResponse - 11, // 24: mintrpc.Mint.ListBatches:output_type -> mintrpc.ListBatchResponse - 13, // 25: mintrpc.Mint.SubscribeMintEvents:output_type -> mintrpc.MintEvent - 21, // [21:26] is the sub-list for method output_type - 16, // [16:21] is the sub-list for method input_type - 16, // [16:16] is the sub-list for extension type_name - 16, // [16:16] is the sub-list for extension extendee - 0, // [0:16] is the sub-list for field type_name + 20, // 0: mintrpc.PendingAsset.asset_version:type_name -> taprpc.AssetVersion + 21, // 1: mintrpc.PendingAsset.asset_type:type_name -> taprpc.AssetType + 22, // 2: mintrpc.PendingAsset.asset_meta:type_name -> taprpc.AssetMeta + 23, // 3: mintrpc.PendingAsset.group_internal_key:type_name -> taprpc.KeyDescriptor + 24, // 4: mintrpc.PendingAsset.script_key:type_name -> taprpc.ScriptKey + 1, // 5: mintrpc.UnsealedAsset.asset:type_name -> mintrpc.PendingAsset + 25, // 6: mintrpc.UnsealedAsset.group_key_request:type_name -> taprpc.GroupKeyRequest + 26, // 7: mintrpc.UnsealedAsset.group_virtual_tx:type_name -> taprpc.GroupVirtualTx + 20, // 8: mintrpc.MintAsset.asset_version:type_name -> taprpc.AssetVersion + 21, // 9: mintrpc.MintAsset.asset_type:type_name -> taprpc.AssetType + 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 } func init() { file_mintrpc_mint_proto_init() } @@ -1304,7 +1871,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MintAsset); i { + switch v := v.(*UnsealedAsset); i { case 0: return &v.state case 1: @@ -1316,7 +1883,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MintAssetRequest); i { + switch v := v.(*MintAsset); i { case 0: return &v.state case 1: @@ -1328,7 +1895,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MintAssetResponse); i { + switch v := v.(*MintAssetRequest); i { case 0: return &v.state case 1: @@ -1340,7 +1907,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MintingBatch); i { + switch v := v.(*MintAssetResponse); i { case 0: return &v.state case 1: @@ -1352,7 +1919,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FinalizeBatchRequest); i { + switch v := v.(*MintingBatch); i { case 0: return &v.state case 1: @@ -1364,7 +1931,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FinalizeBatchResponse); i { + switch v := v.(*VerboseBatch); i { case 0: return &v.state case 1: @@ -1376,7 +1943,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CancelBatchRequest); i { + switch v := v.(*FundBatchRequest); i { case 0: return &v.state case 1: @@ -1388,7 +1955,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CancelBatchResponse); i { + switch v := v.(*FundBatchResponse); i { case 0: return &v.state case 1: @@ -1400,7 +1967,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBatchRequest); i { + switch v := v.(*SealBatchRequest); i { case 0: return &v.state case 1: @@ -1412,7 +1979,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBatchResponse); i { + switch v := v.(*SealBatchResponse); i { case 0: return &v.state case 1: @@ -1424,7 +1991,7 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SubscribeMintEventsRequest); i { + switch v := v.(*FinalizeBatchRequest); i { case 0: return &v.state case 1: @@ -1436,6 +2003,78 @@ func file_mintrpc_mint_proto_init() { } } file_mintrpc_mint_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FinalizeBatchResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_mintrpc_mint_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelBatchRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_mintrpc_mint_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelBatchResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_mintrpc_mint_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListBatchRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_mintrpc_mint_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListBatchResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_mintrpc_mint_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SubscribeMintEventsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_mintrpc_mint_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MintEvent); i { case 0: return &v.state @@ -1448,11 +2087,15 @@ func file_mintrpc_mint_proto_init() { } } } - file_mintrpc_mint_proto_msgTypes[5].OneofWrappers = []interface{}{ + file_mintrpc_mint_proto_msgTypes[7].OneofWrappers = []interface{}{ + (*FundBatchRequest_FullTree)(nil), + (*FundBatchRequest_Branch)(nil), + } + file_mintrpc_mint_proto_msgTypes[11].OneofWrappers = []interface{}{ (*FinalizeBatchRequest_FullTree)(nil), (*FinalizeBatchRequest_Branch)(nil), } - file_mintrpc_mint_proto_msgTypes[9].OneofWrappers = []interface{}{ + file_mintrpc_mint_proto_msgTypes[15].OneofWrappers = []interface{}{ (*ListBatchRequest_BatchKey)(nil), (*ListBatchRequest_BatchKeyStr)(nil), } @@ -1462,7 +2105,7 @@ func file_mintrpc_mint_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_mintrpc_mint_proto_rawDesc, NumEnums: 1, - NumMessages: 13, + NumMessages: 19, NumExtensions: 0, NumServices: 1, }, diff --git a/taprpc/mintrpc/mint.pb.gw.go b/taprpc/mintrpc/mint.pb.gw.go index adec09591e..616eefd2bd 100644 --- a/taprpc/mintrpc/mint.pb.gw.go +++ b/taprpc/mintrpc/mint.pb.gw.go @@ -65,6 +65,74 @@ func local_request_Mint_MintAsset_0(ctx context.Context, marshaler runtime.Marsh } +func request_Mint_FundBatch_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq FundBatchRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.FundBatch(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Mint_FundBatch_0(ctx context.Context, marshaler runtime.Marshaler, server MintServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq FundBatchRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.FundBatch(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Mint_SealBatch_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SealBatchRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SealBatch(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Mint_SealBatch_0(ctx context.Context, marshaler runtime.Marshaler, server MintServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SealBatchRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SealBatch(ctx, &protoReq) + return msg, metadata, err + +} + func request_Mint_FinalizeBatch_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq FinalizeBatchRequest var metadata runtime.ServerMetadata @@ -269,6 +337,56 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve }) + mux.Handle("POST", pattern_Mint_FundBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/mintrpc.Mint/FundBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/fund")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Mint_FundBatch_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_Mint_FundBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Mint_SealBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/mintrpc.Mint/SealBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/seal")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Mint_SealBatch_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_Mint_SealBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("POST", pattern_Mint_FinalizeBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -414,6 +532,50 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien }) + mux.Handle("POST", pattern_Mint_FundBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/FundBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/fund")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Mint_FundBatch_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_Mint_FundBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Mint_SealBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/SealBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/seal")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Mint_SealBatch_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_Mint_SealBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("POST", pattern_Mint_FinalizeBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -508,6 +670,10 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien var ( pattern_Mint_MintAsset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "assets"}, "")) + pattern_Mint_FundBatch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "assets", "mint", "fund"}, "")) + + pattern_Mint_SealBatch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "assets", "mint", "seal"}, "")) + pattern_Mint_FinalizeBatch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "assets", "mint", "finalize"}, "")) pattern_Mint_CancelBatch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "assets", "mint", "cancel"}, "")) @@ -520,6 +686,10 @@ var ( var ( forward_Mint_MintAsset_0 = runtime.ForwardResponseMessage + forward_Mint_FundBatch_0 = runtime.ForwardResponseMessage + + forward_Mint_SealBatch_0 = runtime.ForwardResponseMessage + forward_Mint_FinalizeBatch_0 = runtime.ForwardResponseMessage forward_Mint_CancelBatch_0 = runtime.ForwardResponseMessage diff --git a/taprpc/mintrpc/mint.pb.json.go b/taprpc/mintrpc/mint.pb.json.go index eb7958c2ef..3641d19cec 100644 --- a/taprpc/mintrpc/mint.pb.json.go +++ b/taprpc/mintrpc/mint.pb.json.go @@ -46,6 +46,56 @@ func RegisterMintJSONCallbacks(registry map[string]func(ctx context.Context, callback(string(respBytes), nil) } + registry["mintrpc.Mint.FundBatch"] = func(ctx context.Context, + conn *grpc.ClientConn, reqJSON string, callback func(string, error)) { + + req := &FundBatchRequest{} + err := marshaler.Unmarshal([]byte(reqJSON), req) + if err != nil { + callback("", err) + return + } + + client := NewMintClient(conn) + resp, err := client.FundBatch(ctx, req) + if err != nil { + callback("", err) + return + } + + respBytes, err := marshaler.Marshal(resp) + if err != nil { + callback("", err) + return + } + callback(string(respBytes), nil) + } + + registry["mintrpc.Mint.SealBatch"] = func(ctx context.Context, + conn *grpc.ClientConn, reqJSON string, callback func(string, error)) { + + req := &SealBatchRequest{} + err := marshaler.Unmarshal([]byte(reqJSON), req) + if err != nil { + callback("", err) + return + } + + client := NewMintClient(conn) + resp, err := client.SealBatch(ctx, req) + if err != nil { + callback("", err) + return + } + + respBytes, err := marshaler.Marshal(resp) + if err != nil { + callback("", err) + return + } + callback(string(respBytes), nil) + } + registry["mintrpc.Mint.FinalizeBatch"] = func(ctx context.Context, conn *grpc.ClientConn, reqJSON string, callback func(string, error)) { diff --git a/taprpc/mintrpc/mint.proto b/taprpc/mintrpc/mint.proto index 6eb09c37cd..beb7924d87 100644 --- a/taprpc/mintrpc/mint.proto +++ b/taprpc/mintrpc/mint.proto @@ -16,6 +16,24 @@ service Mint { */ rpc MintAsset (MintAssetRequest) returns (MintAssetResponse); + /* tapcli `assets mint fund` + FundBatch will attempt to fund the current pending batch with a genesis + input, or create a new funded batch if no batch exists yet. This RPC is only + needed if a custom witness is needed to finalize the batch. Otherwise, + FinalizeBatch can be called directly. + */ + rpc FundBatch (FundBatchRequest) returns (FundBatchResponse); + + /* tapcli `assets mint seal` + SealBatch will attempt to seal the current pending batch by creating and + validating asset group witness for all assets in the batch. If a witness + is not provided, a signature will be derived to serve as the witness. This + RPC is only needed if any assets in the batch have a custom asset group key + that require an external signer. Otherwise, FinalizeBatch can be called + directly. + */ + rpc SealBatch (SealBatchRequest) returns (SealBatchResponse); + /* tapcli: `assets mint finalize` FinalizeBatch will attempt to finalize the current pending batch. */ @@ -68,7 +86,7 @@ message PendingAsset { */ bool new_grouped_asset = 6; - // The specific group key this asset should be minted with. + // The specific existing group key this asset should be minted with. bytes group_key = 7; /* @@ -76,6 +94,36 @@ message PendingAsset { This asset will be minted with the same group key as the anchor asset. */ string group_anchor = 8; + + /* + The optional key that will be used as the internal key for an asset group + created with this asset. + */ + taprpc.KeyDescriptor group_internal_key = 9; + + /* + 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. + */ + bytes group_tapscript_root = 10; + + /* + 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. + */ + taprpc.ScriptKey script_key = 11; +} + +message UnsealedAsset { + // The pending asset with an unsealed asset group. + PendingAsset asset = 1; + + // The group key request for the asset. + taprpc.GroupKeyRequest group_key_request = 2; + + // The group virtual transaction for the asset. + taprpc.GroupVirtualTx group_virtual_tx = 3; } message MintAsset { @@ -112,7 +160,7 @@ message MintAsset { */ bool grouped_asset = 7; - // The specific group key this asset should be minted with. + // The specific existing group key this asset should be minted with. bytes group_key = 8; /* @@ -120,6 +168,25 @@ message MintAsset { This asset will be minted with the same group key as the anchor asset. */ string group_anchor = 9; + + /* + The optional key that will be used as the internal key for an asset group + created with this asset. + */ + 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. + */ + bytes group_tapscript_root = 11; + + /* + 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. + */ + taprpc.ScriptKey script_key = 12; } message MintAssetRequest { @@ -172,6 +239,14 @@ message MintingBatch { bytes batch_psbt = 7; } +message VerboseBatch { + // The minting batch, without any assets. + MintingBatch batch = 1; + + // The assets that are part of the batch. + repeated UnsealedAsset unsealed_assets = 2; +} + enum BatchState { BATCH_STATE_UNKNOWN = 0; BATCH_STATE_PENDING = 1; @@ -184,6 +259,56 @@ enum BatchState { BATCH_STATE_SPROUT_CANCELLED = 8; } +message FundBatchRequest { + /* + If true, then the assets currently in the batch won't be returned in the + response. This is mainly to avoid a lot of data being transmitted and + possibly printed on the command line in the case of a very large batch. + */ + bool short_response = 1; + + // The optional fee rate to use for the minting transaction, in sat/kw. + uint32 fee_rate = 2; + + /* + The optional tapscript sibling that will be used when deriving the genesis + output for the batch. This sibling is a tapscript tree, which allows the + minter to encumber future transfers of assets in the batch with Tapscript. + */ + oneof batch_sibling { + /* + An ordered list of TapLeafs, which will be used to construct a + Tapscript tree. + */ + taprpc.TapscriptFullTree full_tree = 3; + + // A TapBranch that represents a Tapscript tree managed externally. + taprpc.TapBranch branch = 4; + } +} + +message FundBatchResponse { + // The funded batch. + MintingBatch batch = 1; +} + +message SealBatchRequest { + /* + If true, then the assets currently in the batch won't be returned in the + response. This is mainly to avoid a lot of data being transmitted and + possibly printed on the command line in the case of a very large batch. + */ + bool short_response = 1; + + // The assetID, witness pairs that authorize asset membership in a group. + repeated taprpc.GroupWitness group_witnesses = 2; +} + +message SealBatchResponse { + // The sealed batch. + MintingBatch batch = 1; +} + message FinalizeBatchRequest { /* If true, then the assets currently in the batch won't be returned in the @@ -236,10 +361,14 @@ message ListBatchRequest { // encoded string (use this for REST). string batch_key_str = 2; } + + // If true, pending asset group information will be shown for the pending + // batch. + bool verbose = 3; } message ListBatchResponse { - repeated MintingBatch batches = 1; + repeated VerboseBatch batches = 1; } message SubscribeMintEventsRequest { diff --git a/taprpc/mintrpc/mint.swagger.json b/taprpc/mintrpc/mint.swagger.json index 536c6fcfe8..23eaee3ed6 100644 --- a/taprpc/mintrpc/mint.swagger.json +++ b/taprpc/mintrpc/mint.swagger.json @@ -82,6 +82,13 @@ "in": "query", "required": false, "type": "string" + }, + { + "name": "verbose", + "description": "If true, pending asset group information will be shown for the pending\nbatch.", + "in": "query", + "required": false, + "type": "boolean" } ], "tags": [ @@ -155,6 +162,72 @@ ] } }, + "/v1/taproot-assets/assets/mint/fund": { + "post": { + "summary": "tapcli `assets mint fund`\nFundBatch will attempt to fund the current pending batch with a genesis\ninput, or create a new funded batch if no batch exists yet. This RPC is only\nneeded if a custom witness is needed to finalize the batch. Otherwise,\nFinalizeBatch can be called directly.", + "operationId": "Mint_FundBatch", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/mintrpcFundBatchResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/mintrpcFundBatchRequest" + } + } + ], + "tags": [ + "Mint" + ] + } + }, + "/v1/taproot-assets/assets/mint/seal": { + "post": { + "summary": "tapcli `assets mint seal`\nSealBatch will attempt to seal the current pending batch by creating and\nvalidating asset group witness for all assets in the batch. If a witness\nis not provided, a signature will be derived to serve as the witness. This\nRPC is only needed if any assets in the batch have a custom asset group key\nthat require an external signer. Otherwise, FinalizeBatch can be called\ndirectly.", + "operationId": "Mint_SealBatch", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/mintrpcSealBatchResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/mintrpcSealBatchRequest" + } + } + ], + "tags": [ + "Mint" + ] + } + }, "/v1/taproot-assets/events/asset-mint": { "post": { "summary": "tapcli: `events mint`\nSubscribeMintEvents allows a caller to subscribe to mint events for asset\ncreation batches.", @@ -258,6 +331,37 @@ } } }, + "mintrpcFundBatchRequest": { + "type": "object", + "properties": { + "short_response": { + "type": "boolean", + "description": "If true, then the assets currently in the batch won't be returned in the\nresponse. This is mainly to avoid a lot of data being transmitted and\npossibly printed on the command line in the case of a very large batch." + }, + "fee_rate": { + "type": "integer", + "format": "int64", + "description": "The optional fee rate to use for the minting transaction, in sat/kw." + }, + "full_tree": { + "$ref": "#/definitions/taprpcTapscriptFullTree", + "description": "An ordered list of TapLeafs, which will be used to construct a\nTapscript tree." + }, + "branch": { + "$ref": "#/definitions/taprpcTapBranch", + "description": "A TapBranch that represents a Tapscript tree managed externally." + } + } + }, + "mintrpcFundBatchResponse": { + "type": "object", + "properties": { + "batch": { + "$ref": "#/definitions/mintrpcMintingBatch", + "description": "The funded batch." + } + } + }, "mintrpcListBatchResponse": { "type": "object", "properties": { @@ -265,7 +369,7 @@ "type": "array", "items": { "type": "object", - "$ref": "#/definitions/mintrpcMintingBatch" + "$ref": "#/definitions/mintrpcVerboseBatch" } } } @@ -305,11 +409,24 @@ "group_key": { "type": "string", "format": "byte", - "description": "The specific group key this asset should be minted with." + "description": "The specific existing group key this asset should be minted with." }, "group_anchor": { "type": "string", "description": "The name of the asset in the batch that will anchor a new asset group.\nThis asset will be minted with the same group key as the anchor asset." + }, + "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." + }, + "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." + }, + "script_key": { + "$ref": "#/definitions/taprpcScriptKey", + "description": "The optional script key to use for the new asset. If no script key is given,\na BIP-86 key will be derived from the underlying wallet." } } }, @@ -429,11 +546,50 @@ "group_key": { "type": "string", "format": "byte", - "description": "The specific group key this asset should be minted with." + "description": "The specific existing group key this asset should be minted with." }, "group_anchor": { "type": "string", "description": "The name of the asset in the batch that will anchor a new asset group.\nThis asset will be minted with the same group key as the anchor asset." + }, + "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." + }, + "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." + }, + "script_key": { + "$ref": "#/definitions/taprpcScriptKey", + "description": "The optional script key to use for the new asset. If no script key is given,\na BIP-86 key will be derived from the underlying wallet." + } + } + }, + "mintrpcSealBatchRequest": { + "type": "object", + "properties": { + "short_response": { + "type": "boolean", + "description": "If true, then the assets currently in the batch won't be returned in the\nresponse. This is mainly to avoid a lot of data being transmitted and\npossibly printed on the command line in the case of a very large batch." + }, + "group_witnesses": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/taprpcGroupWitness" + }, + "description": "The assetID, witness pairs that authorize asset membership in a group." + } + } + }, + "mintrpcSealBatchResponse": { + "type": "object", + "properties": { + "batch": { + "$ref": "#/definitions/mintrpcMintingBatch", + "description": "The sealed batch." } } }, @@ -446,6 +602,40 @@ } } }, + "mintrpcUnsealedAsset": { + "type": "object", + "properties": { + "asset": { + "$ref": "#/definitions/mintrpcPendingAsset", + "description": "The pending asset with an unsealed asset group." + }, + "group_key_request": { + "$ref": "#/definitions/taprpcGroupKeyRequest", + "description": "The group key request for the asset." + }, + "group_virtual_tx": { + "$ref": "#/definitions/taprpcGroupVirtualTx", + "description": "The group virtual transaction for the asset." + } + } + }, + "mintrpcVerboseBatch": { + "type": "object", + "properties": { + "batch": { + "$ref": "#/definitions/mintrpcMintingBatch", + "description": "The minting batch, without any assets." + }, + "unsealed_assets": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/mintrpcUnsealedAsset" + }, + "description": "The assets that are part of the batch." + } + } + }, "protobufAny": { "type": "object", "properties": { @@ -520,6 +710,151 @@ "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." }, + "taprpcGenesisInfo": { + "type": "object", + "properties": { + "genesis_point": { + "type": "string", + "description": "The first outpoint of the transaction that created the asset (txid:vout)." + }, + "name": { + "type": "string", + "description": "The name of the asset." + }, + "meta_hash": { + "type": "string", + "format": "byte", + "description": "The hash of the meta data for this genesis asset." + }, + "asset_id": { + "type": "string", + "format": "byte", + "description": "The asset ID that uniquely identifies the asset." + }, + "asset_type": { + "$ref": "#/definitions/taprpcAssetType", + "description": "The type of the asset." + }, + "output_index": { + "type": "integer", + "format": "int64", + "description": "The index of the output that carries the unique Taproot Asset commitment in\nthe genesis transaction." + } + } + }, + "taprpcGroupKeyRequest": { + "type": "object", + "properties": { + "raw_key": { + "$ref": "#/definitions/taprpcKeyDescriptor", + "description": "The internal key for the asset group before any tweaks have been applied." + }, + "anchor_genesis": { + "$ref": "#/definitions/taprpcGenesisInfo", + "description": "The genesis of the group anchor asset, which is used to derive the single\ntweak for the group key. For a new group key, this will be the genesis of\nnew_asset." + }, + "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." + }, + "new_asset": { + "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." + } + } + }, + "taprpcGroupVirtualTx": { + "type": "object", + "properties": { + "transaction": { + "type": "string", + "format": "byte", + "description": "The virtual transaction that represents the genesis state transition of a\ngrouped asset." + }, + "prev_out": { + "$ref": "#/definitions/taprpcTxOut", + "description": "The transaction output that represents a grouped asset. The tweaked\ngroup key is set as the PkScript of this output. This is used in combination\nwith Tx to produce an asset group witness." + }, + "genesis_id": { + "type": "string", + "format": "byte", + "description": "The asset ID of the grouped asset in a GroupKeyRequest. This ID is\nneeded to construct a sign descriptor, as it is the single tweak for the\ngroup internal key." + }, + "tweaked_key": { + "type": "string", + "format": "byte", + "description": "The tweaked group key for a specific GroupKeyRequest. This is used to\nconstruct a complete group key after producing an asset group witness." + } + } + }, + "taprpcGroupWitness": { + "type": "object", + "properties": { + "genesis_id": { + "type": "string", + "format": "byte", + "description": "The asset ID of the pending asset that should be assigned this asset\ngroup witness." + }, + "witness": { + "type": "array", + "items": { + "type": "string", + "format": "byte" + }, + "description": "The serialized witness stack for the asset group." + } + } + }, + "taprpcKeyDescriptor": { + "type": "object", + "properties": { + "raw_key_bytes": { + "type": "string", + "format": "byte", + "description": "The raw bytes of the key being identified." + }, + "key_loc": { + "$ref": "#/definitions/taprpcKeyLocator", + "description": "The key locator that identifies which key to use for signing." + } + } + }, + "taprpcKeyLocator": { + "type": "object", + "properties": { + "key_family": { + "type": "integer", + "format": "int32", + "description": "The family of key being identified." + }, + "key_index": { + "type": "integer", + "format": "int32", + "description": "The precise index of the key being identified." + } + } + }, + "taprpcScriptKey": { + "type": "object", + "properties": { + "pub_key": { + "type": "string", + "format": "byte", + "description": "The full Taproot output key the asset is locked to. This is either a BIP-86\nkey if the tap_tweak below is empty, or a key with the tap tweak applied to\nit." + }, + "key_desc": { + "$ref": "#/definitions/taprpcKeyDescriptor", + "description": "The key descriptor describing the internal key of the above Taproot key." + }, + "tap_tweak": { + "type": "string", + "format": "byte", + "description": "The optional Taproot tweak to apply to the above internal key. If this is\nempty then a BIP-86 style tweak is applied to the internal key." + } + } + }, "taprpcTapBranch": { "type": "object", "properties": { @@ -557,6 +892,21 @@ "description": "The complete, ordered list of all tap leaves of the tree." } } + }, + "taprpcTxOut": { + "type": "object", + "properties": { + "value": { + "type": "string", + "format": "int64", + "description": "The value of the output being spent." + }, + "pk_script": { + "type": "string", + "format": "byte", + "description": "The script of the output being spent." + } + } } } } diff --git a/taprpc/mintrpc/mint.yaml b/taprpc/mintrpc/mint.yaml index 5f011e4d89..0ec2db4a97 100644 --- a/taprpc/mintrpc/mint.yaml +++ b/taprpc/mintrpc/mint.yaml @@ -7,6 +7,14 @@ http: post: "/v1/taproot-assets/assets" body: "*" + - selector: mintrpc.Mint.FundBatch + post: "/v1/taproot-assets/assets/mint/fund" + body: "*" + + - selector: mintrpc.Mint.SealBatch + post: "/v1/taproot-assets/assets/mint/seal" + body: "*" + - selector: mintrpc.Mint.FinalizeBatch post: "/v1/taproot-assets/assets/mint/finalize" body: "*" diff --git a/taprpc/mintrpc/mint_grpc.pb.go b/taprpc/mintrpc/mint_grpc.pb.go index b1a09cc655..b3ee711ab1 100644 --- a/taprpc/mintrpc/mint_grpc.pb.go +++ b/taprpc/mintrpc/mint_grpc.pb.go @@ -25,6 +25,20 @@ type MintClient interface { // batch. This call will block until the operation succeeds (asset is staged // in the batch) or fails. MintAsset(ctx context.Context, in *MintAssetRequest, opts ...grpc.CallOption) (*MintAssetResponse, error) + // tapcli `assets mint fund` + // FundBatch will attempt to fund the current pending batch with a genesis + // input, or create a new funded batch if no batch exists yet. This RPC is only + // needed if a custom witness is needed to finalize the batch. Otherwise, + // FinalizeBatch can be called directly. + FundBatch(ctx context.Context, in *FundBatchRequest, opts ...grpc.CallOption) (*FundBatchResponse, error) + // tapcli `assets mint seal` + // SealBatch will attempt to seal the current pending batch by creating and + // validating asset group witness for all assets in the batch. If a witness + // is not provided, a signature will be derived to serve as the witness. This + // RPC is only needed if any assets in the batch have a custom asset group key + // that require an external signer. Otherwise, FinalizeBatch can be called + // directly. + SealBatch(ctx context.Context, in *SealBatchRequest, opts ...grpc.CallOption) (*SealBatchResponse, error) // tapcli: `assets mint finalize` // FinalizeBatch will attempt to finalize the current pending batch. FinalizeBatch(ctx context.Context, in *FinalizeBatchRequest, opts ...grpc.CallOption) (*FinalizeBatchResponse, error) @@ -58,6 +72,24 @@ func (c *mintClient) MintAsset(ctx context.Context, in *MintAssetRequest, opts . return out, nil } +func (c *mintClient) FundBatch(ctx context.Context, in *FundBatchRequest, opts ...grpc.CallOption) (*FundBatchResponse, error) { + out := new(FundBatchResponse) + err := c.cc.Invoke(ctx, "/mintrpc.Mint/FundBatch", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *mintClient) SealBatch(ctx context.Context, in *SealBatchRequest, opts ...grpc.CallOption) (*SealBatchResponse, error) { + out := new(SealBatchResponse) + err := c.cc.Invoke(ctx, "/mintrpc.Mint/SealBatch", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *mintClient) FinalizeBatch(ctx context.Context, in *FinalizeBatchRequest, opts ...grpc.CallOption) (*FinalizeBatchResponse, error) { out := new(FinalizeBatchResponse) err := c.cc.Invoke(ctx, "/mintrpc.Mint/FinalizeBatch", in, out, opts...) @@ -128,6 +160,20 @@ type MintServer interface { // batch. This call will block until the operation succeeds (asset is staged // in the batch) or fails. MintAsset(context.Context, *MintAssetRequest) (*MintAssetResponse, error) + // tapcli `assets mint fund` + // FundBatch will attempt to fund the current pending batch with a genesis + // input, or create a new funded batch if no batch exists yet. This RPC is only + // needed if a custom witness is needed to finalize the batch. Otherwise, + // FinalizeBatch can be called directly. + FundBatch(context.Context, *FundBatchRequest) (*FundBatchResponse, error) + // tapcli `assets mint seal` + // SealBatch will attempt to seal the current pending batch by creating and + // validating asset group witness for all assets in the batch. If a witness + // is not provided, a signature will be derived to serve as the witness. This + // RPC is only needed if any assets in the batch have a custom asset group key + // that require an external signer. Otherwise, FinalizeBatch can be called + // directly. + SealBatch(context.Context, *SealBatchRequest) (*SealBatchResponse, error) // tapcli: `assets mint finalize` // FinalizeBatch will attempt to finalize the current pending batch. FinalizeBatch(context.Context, *FinalizeBatchRequest) (*FinalizeBatchResponse, error) @@ -152,6 +198,12 @@ type UnimplementedMintServer struct { func (UnimplementedMintServer) MintAsset(context.Context, *MintAssetRequest) (*MintAssetResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method MintAsset not implemented") } +func (UnimplementedMintServer) FundBatch(context.Context, *FundBatchRequest) (*FundBatchResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method FundBatch not implemented") +} +func (UnimplementedMintServer) SealBatch(context.Context, *SealBatchRequest) (*SealBatchResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SealBatch not implemented") +} func (UnimplementedMintServer) FinalizeBatch(context.Context, *FinalizeBatchRequest) (*FinalizeBatchResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FinalizeBatch not implemented") } @@ -195,6 +247,42 @@ func _Mint_MintAsset_Handler(srv interface{}, ctx context.Context, dec func(inte return interceptor(ctx, in, info, handler) } +func _Mint_FundBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FundBatchRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MintServer).FundBatch(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/mintrpc.Mint/FundBatch", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MintServer).FundBatch(ctx, req.(*FundBatchRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Mint_SealBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SealBatchRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MintServer).SealBatch(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/mintrpc.Mint/SealBatch", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MintServer).SealBatch(ctx, req.(*SealBatchRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Mint_FinalizeBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(FinalizeBatchRequest) if err := dec(in); err != nil { @@ -281,6 +369,14 @@ var Mint_ServiceDesc = grpc.ServiceDesc{ MethodName: "MintAsset", Handler: _Mint_MintAsset_Handler, }, + { + MethodName: "FundBatch", + Handler: _Mint_FundBatch_Handler, + }, + { + MethodName: "SealBatch", + Handler: _Mint_SealBatch_Handler, + }, { MethodName: "FinalizeBatch", Handler: _Mint_FinalizeBatch_Handler, diff --git a/taprpc/taprootassets.pb.go b/taprpc/taprootassets.pb.go index 77f17634de..6963880667 100644 --- a/taprpc/taprootassets.pb.go +++ b/taprpc/taprootassets.pb.go @@ -753,6 +753,283 @@ func (x *GenesisInfo) GetOutputIndex() uint32 { return 0 } +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. + 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 + // new_asset. + AnchorGenesis *GenesisInfo `protobuf:"bytes,2,opt,name=anchor_genesis,json=anchorGenesis,proto3" json:"anchor_genesis,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. + TapscriptRoot []byte `protobuf:"bytes,3,opt,name=tapscript_root,json=tapscriptRoot,proto3" json:"tapscript_root,omitempty"` + // The serialized 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. + NewAsset []byte `protobuf:"bytes,4,opt,name=new_asset,json=newAsset,proto3" json:"new_asset,omitempty"` +} + +func (x *GroupKeyRequest) Reset() { + *x = GroupKeyRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_taprootassets_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupKeyRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupKeyRequest) ProtoMessage() {} + +func (x *GroupKeyRequest) 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 GroupKeyRequest.ProtoReflect.Descriptor instead. +func (*GroupKeyRequest) Descriptor() ([]byte, []int) { + return file_taprootassets_proto_rawDescGZIP(), []int{4} +} + +func (x *GroupKeyRequest) GetRawKey() *KeyDescriptor { + if x != nil { + return x.RawKey + } + return nil +} + +func (x *GroupKeyRequest) GetAnchorGenesis() *GenesisInfo { + if x != nil { + return x.AnchorGenesis + } + return nil +} + +func (x *GroupKeyRequest) GetTapscriptRoot() []byte { + if x != nil { + return x.TapscriptRoot + } + return nil +} + +func (x *GroupKeyRequest) GetNewAsset() []byte { + if x != nil { + return x.NewAsset + } + return nil +} + +type TxOut struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The value of the output being spent. + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + // The script of the output being spent. + PkScript []byte `protobuf:"bytes,2,opt,name=pk_script,json=pkScript,proto3" json:"pk_script,omitempty"` +} + +func (x *TxOut) Reset() { + *x = TxOut{} + if protoimpl.UnsafeEnabled { + mi := &file_taprootassets_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TxOut) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TxOut) ProtoMessage() {} + +func (x *TxOut) ProtoReflect() protoreflect.Message { + mi := &file_taprootassets_proto_msgTypes[5] + 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 TxOut.ProtoReflect.Descriptor instead. +func (*TxOut) Descriptor() ([]byte, []int) { + return file_taprootassets_proto_rawDescGZIP(), []int{5} +} + +func (x *TxOut) GetValue() int64 { + if x != nil { + return x.Value + } + return 0 +} + +func (x *TxOut) GetPkScript() []byte { + if x != nil { + return x.PkScript + } + return nil +} + +type GroupVirtualTx struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The virtual transaction that represents the genesis state transition of a + // grouped asset. + Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` + // The transaction output that represents a grouped asset. The tweaked + // group key is set as the PkScript of this output. This is used in combination + // with Tx to produce an asset group witness. + PrevOut *TxOut `protobuf:"bytes,2,opt,name=prev_out,json=prevOut,proto3" json:"prev_out,omitempty"` + // The asset ID of the grouped asset in a GroupKeyRequest. This ID is + // needed to construct a sign descriptor, as it is the single tweak for the + // group internal key. + GenesisId []byte `protobuf:"bytes,3,opt,name=genesis_id,json=genesisId,proto3" json:"genesis_id,omitempty"` + // The tweaked group key for a specific GroupKeyRequest. This is used to + // construct a complete group key after producing an asset group witness. + TweakedKey []byte `protobuf:"bytes,4,opt,name=tweaked_key,json=tweakedKey,proto3" json:"tweaked_key,omitempty"` +} + +func (x *GroupVirtualTx) Reset() { + *x = GroupVirtualTx{} + if protoimpl.UnsafeEnabled { + mi := &file_taprootassets_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupVirtualTx) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupVirtualTx) ProtoMessage() {} + +func (x *GroupVirtualTx) ProtoReflect() protoreflect.Message { + mi := &file_taprootassets_proto_msgTypes[6] + 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 GroupVirtualTx.ProtoReflect.Descriptor instead. +func (*GroupVirtualTx) Descriptor() ([]byte, []int) { + return file_taprootassets_proto_rawDescGZIP(), []int{6} +} + +func (x *GroupVirtualTx) GetTransaction() []byte { + if x != nil { + return x.Transaction + } + return nil +} + +func (x *GroupVirtualTx) GetPrevOut() *TxOut { + if x != nil { + return x.PrevOut + } + return nil +} + +func (x *GroupVirtualTx) GetGenesisId() []byte { + if x != nil { + return x.GenesisId + } + return nil +} + +func (x *GroupVirtualTx) GetTweakedKey() []byte { + if x != nil { + return x.TweakedKey + } + return nil +} + +type GroupWitness struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The asset ID of the pending asset that should be assigned this asset + // group witness. + GenesisId []byte `protobuf:"bytes,1,opt,name=genesis_id,json=genesisId,proto3" json:"genesis_id,omitempty"` + // The serialized witness stack for the asset group. + Witness [][]byte `protobuf:"bytes,2,rep,name=witness,proto3" json:"witness,omitempty"` +} + +func (x *GroupWitness) Reset() { + *x = GroupWitness{} + if protoimpl.UnsafeEnabled { + mi := &file_taprootassets_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupWitness) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupWitness) ProtoMessage() {} + +func (x *GroupWitness) ProtoReflect() protoreflect.Message { + mi := &file_taprootassets_proto_msgTypes[7] + 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 GroupWitness.ProtoReflect.Descriptor instead. +func (*GroupWitness) Descriptor() ([]byte, []int) { + return file_taprootassets_proto_rawDescGZIP(), []int{7} +} + +func (x *GroupWitness) GetGenesisId() []byte { + if x != nil { + return x.GenesisId + } + return nil +} + +func (x *GroupWitness) GetWitness() [][]byte { + if x != nil { + return x.Witness + } + return nil +} + type AssetGroup struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -766,12 +1043,15 @@ type AssetGroup struct { // A witness that authorizes a specific asset to be part of the asset group // specified by the above key. AssetWitness []byte `protobuf:"bytes,3,opt,name=asset_witness,json=assetWitness,proto3" json:"asset_witness,omitempty"` + // The root hash of a tapscript tree, which enables future issuance authorized + // with a script witness. + TapscriptRoot []byte `protobuf:"bytes,4,opt,name=tapscript_root,json=tapscriptRoot,proto3" json:"tapscript_root,omitempty"` } func (x *AssetGroup) Reset() { *x = AssetGroup{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[4] + mi := &file_taprootassets_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -784,7 +1064,7 @@ func (x *AssetGroup) String() string { func (*AssetGroup) ProtoMessage() {} func (x *AssetGroup) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[4] + mi := &file_taprootassets_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -797,7 +1077,7 @@ func (x *AssetGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetGroup.ProtoReflect.Descriptor instead. func (*AssetGroup) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{4} + return file_taprootassets_proto_rawDescGZIP(), []int{8} } func (x *AssetGroup) GetRawGroupKey() []byte { @@ -821,6 +1101,13 @@ func (x *AssetGroup) GetAssetWitness() []byte { return nil } +func (x *AssetGroup) GetTapscriptRoot() []byte { + if x != nil { + return x.TapscriptRoot + } + return nil +} + type GroupKeyReveal struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -835,7 +1122,7 @@ type GroupKeyReveal struct { func (x *GroupKeyReveal) Reset() { *x = GroupKeyReveal{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[5] + mi := &file_taprootassets_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -848,7 +1135,7 @@ func (x *GroupKeyReveal) String() string { func (*GroupKeyReveal) ProtoMessage() {} func (x *GroupKeyReveal) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[5] + mi := &file_taprootassets_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -861,7 +1148,7 @@ func (x *GroupKeyReveal) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupKeyReveal.ProtoReflect.Descriptor instead. func (*GroupKeyReveal) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{5} + return file_taprootassets_proto_rawDescGZIP(), []int{9} } func (x *GroupKeyReveal) GetRawGroupKey() []byte { @@ -890,7 +1177,7 @@ type GenesisReveal struct { func (x *GenesisReveal) Reset() { *x = GenesisReveal{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[6] + mi := &file_taprootassets_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -903,7 +1190,7 @@ func (x *GenesisReveal) String() string { func (*GenesisReveal) ProtoMessage() {} func (x *GenesisReveal) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[6] + mi := &file_taprootassets_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -916,7 +1203,7 @@ func (x *GenesisReveal) ProtoReflect() protoreflect.Message { // Deprecated: Use GenesisReveal.ProtoReflect.Descriptor instead. func (*GenesisReveal) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{6} + return file_taprootassets_proto_rawDescGZIP(), []int{10} } func (x *GenesisReveal) GetGenesisBaseReveal() *GenesisInfo { @@ -969,7 +1256,7 @@ type Asset struct { func (x *Asset) Reset() { *x = Asset{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[7] + mi := &file_taprootassets_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -982,7 +1269,7 @@ func (x *Asset) String() string { func (*Asset) ProtoMessage() {} func (x *Asset) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[7] + mi := &file_taprootassets_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -995,7 +1282,7 @@ func (x *Asset) ProtoReflect() protoreflect.Message { // Deprecated: Use Asset.ProtoReflect.Descriptor instead. func (*Asset) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{7} + return file_taprootassets_proto_rawDescGZIP(), []int{11} } func (x *Asset) GetVersion() AssetVersion { @@ -1116,7 +1403,7 @@ type PrevWitness struct { func (x *PrevWitness) Reset() { *x = PrevWitness{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[8] + mi := &file_taprootassets_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1129,7 +1416,7 @@ func (x *PrevWitness) String() string { func (*PrevWitness) ProtoMessage() {} func (x *PrevWitness) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[8] + mi := &file_taprootassets_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1142,7 +1429,7 @@ func (x *PrevWitness) ProtoReflect() protoreflect.Message { // Deprecated: Use PrevWitness.ProtoReflect.Descriptor instead. func (*PrevWitness) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{8} + return file_taprootassets_proto_rawDescGZIP(), []int{12} } func (x *PrevWitness) GetPrevId() *PrevInputAsset { @@ -1177,7 +1464,7 @@ type SplitCommitment struct { func (x *SplitCommitment) Reset() { *x = SplitCommitment{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[9] + mi := &file_taprootassets_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1190,7 +1477,7 @@ func (x *SplitCommitment) String() string { func (*SplitCommitment) ProtoMessage() {} func (x *SplitCommitment) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[9] + mi := &file_taprootassets_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1203,7 +1490,7 @@ func (x *SplitCommitment) ProtoReflect() protoreflect.Message { // Deprecated: Use SplitCommitment.ProtoReflect.Descriptor instead. func (*SplitCommitment) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{9} + return file_taprootassets_proto_rawDescGZIP(), []int{13} } func (x *SplitCommitment) GetRootAsset() *Asset { @@ -1224,7 +1511,7 @@ type ListAssetResponse struct { func (x *ListAssetResponse) Reset() { *x = ListAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[10] + mi := &file_taprootassets_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1237,7 +1524,7 @@ func (x *ListAssetResponse) String() string { func (*ListAssetResponse) ProtoMessage() {} func (x *ListAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[10] + mi := &file_taprootassets_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1250,7 +1537,7 @@ func (x *ListAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAssetResponse.ProtoReflect.Descriptor instead. func (*ListAssetResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{10} + return file_taprootassets_proto_rawDescGZIP(), []int{14} } func (x *ListAssetResponse) GetAssets() []*Asset { @@ -1271,7 +1558,7 @@ type ListUtxosRequest struct { func (x *ListUtxosRequest) Reset() { *x = ListUtxosRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[11] + mi := &file_taprootassets_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1284,7 +1571,7 @@ func (x *ListUtxosRequest) String() string { func (*ListUtxosRequest) ProtoMessage() {} func (x *ListUtxosRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[11] + mi := &file_taprootassets_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1297,7 +1584,7 @@ func (x *ListUtxosRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListUtxosRequest.ProtoReflect.Descriptor instead. func (*ListUtxosRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{11} + return file_taprootassets_proto_rawDescGZIP(), []int{15} } func (x *ListUtxosRequest) GetIncludeLeased() bool { @@ -1331,7 +1618,7 @@ type ManagedUtxo struct { func (x *ManagedUtxo) Reset() { *x = ManagedUtxo{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[12] + mi := &file_taprootassets_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1344,7 +1631,7 @@ func (x *ManagedUtxo) String() string { func (*ManagedUtxo) ProtoMessage() {} func (x *ManagedUtxo) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[12] + mi := &file_taprootassets_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1357,7 +1644,7 @@ func (x *ManagedUtxo) ProtoReflect() protoreflect.Message { // Deprecated: Use ManagedUtxo.ProtoReflect.Descriptor instead. func (*ManagedUtxo) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{12} + return file_taprootassets_proto_rawDescGZIP(), []int{16} } func (x *ManagedUtxo) GetOutPoint() string { @@ -1414,7 +1701,7 @@ type ListUtxosResponse struct { func (x *ListUtxosResponse) Reset() { *x = ListUtxosResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[13] + mi := &file_taprootassets_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1427,7 +1714,7 @@ func (x *ListUtxosResponse) String() string { func (*ListUtxosResponse) ProtoMessage() {} func (x *ListUtxosResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[13] + mi := &file_taprootassets_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1440,7 +1727,7 @@ func (x *ListUtxosResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListUtxosResponse.ProtoReflect.Descriptor instead. func (*ListUtxosResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{13} + return file_taprootassets_proto_rawDescGZIP(), []int{17} } func (x *ListUtxosResponse) GetManagedUtxos() map[string]*ManagedUtxo { @@ -1459,7 +1746,7 @@ type ListGroupsRequest struct { func (x *ListGroupsRequest) Reset() { *x = ListGroupsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[14] + mi := &file_taprootassets_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1472,7 +1759,7 @@ func (x *ListGroupsRequest) String() string { func (*ListGroupsRequest) ProtoMessage() {} func (x *ListGroupsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[14] + mi := &file_taprootassets_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1485,7 +1772,7 @@ func (x *ListGroupsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListGroupsRequest.ProtoReflect.Descriptor instead. func (*ListGroupsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{14} + return file_taprootassets_proto_rawDescGZIP(), []int{18} } type AssetHumanReadable struct { @@ -1514,7 +1801,7 @@ type AssetHumanReadable struct { func (x *AssetHumanReadable) Reset() { *x = AssetHumanReadable{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[15] + mi := &file_taprootassets_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1527,7 +1814,7 @@ func (x *AssetHumanReadable) String() string { func (*AssetHumanReadable) ProtoMessage() {} func (x *AssetHumanReadable) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[15] + mi := &file_taprootassets_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1540,7 +1827,7 @@ func (x *AssetHumanReadable) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetHumanReadable.ProtoReflect.Descriptor instead. func (*AssetHumanReadable) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{15} + return file_taprootassets_proto_rawDescGZIP(), []int{19} } func (x *AssetHumanReadable) GetId() []byte { @@ -1611,7 +1898,7 @@ type GroupedAssets struct { func (x *GroupedAssets) Reset() { *x = GroupedAssets{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[16] + mi := &file_taprootassets_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1624,7 +1911,7 @@ func (x *GroupedAssets) String() string { func (*GroupedAssets) ProtoMessage() {} func (x *GroupedAssets) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[16] + mi := &file_taprootassets_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1637,7 +1924,7 @@ func (x *GroupedAssets) ProtoReflect() protoreflect.Message { // Deprecated: Use GroupedAssets.ProtoReflect.Descriptor instead. func (*GroupedAssets) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{16} + return file_taprootassets_proto_rawDescGZIP(), []int{20} } func (x *GroupedAssets) GetAssets() []*AssetHumanReadable { @@ -1659,7 +1946,7 @@ type ListGroupsResponse struct { func (x *ListGroupsResponse) Reset() { *x = ListGroupsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[17] + mi := &file_taprootassets_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1672,7 +1959,7 @@ func (x *ListGroupsResponse) String() string { func (*ListGroupsResponse) ProtoMessage() {} func (x *ListGroupsResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[17] + mi := &file_taprootassets_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1685,7 +1972,7 @@ func (x *ListGroupsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListGroupsResponse.ProtoReflect.Descriptor instead. func (*ListGroupsResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{17} + return file_taprootassets_proto_rawDescGZIP(), []int{21} } func (x *ListGroupsResponse) GetGroups() map[string]*GroupedAssets { @@ -1717,7 +2004,7 @@ type ListBalancesRequest struct { func (x *ListBalancesRequest) Reset() { *x = ListBalancesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[18] + mi := &file_taprootassets_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1730,7 +2017,7 @@ func (x *ListBalancesRequest) String() string { func (*ListBalancesRequest) ProtoMessage() {} func (x *ListBalancesRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[18] + mi := &file_taprootassets_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1743,7 +2030,7 @@ func (x *ListBalancesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBalancesRequest.ProtoReflect.Descriptor instead. func (*ListBalancesRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{18} + return file_taprootassets_proto_rawDescGZIP(), []int{22} } func (m *ListBalancesRequest) GetGroupBy() isListBalancesRequest_GroupBy { @@ -1813,7 +2100,7 @@ type AssetBalance struct { func (x *AssetBalance) Reset() { *x = AssetBalance{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[19] + mi := &file_taprootassets_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1826,7 +2113,7 @@ func (x *AssetBalance) String() string { func (*AssetBalance) ProtoMessage() {} func (x *AssetBalance) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[19] + mi := &file_taprootassets_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1839,7 +2126,7 @@ func (x *AssetBalance) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetBalance.ProtoReflect.Descriptor instead. func (*AssetBalance) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{19} + return file_taprootassets_proto_rawDescGZIP(), []int{23} } func (x *AssetBalance) GetAssetGenesis() *GenesisInfo { @@ -1870,7 +2157,7 @@ type AssetGroupBalance struct { func (x *AssetGroupBalance) Reset() { *x = AssetGroupBalance{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[20] + mi := &file_taprootassets_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1883,7 +2170,7 @@ func (x *AssetGroupBalance) String() string { func (*AssetGroupBalance) ProtoMessage() {} func (x *AssetGroupBalance) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[20] + mi := &file_taprootassets_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1896,7 +2183,7 @@ func (x *AssetGroupBalance) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetGroupBalance.ProtoReflect.Descriptor instead. func (*AssetGroupBalance) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{20} + return file_taprootassets_proto_rawDescGZIP(), []int{24} } func (x *AssetGroupBalance) GetGroupKey() []byte { @@ -1925,7 +2212,7 @@ type ListBalancesResponse struct { func (x *ListBalancesResponse) Reset() { *x = ListBalancesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[21] + mi := &file_taprootassets_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1938,7 +2225,7 @@ func (x *ListBalancesResponse) String() string { func (*ListBalancesResponse) ProtoMessage() {} func (x *ListBalancesResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[21] + mi := &file_taprootassets_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1951,7 +2238,7 @@ func (x *ListBalancesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListBalancesResponse.ProtoReflect.Descriptor instead. func (*ListBalancesResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{21} + return file_taprootassets_proto_rawDescGZIP(), []int{25} } func (x *ListBalancesResponse) GetAssetBalances() map[string]*AssetBalance { @@ -1982,7 +2269,7 @@ type ListTransfersRequest struct { func (x *ListTransfersRequest) Reset() { *x = ListTransfersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[22] + mi := &file_taprootassets_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1995,7 +2282,7 @@ func (x *ListTransfersRequest) String() string { func (*ListTransfersRequest) ProtoMessage() {} func (x *ListTransfersRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[22] + mi := &file_taprootassets_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2008,7 +2295,7 @@ func (x *ListTransfersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTransfersRequest.ProtoReflect.Descriptor instead. func (*ListTransfersRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{22} + return file_taprootassets_proto_rawDescGZIP(), []int{26} } func (x *ListTransfersRequest) GetAnchorTxid() string { @@ -2030,7 +2317,7 @@ type ListTransfersResponse struct { func (x *ListTransfersResponse) Reset() { *x = ListTransfersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[23] + mi := &file_taprootassets_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2043,7 +2330,7 @@ func (x *ListTransfersResponse) String() string { func (*ListTransfersResponse) ProtoMessage() {} func (x *ListTransfersResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[23] + mi := &file_taprootassets_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2056,7 +2343,7 @@ func (x *ListTransfersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTransfersResponse.ProtoReflect.Descriptor instead. func (*ListTransfersResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{23} + return file_taprootassets_proto_rawDescGZIP(), []int{27} } func (x *ListTransfersResponse) GetTransfers() []*AssetTransfer { @@ -2086,7 +2373,7 @@ type AssetTransfer struct { func (x *AssetTransfer) Reset() { *x = AssetTransfer{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[24] + mi := &file_taprootassets_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2099,7 +2386,7 @@ func (x *AssetTransfer) String() string { func (*AssetTransfer) ProtoMessage() {} func (x *AssetTransfer) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[24] + mi := &file_taprootassets_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2112,7 +2399,7 @@ func (x *AssetTransfer) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetTransfer.ProtoReflect.Descriptor instead. func (*AssetTransfer) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{24} + return file_taprootassets_proto_rawDescGZIP(), []int{28} } func (x *AssetTransfer) GetTransferTimestamp() int64 { @@ -2176,7 +2463,7 @@ type TransferInput struct { func (x *TransferInput) Reset() { *x = TransferInput{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[25] + mi := &file_taprootassets_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2189,7 +2476,7 @@ func (x *TransferInput) String() string { func (*TransferInput) ProtoMessage() {} func (x *TransferInput) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[25] + mi := &file_taprootassets_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2202,7 +2489,7 @@ func (x *TransferInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferInput.ProtoReflect.Descriptor instead. func (*TransferInput) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{25} + return file_taprootassets_proto_rawDescGZIP(), []int{29} } func (x *TransferInput) GetAnchorPoint() string { @@ -2252,7 +2539,7 @@ type TransferOutputAnchor struct { func (x *TransferOutputAnchor) Reset() { *x = TransferOutputAnchor{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[26] + mi := &file_taprootassets_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2265,7 +2552,7 @@ func (x *TransferOutputAnchor) String() string { func (*TransferOutputAnchor) ProtoMessage() {} func (x *TransferOutputAnchor) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[26] + mi := &file_taprootassets_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2278,7 +2565,7 @@ func (x *TransferOutputAnchor) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferOutputAnchor.ProtoReflect.Descriptor instead. func (*TransferOutputAnchor) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{26} + return file_taprootassets_proto_rawDescGZIP(), []int{30} } func (x *TransferOutputAnchor) GetOutpoint() string { @@ -2350,7 +2637,7 @@ type TransferOutput struct { func (x *TransferOutput) Reset() { *x = TransferOutput{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[27] + mi := &file_taprootassets_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2363,7 +2650,7 @@ func (x *TransferOutput) String() string { func (*TransferOutput) ProtoMessage() {} func (x *TransferOutput) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[27] + mi := &file_taprootassets_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2376,7 +2663,7 @@ func (x *TransferOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferOutput.ProtoReflect.Descriptor instead. func (*TransferOutput) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{27} + return file_taprootassets_proto_rawDescGZIP(), []int{31} } func (x *TransferOutput) GetAnchor() *TransferOutputAnchor { @@ -2444,7 +2731,7 @@ type StopRequest struct { func (x *StopRequest) Reset() { *x = StopRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[28] + mi := &file_taprootassets_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2457,7 +2744,7 @@ func (x *StopRequest) String() string { func (*StopRequest) ProtoMessage() {} func (x *StopRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[28] + mi := &file_taprootassets_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2470,7 +2757,7 @@ func (x *StopRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopRequest.ProtoReflect.Descriptor instead. func (*StopRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{28} + return file_taprootassets_proto_rawDescGZIP(), []int{32} } type StopResponse struct { @@ -2482,7 +2769,7 @@ type StopResponse struct { func (x *StopResponse) Reset() { *x = StopResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[29] + mi := &file_taprootassets_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2495,7 +2782,7 @@ func (x *StopResponse) String() string { func (*StopResponse) ProtoMessage() {} func (x *StopResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[29] + mi := &file_taprootassets_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2508,7 +2795,7 @@ func (x *StopResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StopResponse.ProtoReflect.Descriptor instead. func (*StopResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{29} + return file_taprootassets_proto_rawDescGZIP(), []int{33} } type DebugLevelRequest struct { @@ -2524,7 +2811,7 @@ type DebugLevelRequest struct { func (x *DebugLevelRequest) Reset() { *x = DebugLevelRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[30] + mi := &file_taprootassets_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2537,7 +2824,7 @@ func (x *DebugLevelRequest) String() string { func (*DebugLevelRequest) ProtoMessage() {} func (x *DebugLevelRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[30] + mi := &file_taprootassets_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2550,7 +2837,7 @@ func (x *DebugLevelRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugLevelRequest.ProtoReflect.Descriptor instead. func (*DebugLevelRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{30} + return file_taprootassets_proto_rawDescGZIP(), []int{34} } func (x *DebugLevelRequest) GetShow() bool { @@ -2578,7 +2865,7 @@ type DebugLevelResponse struct { func (x *DebugLevelResponse) Reset() { *x = DebugLevelResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[31] + mi := &file_taprootassets_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2591,7 +2878,7 @@ func (x *DebugLevelResponse) String() string { func (*DebugLevelResponse) ProtoMessage() {} func (x *DebugLevelResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[31] + mi := &file_taprootassets_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2604,7 +2891,7 @@ func (x *DebugLevelResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugLevelResponse.ProtoReflect.Descriptor instead. func (*DebugLevelResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{31} + return file_taprootassets_proto_rawDescGZIP(), []int{35} } func (x *DebugLevelResponse) GetSubSystems() string { @@ -2652,7 +2939,7 @@ type Addr struct { func (x *Addr) Reset() { *x = Addr{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[32] + mi := &file_taprootassets_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2665,7 +2952,7 @@ func (x *Addr) String() string { func (*Addr) ProtoMessage() {} func (x *Addr) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[32] + mi := &file_taprootassets_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2678,7 +2965,7 @@ func (x *Addr) ProtoReflect() protoreflect.Message { // Deprecated: Use Addr.ProtoReflect.Descriptor instead. func (*Addr) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{32} + return file_taprootassets_proto_rawDescGZIP(), []int{36} } func (x *Addr) GetEncoded() string { @@ -2778,7 +3065,7 @@ type QueryAddrRequest struct { func (x *QueryAddrRequest) Reset() { *x = QueryAddrRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[33] + mi := &file_taprootassets_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2791,7 +3078,7 @@ func (x *QueryAddrRequest) String() string { func (*QueryAddrRequest) ProtoMessage() {} func (x *QueryAddrRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[33] + mi := &file_taprootassets_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2804,7 +3091,7 @@ func (x *QueryAddrRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAddrRequest.ProtoReflect.Descriptor instead. func (*QueryAddrRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{33} + return file_taprootassets_proto_rawDescGZIP(), []int{37} } func (x *QueryAddrRequest) GetCreatedAfter() int64 { @@ -2846,7 +3133,7 @@ type QueryAddrResponse struct { func (x *QueryAddrResponse) Reset() { *x = QueryAddrResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[34] + mi := &file_taprootassets_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2859,7 +3146,7 @@ func (x *QueryAddrResponse) String() string { func (*QueryAddrResponse) ProtoMessage() {} func (x *QueryAddrResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[34] + mi := &file_taprootassets_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2872,7 +3159,7 @@ func (x *QueryAddrResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAddrResponse.ProtoReflect.Descriptor instead. func (*QueryAddrResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{34} + return file_taprootassets_proto_rawDescGZIP(), []int{38} } func (x *QueryAddrResponse) GetAddrs() []*Addr { @@ -2918,7 +3205,7 @@ type NewAddrRequest struct { func (x *NewAddrRequest) Reset() { *x = NewAddrRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[35] + mi := &file_taprootassets_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2931,7 +3218,7 @@ func (x *NewAddrRequest) String() string { func (*NewAddrRequest) ProtoMessage() {} func (x *NewAddrRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[35] + mi := &file_taprootassets_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2944,7 +3231,7 @@ func (x *NewAddrRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use NewAddrRequest.ProtoReflect.Descriptor instead. func (*NewAddrRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{35} + return file_taprootassets_proto_rawDescGZIP(), []int{39} } func (x *NewAddrRequest) GetAssetId() []byte { @@ -3015,7 +3302,7 @@ type ScriptKey struct { func (x *ScriptKey) Reset() { *x = ScriptKey{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[36] + mi := &file_taprootassets_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3028,7 +3315,7 @@ func (x *ScriptKey) String() string { func (*ScriptKey) ProtoMessage() {} func (x *ScriptKey) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[36] + mi := &file_taprootassets_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3041,7 +3328,7 @@ func (x *ScriptKey) ProtoReflect() protoreflect.Message { // Deprecated: Use ScriptKey.ProtoReflect.Descriptor instead. func (*ScriptKey) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{36} + return file_taprootassets_proto_rawDescGZIP(), []int{40} } func (x *ScriptKey) GetPubKey() []byte { @@ -3079,7 +3366,7 @@ type KeyLocator struct { func (x *KeyLocator) Reset() { *x = KeyLocator{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[37] + mi := &file_taprootassets_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3092,7 +3379,7 @@ func (x *KeyLocator) String() string { func (*KeyLocator) ProtoMessage() {} func (x *KeyLocator) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[37] + mi := &file_taprootassets_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3105,7 +3392,7 @@ func (x *KeyLocator) ProtoReflect() protoreflect.Message { // Deprecated: Use KeyLocator.ProtoReflect.Descriptor instead. func (*KeyLocator) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{37} + return file_taprootassets_proto_rawDescGZIP(), []int{41} } func (x *KeyLocator) GetKeyFamily() int32 { @@ -3136,7 +3423,7 @@ type KeyDescriptor struct { func (x *KeyDescriptor) Reset() { *x = KeyDescriptor{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[38] + mi := &file_taprootassets_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3149,7 +3436,7 @@ func (x *KeyDescriptor) String() string { func (*KeyDescriptor) ProtoMessage() {} func (x *KeyDescriptor) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[38] + mi := &file_taprootassets_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3162,7 +3449,7 @@ func (x *KeyDescriptor) ProtoReflect() protoreflect.Message { // Deprecated: Use KeyDescriptor.ProtoReflect.Descriptor instead. func (*KeyDescriptor) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{38} + return file_taprootassets_proto_rawDescGZIP(), []int{42} } func (x *KeyDescriptor) GetRawKeyBytes() []byte { @@ -3191,7 +3478,7 @@ type TapscriptFullTree struct { func (x *TapscriptFullTree) Reset() { *x = TapscriptFullTree{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[39] + mi := &file_taprootassets_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3204,7 +3491,7 @@ func (x *TapscriptFullTree) String() string { func (*TapscriptFullTree) ProtoMessage() {} func (x *TapscriptFullTree) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[39] + mi := &file_taprootassets_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3217,7 +3504,7 @@ func (x *TapscriptFullTree) ProtoReflect() protoreflect.Message { // Deprecated: Use TapscriptFullTree.ProtoReflect.Descriptor instead. func (*TapscriptFullTree) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{39} + return file_taprootassets_proto_rawDescGZIP(), []int{43} } func (x *TapscriptFullTree) GetAllLeaves() []*TapLeaf { @@ -3239,7 +3526,7 @@ type TapLeaf struct { func (x *TapLeaf) Reset() { *x = TapLeaf{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[40] + mi := &file_taprootassets_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3252,7 +3539,7 @@ func (x *TapLeaf) String() string { func (*TapLeaf) ProtoMessage() {} func (x *TapLeaf) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[40] + mi := &file_taprootassets_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3265,7 +3552,7 @@ func (x *TapLeaf) ProtoReflect() protoreflect.Message { // Deprecated: Use TapLeaf.ProtoReflect.Descriptor instead. func (*TapLeaf) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{40} + return file_taprootassets_proto_rawDescGZIP(), []int{44} } func (x *TapLeaf) GetScript() []byte { @@ -3289,7 +3576,7 @@ type TapBranch struct { func (x *TapBranch) Reset() { *x = TapBranch{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[41] + mi := &file_taprootassets_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3302,7 +3589,7 @@ func (x *TapBranch) String() string { func (*TapBranch) ProtoMessage() {} func (x *TapBranch) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[41] + mi := &file_taprootassets_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3315,7 +3602,7 @@ func (x *TapBranch) ProtoReflect() protoreflect.Message { // Deprecated: Use TapBranch.ProtoReflect.Descriptor instead. func (*TapBranch) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{41} + return file_taprootassets_proto_rawDescGZIP(), []int{45} } func (x *TapBranch) GetLeftTaphash() []byte { @@ -3343,7 +3630,7 @@ type DecodeAddrRequest struct { func (x *DecodeAddrRequest) Reset() { *x = DecodeAddrRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[42] + mi := &file_taprootassets_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3356,7 +3643,7 @@ func (x *DecodeAddrRequest) String() string { func (*DecodeAddrRequest) ProtoMessage() {} func (x *DecodeAddrRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[42] + mi := &file_taprootassets_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3369,7 +3656,7 @@ func (x *DecodeAddrRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodeAddrRequest.ProtoReflect.Descriptor instead. func (*DecodeAddrRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{42} + return file_taprootassets_proto_rawDescGZIP(), []int{46} } func (x *DecodeAddrRequest) GetAddr() string { @@ -3393,7 +3680,7 @@ type ProofFile struct { func (x *ProofFile) Reset() { *x = ProofFile{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[43] + mi := &file_taprootassets_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3406,7 +3693,7 @@ func (x *ProofFile) String() string { func (*ProofFile) ProtoMessage() {} func (x *ProofFile) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[43] + mi := &file_taprootassets_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3419,7 +3706,7 @@ func (x *ProofFile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProofFile.ProtoReflect.Descriptor instead. func (*ProofFile) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{43} + return file_taprootassets_proto_rawDescGZIP(), []int{47} } func (x *ProofFile) GetRawProofFile() []byte { @@ -3489,7 +3776,7 @@ type DecodedProof struct { func (x *DecodedProof) Reset() { *x = DecodedProof{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[44] + mi := &file_taprootassets_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3502,7 +3789,7 @@ func (x *DecodedProof) String() string { func (*DecodedProof) ProtoMessage() {} func (x *DecodedProof) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[44] + mi := &file_taprootassets_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3515,7 +3802,7 @@ func (x *DecodedProof) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodedProof.ProtoReflect.Descriptor instead. func (*DecodedProof) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{44} + return file_taprootassets_proto_rawDescGZIP(), []int{48} } func (x *DecodedProof) GetProofAtDepth() uint32 { @@ -3622,7 +3909,7 @@ type VerifyProofResponse struct { func (x *VerifyProofResponse) Reset() { *x = VerifyProofResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[45] + mi := &file_taprootassets_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3635,7 +3922,7 @@ func (x *VerifyProofResponse) String() string { func (*VerifyProofResponse) ProtoMessage() {} func (x *VerifyProofResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[45] + mi := &file_taprootassets_proto_msgTypes[49] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3648,7 +3935,7 @@ func (x *VerifyProofResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VerifyProofResponse.ProtoReflect.Descriptor instead. func (*VerifyProofResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{45} + return file_taprootassets_proto_rawDescGZIP(), []int{49} } func (x *VerifyProofResponse) GetValid() bool { @@ -3688,7 +3975,7 @@ type DecodeProofRequest struct { func (x *DecodeProofRequest) Reset() { *x = DecodeProofRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[46] + mi := &file_taprootassets_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3701,7 +3988,7 @@ func (x *DecodeProofRequest) String() string { func (*DecodeProofRequest) ProtoMessage() {} func (x *DecodeProofRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[46] + mi := &file_taprootassets_proto_msgTypes[50] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3714,7 +4001,7 @@ func (x *DecodeProofRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodeProofRequest.ProtoReflect.Descriptor instead. func (*DecodeProofRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{46} + return file_taprootassets_proto_rawDescGZIP(), []int{50} } func (x *DecodeProofRequest) GetRawProof() []byte { @@ -3756,7 +4043,7 @@ type DecodeProofResponse struct { func (x *DecodeProofResponse) Reset() { *x = DecodeProofResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[47] + mi := &file_taprootassets_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3769,7 +4056,7 @@ func (x *DecodeProofResponse) String() string { func (*DecodeProofResponse) ProtoMessage() {} func (x *DecodeProofResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[47] + mi := &file_taprootassets_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3782,7 +4069,7 @@ func (x *DecodeProofResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DecodeProofResponse.ProtoReflect.Descriptor instead. func (*DecodeProofResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{47} + return file_taprootassets_proto_rawDescGZIP(), []int{51} } func (x *DecodeProofResponse) GetDecodedProof() *DecodedProof { @@ -3805,7 +4092,7 @@ type ExportProofRequest struct { func (x *ExportProofRequest) Reset() { *x = ExportProofRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[48] + mi := &file_taprootassets_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3818,7 +4105,7 @@ func (x *ExportProofRequest) String() string { func (*ExportProofRequest) ProtoMessage() {} func (x *ExportProofRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[48] + mi := &file_taprootassets_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3831,7 +4118,7 @@ func (x *ExportProofRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExportProofRequest.ProtoReflect.Descriptor instead. func (*ExportProofRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{48} + return file_taprootassets_proto_rawDescGZIP(), []int{52} } func (x *ExportProofRequest) GetAssetId() []byte { @@ -3885,7 +4172,7 @@ type AddrEvent struct { func (x *AddrEvent) Reset() { *x = AddrEvent{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[49] + mi := &file_taprootassets_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3898,7 +4185,7 @@ func (x *AddrEvent) String() string { func (*AddrEvent) ProtoMessage() {} func (x *AddrEvent) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[49] + mi := &file_taprootassets_proto_msgTypes[53] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3911,7 +4198,7 @@ func (x *AddrEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use AddrEvent.ProtoReflect.Descriptor instead. func (*AddrEvent) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{49} + return file_taprootassets_proto_rawDescGZIP(), []int{53} } func (x *AddrEvent) GetCreationTimeUnixSeconds() uint64 { @@ -3984,7 +4271,7 @@ type AddrReceivesRequest struct { func (x *AddrReceivesRequest) Reset() { *x = AddrReceivesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[50] + mi := &file_taprootassets_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3997,7 +4284,7 @@ func (x *AddrReceivesRequest) String() string { func (*AddrReceivesRequest) ProtoMessage() {} func (x *AddrReceivesRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[50] + mi := &file_taprootassets_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4010,7 +4297,7 @@ func (x *AddrReceivesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddrReceivesRequest.ProtoReflect.Descriptor instead. func (*AddrReceivesRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{50} + return file_taprootassets_proto_rawDescGZIP(), []int{54} } func (x *AddrReceivesRequest) GetFilterAddr() string { @@ -4039,7 +4326,7 @@ type AddrReceivesResponse struct { func (x *AddrReceivesResponse) Reset() { *x = AddrReceivesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[51] + mi := &file_taprootassets_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4052,7 +4339,7 @@ func (x *AddrReceivesResponse) String() string { func (*AddrReceivesResponse) ProtoMessage() {} func (x *AddrReceivesResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[51] + mi := &file_taprootassets_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4065,7 +4352,7 @@ func (x *AddrReceivesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddrReceivesResponse.ProtoReflect.Descriptor instead. func (*AddrReceivesResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{51} + return file_taprootassets_proto_rawDescGZIP(), []int{55} } func (x *AddrReceivesResponse) GetEvents() []*AddrEvent { @@ -4088,7 +4375,7 @@ type SendAssetRequest struct { func (x *SendAssetRequest) Reset() { *x = SendAssetRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[52] + mi := &file_taprootassets_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4101,7 +4388,7 @@ func (x *SendAssetRequest) String() string { func (*SendAssetRequest) ProtoMessage() {} func (x *SendAssetRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[52] + mi := &file_taprootassets_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4114,7 +4401,7 @@ func (x *SendAssetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SendAssetRequest.ProtoReflect.Descriptor instead. func (*SendAssetRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{52} + return file_taprootassets_proto_rawDescGZIP(), []int{56} } func (x *SendAssetRequest) GetTapAddrs() []string { @@ -4145,7 +4432,7 @@ type PrevInputAsset struct { func (x *PrevInputAsset) Reset() { *x = PrevInputAsset{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[53] + mi := &file_taprootassets_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4158,7 +4445,7 @@ func (x *PrevInputAsset) String() string { func (*PrevInputAsset) ProtoMessage() {} func (x *PrevInputAsset) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[53] + mi := &file_taprootassets_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4171,7 +4458,7 @@ func (x *PrevInputAsset) ProtoReflect() protoreflect.Message { // Deprecated: Use PrevInputAsset.ProtoReflect.Descriptor instead. func (*PrevInputAsset) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{53} + return file_taprootassets_proto_rawDescGZIP(), []int{57} } func (x *PrevInputAsset) GetAnchorPoint() string { @@ -4213,7 +4500,7 @@ type SendAssetResponse struct { func (x *SendAssetResponse) Reset() { *x = SendAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[54] + mi := &file_taprootassets_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4226,7 +4513,7 @@ func (x *SendAssetResponse) String() string { func (*SendAssetResponse) ProtoMessage() {} func (x *SendAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[54] + mi := &file_taprootassets_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4239,7 +4526,7 @@ func (x *SendAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SendAssetResponse.ProtoReflect.Descriptor instead. func (*SendAssetResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{54} + return file_taprootassets_proto_rawDescGZIP(), []int{58} } func (x *SendAssetResponse) GetTransfer() *AssetTransfer { @@ -4258,7 +4545,7 @@ type GetInfoRequest struct { func (x *GetInfoRequest) Reset() { *x = GetInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[55] + mi := &file_taprootassets_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4271,7 +4558,7 @@ func (x *GetInfoRequest) String() string { func (*GetInfoRequest) ProtoMessage() {} func (x *GetInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[55] + mi := &file_taprootassets_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4284,7 +4571,7 @@ func (x *GetInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetInfoRequest.ProtoReflect.Descriptor instead. func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{55} + return file_taprootassets_proto_rawDescGZIP(), []int{59} } type GetInfoResponse struct { @@ -4305,7 +4592,7 @@ type GetInfoResponse struct { func (x *GetInfoResponse) Reset() { *x = GetInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[56] + mi := &file_taprootassets_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4318,7 +4605,7 @@ func (x *GetInfoResponse) String() string { func (*GetInfoResponse) ProtoMessage() {} func (x *GetInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[56] + mi := &file_taprootassets_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4331,7 +4618,7 @@ func (x *GetInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetInfoResponse.ProtoReflect.Descriptor instead. func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{56} + return file_taprootassets_proto_rawDescGZIP(), []int{60} } func (x *GetInfoResponse) GetVersion() string { @@ -4407,7 +4694,7 @@ type FetchAssetMetaRequest struct { func (x *FetchAssetMetaRequest) Reset() { *x = FetchAssetMetaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[57] + mi := &file_taprootassets_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4420,7 +4707,7 @@ func (x *FetchAssetMetaRequest) String() string { func (*FetchAssetMetaRequest) ProtoMessage() {} func (x *FetchAssetMetaRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[57] + mi := &file_taprootassets_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4433,7 +4720,7 @@ func (x *FetchAssetMetaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FetchAssetMetaRequest.ProtoReflect.Descriptor instead. func (*FetchAssetMetaRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{57} + return file_taprootassets_proto_rawDescGZIP(), []int{61} } func (m *FetchAssetMetaRequest) GetAsset() isFetchAssetMetaRequest_Asset { @@ -4523,7 +4810,7 @@ type BurnAssetRequest struct { func (x *BurnAssetRequest) Reset() { *x = BurnAssetRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[58] + mi := &file_taprootassets_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4536,7 +4823,7 @@ func (x *BurnAssetRequest) String() string { func (*BurnAssetRequest) ProtoMessage() {} func (x *BurnAssetRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[58] + mi := &file_taprootassets_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4549,7 +4836,7 @@ func (x *BurnAssetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BurnAssetRequest.ProtoReflect.Descriptor instead. func (*BurnAssetRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{58} + return file_taprootassets_proto_rawDescGZIP(), []int{62} } func (m *BurnAssetRequest) GetAsset() isBurnAssetRequest_Asset { @@ -4619,7 +4906,7 @@ type BurnAssetResponse struct { func (x *BurnAssetResponse) Reset() { *x = BurnAssetResponse{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[59] + mi := &file_taprootassets_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4632,7 +4919,7 @@ func (x *BurnAssetResponse) String() string { func (*BurnAssetResponse) ProtoMessage() {} func (x *BurnAssetResponse) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[59] + mi := &file_taprootassets_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4645,7 +4932,7 @@ func (x *BurnAssetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BurnAssetResponse.ProtoReflect.Descriptor instead. func (*BurnAssetResponse) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{59} + return file_taprootassets_proto_rawDescGZIP(), []int{63} } func (x *BurnAssetResponse) GetBurnTransfer() *AssetTransfer { @@ -4676,7 +4963,7 @@ type OutPoint struct { func (x *OutPoint) Reset() { *x = OutPoint{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[60] + mi := &file_taprootassets_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4689,7 +4976,7 @@ func (x *OutPoint) String() string { func (*OutPoint) ProtoMessage() {} func (x *OutPoint) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[60] + mi := &file_taprootassets_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4702,7 +4989,7 @@ func (x *OutPoint) ProtoReflect() protoreflect.Message { // Deprecated: Use OutPoint.ProtoReflect.Descriptor instead. func (*OutPoint) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{60} + return file_taprootassets_proto_rawDescGZIP(), []int{64} } func (x *OutPoint) GetTxid() []byte { @@ -4735,7 +5022,7 @@ type SubscribeReceiveEventsRequest struct { func (x *SubscribeReceiveEventsRequest) Reset() { *x = SubscribeReceiveEventsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[61] + mi := &file_taprootassets_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4748,7 +5035,7 @@ func (x *SubscribeReceiveEventsRequest) String() string { func (*SubscribeReceiveEventsRequest) ProtoMessage() {} func (x *SubscribeReceiveEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[61] + mi := &file_taprootassets_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4761,7 +5048,7 @@ func (x *SubscribeReceiveEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubscribeReceiveEventsRequest.ProtoReflect.Descriptor instead. func (*SubscribeReceiveEventsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{61} + return file_taprootassets_proto_rawDescGZIP(), []int{65} } func (x *SubscribeReceiveEventsRequest) GetFilterAddr() string { @@ -4803,7 +5090,7 @@ type ReceiveEvent struct { func (x *ReceiveEvent) Reset() { *x = ReceiveEvent{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[62] + mi := &file_taprootassets_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4816,7 +5103,7 @@ func (x *ReceiveEvent) String() string { func (*ReceiveEvent) ProtoMessage() {} func (x *ReceiveEvent) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[62] + mi := &file_taprootassets_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4829,7 +5116,7 @@ func (x *ReceiveEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ReceiveEvent.ProtoReflect.Descriptor instead. func (*ReceiveEvent) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{62} + return file_taprootassets_proto_rawDescGZIP(), []int{66} } func (x *ReceiveEvent) GetTimestamp() int64 { @@ -4887,7 +5174,7 @@ type SubscribeSendEventsRequest struct { func (x *SubscribeSendEventsRequest) Reset() { *x = SubscribeSendEventsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[63] + mi := &file_taprootassets_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4900,7 +5187,7 @@ func (x *SubscribeSendEventsRequest) String() string { func (*SubscribeSendEventsRequest) ProtoMessage() {} func (x *SubscribeSendEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[63] + mi := &file_taprootassets_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4913,7 +5200,7 @@ func (x *SubscribeSendEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubscribeSendEventsRequest.ProtoReflect.Descriptor instead. func (*SubscribeSendEventsRequest) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{63} + return file_taprootassets_proto_rawDescGZIP(), []int{67} } func (x *SubscribeSendEventsRequest) GetFilterScriptKey() []byte { @@ -4959,7 +5246,7 @@ type SendEvent struct { func (x *SendEvent) Reset() { *x = SendEvent{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[64] + mi := &file_taprootassets_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4972,7 +5259,7 @@ func (x *SendEvent) String() string { func (*SendEvent) ProtoMessage() {} func (x *SendEvent) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[64] + mi := &file_taprootassets_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4985,7 +5272,7 @@ func (x *SendEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SendEvent.ProtoReflect.Descriptor instead. func (*SendEvent) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{64} + return file_taprootassets_proto_rawDescGZIP(), []int{68} } func (x *SendEvent) GetTimestamp() int64 { @@ -5075,7 +5362,7 @@ type AnchorTransaction struct { func (x *AnchorTransaction) Reset() { *x = AnchorTransaction{} if protoimpl.UnsafeEnabled { - mi := &file_taprootassets_proto_msgTypes[65] + mi := &file_taprootassets_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5088,7 +5375,7 @@ func (x *AnchorTransaction) String() string { func (*AnchorTransaction) ProtoMessage() {} func (x *AnchorTransaction) ProtoReflect() protoreflect.Message { - mi := &file_taprootassets_proto_msgTypes[65] + mi := &file_taprootassets_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5101,7 +5388,7 @@ func (x *AnchorTransaction) ProtoReflect() protoreflect.Message { // Deprecated: Use AnchorTransaction.ProtoReflect.Descriptor instead. func (*AnchorTransaction) Descriptor() ([]byte, []int) { - return file_taprootassets_proto_rawDescGZIP(), []int{65} + return file_taprootassets_proto_rawDescGZIP(), []int{69} } func (x *AnchorTransaction) GetAnchorPsbt() []byte { @@ -5196,760 +5483,793 @@ var file_taprootassets_proto_rawDesc = []byte{ 0x73, 0x65, 0x74, 0x54, 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, 0x81, 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, 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, 0xe9, 0x04, 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, 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, 0x3a, 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, + 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, 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, 0xe9, 0x04, 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, 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, 0x06, 0x61, 0x73, 0x73, 0x65, 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, 0xdc, 0x01, 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, 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, 0xaa, 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, 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, 0xa9, 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, 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, + 0x74, 0x52, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x22, 0x3a, 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, 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, 0xdc, 0x01, 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, 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, 0xf7, 0x02, 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, + 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, 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, 0xaa, 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, 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, 0xa9, 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, 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, 0xf7, 0x02, 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, 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, 0xa8, 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, 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, - 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, 0xa8, - 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, 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, 0xbf, 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, 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, 0xd7, 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, 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, + 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, 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, 0xbf, 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, 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, 0xd7, 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, 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, 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, 0xaf, 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, 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, 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, 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, 0xaf, 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, 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, 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, + 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x09, 0x62, 0x75, 0x72, 0x6e, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 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, 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, 0x5a, 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, + 0x32, 0xd8, 0x0a, 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, 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, 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, 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, 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, 0x5a, 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, 0x32, 0xd8, 0x0a, 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, 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, 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, + 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, } var ( @@ -5965,7 +6285,7 @@ func file_taprootassets_proto_rawDescGZIP() []byte { } var file_taprootassets_proto_enumTypes = make([]protoimpl.EnumInfo, 7) -var file_taprootassets_proto_msgTypes = make([]protoimpl.MessageInfo, 70) +var file_taprootassets_proto_msgTypes = make([]protoimpl.MessageInfo, 74) var file_taprootassets_proto_goTypes = []interface{}{ (AssetType)(0), // 0: taprpc.AssetType (AssetMetaType)(0), // 1: taprpc.AssetMetaType @@ -5978,180 +6298,187 @@ var file_taprootassets_proto_goTypes = []interface{}{ (*ListAssetRequest)(nil), // 8: taprpc.ListAssetRequest (*AnchorInfo)(nil), // 9: taprpc.AnchorInfo (*GenesisInfo)(nil), // 10: taprpc.GenesisInfo - (*AssetGroup)(nil), // 11: taprpc.AssetGroup - (*GroupKeyReveal)(nil), // 12: taprpc.GroupKeyReveal - (*GenesisReveal)(nil), // 13: taprpc.GenesisReveal - (*Asset)(nil), // 14: taprpc.Asset - (*PrevWitness)(nil), // 15: taprpc.PrevWitness - (*SplitCommitment)(nil), // 16: taprpc.SplitCommitment - (*ListAssetResponse)(nil), // 17: taprpc.ListAssetResponse - (*ListUtxosRequest)(nil), // 18: taprpc.ListUtxosRequest - (*ManagedUtxo)(nil), // 19: taprpc.ManagedUtxo - (*ListUtxosResponse)(nil), // 20: taprpc.ListUtxosResponse - (*ListGroupsRequest)(nil), // 21: taprpc.ListGroupsRequest - (*AssetHumanReadable)(nil), // 22: taprpc.AssetHumanReadable - (*GroupedAssets)(nil), // 23: taprpc.GroupedAssets - (*ListGroupsResponse)(nil), // 24: taprpc.ListGroupsResponse - (*ListBalancesRequest)(nil), // 25: taprpc.ListBalancesRequest - (*AssetBalance)(nil), // 26: taprpc.AssetBalance - (*AssetGroupBalance)(nil), // 27: taprpc.AssetGroupBalance - (*ListBalancesResponse)(nil), // 28: taprpc.ListBalancesResponse - (*ListTransfersRequest)(nil), // 29: taprpc.ListTransfersRequest - (*ListTransfersResponse)(nil), // 30: taprpc.ListTransfersResponse - (*AssetTransfer)(nil), // 31: taprpc.AssetTransfer - (*TransferInput)(nil), // 32: taprpc.TransferInput - (*TransferOutputAnchor)(nil), // 33: taprpc.TransferOutputAnchor - (*TransferOutput)(nil), // 34: taprpc.TransferOutput - (*StopRequest)(nil), // 35: taprpc.StopRequest - (*StopResponse)(nil), // 36: taprpc.StopResponse - (*DebugLevelRequest)(nil), // 37: taprpc.DebugLevelRequest - (*DebugLevelResponse)(nil), // 38: taprpc.DebugLevelResponse - (*Addr)(nil), // 39: taprpc.Addr - (*QueryAddrRequest)(nil), // 40: taprpc.QueryAddrRequest - (*QueryAddrResponse)(nil), // 41: taprpc.QueryAddrResponse - (*NewAddrRequest)(nil), // 42: taprpc.NewAddrRequest - (*ScriptKey)(nil), // 43: taprpc.ScriptKey - (*KeyLocator)(nil), // 44: taprpc.KeyLocator - (*KeyDescriptor)(nil), // 45: taprpc.KeyDescriptor - (*TapscriptFullTree)(nil), // 46: taprpc.TapscriptFullTree - (*TapLeaf)(nil), // 47: taprpc.TapLeaf - (*TapBranch)(nil), // 48: taprpc.TapBranch - (*DecodeAddrRequest)(nil), // 49: taprpc.DecodeAddrRequest - (*ProofFile)(nil), // 50: taprpc.ProofFile - (*DecodedProof)(nil), // 51: taprpc.DecodedProof - (*VerifyProofResponse)(nil), // 52: taprpc.VerifyProofResponse - (*DecodeProofRequest)(nil), // 53: taprpc.DecodeProofRequest - (*DecodeProofResponse)(nil), // 54: taprpc.DecodeProofResponse - (*ExportProofRequest)(nil), // 55: taprpc.ExportProofRequest - (*AddrEvent)(nil), // 56: taprpc.AddrEvent - (*AddrReceivesRequest)(nil), // 57: taprpc.AddrReceivesRequest - (*AddrReceivesResponse)(nil), // 58: taprpc.AddrReceivesResponse - (*SendAssetRequest)(nil), // 59: taprpc.SendAssetRequest - (*PrevInputAsset)(nil), // 60: taprpc.PrevInputAsset - (*SendAssetResponse)(nil), // 61: taprpc.SendAssetResponse - (*GetInfoRequest)(nil), // 62: taprpc.GetInfoRequest - (*GetInfoResponse)(nil), // 63: taprpc.GetInfoResponse - (*FetchAssetMetaRequest)(nil), // 64: taprpc.FetchAssetMetaRequest - (*BurnAssetRequest)(nil), // 65: taprpc.BurnAssetRequest - (*BurnAssetResponse)(nil), // 66: taprpc.BurnAssetResponse - (*OutPoint)(nil), // 67: taprpc.OutPoint - (*SubscribeReceiveEventsRequest)(nil), // 68: taprpc.SubscribeReceiveEventsRequest - (*ReceiveEvent)(nil), // 69: taprpc.ReceiveEvent - (*SubscribeSendEventsRequest)(nil), // 70: taprpc.SubscribeSendEventsRequest - (*SendEvent)(nil), // 71: taprpc.SendEvent - (*AnchorTransaction)(nil), // 72: taprpc.AnchorTransaction - nil, // 73: taprpc.ListUtxosResponse.ManagedUtxosEntry - nil, // 74: taprpc.ListGroupsResponse.GroupsEntry - nil, // 75: taprpc.ListBalancesResponse.AssetBalancesEntry - nil, // 76: taprpc.ListBalancesResponse.AssetGroupBalancesEntry + (*GroupKeyRequest)(nil), // 11: taprpc.GroupKeyRequest + (*TxOut)(nil), // 12: taprpc.TxOut + (*GroupVirtualTx)(nil), // 13: taprpc.GroupVirtualTx + (*GroupWitness)(nil), // 14: taprpc.GroupWitness + (*AssetGroup)(nil), // 15: taprpc.AssetGroup + (*GroupKeyReveal)(nil), // 16: taprpc.GroupKeyReveal + (*GenesisReveal)(nil), // 17: taprpc.GenesisReveal + (*Asset)(nil), // 18: taprpc.Asset + (*PrevWitness)(nil), // 19: taprpc.PrevWitness + (*SplitCommitment)(nil), // 20: taprpc.SplitCommitment + (*ListAssetResponse)(nil), // 21: taprpc.ListAssetResponse + (*ListUtxosRequest)(nil), // 22: taprpc.ListUtxosRequest + (*ManagedUtxo)(nil), // 23: taprpc.ManagedUtxo + (*ListUtxosResponse)(nil), // 24: taprpc.ListUtxosResponse + (*ListGroupsRequest)(nil), // 25: taprpc.ListGroupsRequest + (*AssetHumanReadable)(nil), // 26: taprpc.AssetHumanReadable + (*GroupedAssets)(nil), // 27: taprpc.GroupedAssets + (*ListGroupsResponse)(nil), // 28: taprpc.ListGroupsResponse + (*ListBalancesRequest)(nil), // 29: taprpc.ListBalancesRequest + (*AssetBalance)(nil), // 30: taprpc.AssetBalance + (*AssetGroupBalance)(nil), // 31: taprpc.AssetGroupBalance + (*ListBalancesResponse)(nil), // 32: taprpc.ListBalancesResponse + (*ListTransfersRequest)(nil), // 33: taprpc.ListTransfersRequest + (*ListTransfersResponse)(nil), // 34: taprpc.ListTransfersResponse + (*AssetTransfer)(nil), // 35: taprpc.AssetTransfer + (*TransferInput)(nil), // 36: taprpc.TransferInput + (*TransferOutputAnchor)(nil), // 37: taprpc.TransferOutputAnchor + (*TransferOutput)(nil), // 38: taprpc.TransferOutput + (*StopRequest)(nil), // 39: taprpc.StopRequest + (*StopResponse)(nil), // 40: taprpc.StopResponse + (*DebugLevelRequest)(nil), // 41: taprpc.DebugLevelRequest + (*DebugLevelResponse)(nil), // 42: taprpc.DebugLevelResponse + (*Addr)(nil), // 43: taprpc.Addr + (*QueryAddrRequest)(nil), // 44: taprpc.QueryAddrRequest + (*QueryAddrResponse)(nil), // 45: taprpc.QueryAddrResponse + (*NewAddrRequest)(nil), // 46: taprpc.NewAddrRequest + (*ScriptKey)(nil), // 47: taprpc.ScriptKey + (*KeyLocator)(nil), // 48: taprpc.KeyLocator + (*KeyDescriptor)(nil), // 49: taprpc.KeyDescriptor + (*TapscriptFullTree)(nil), // 50: taprpc.TapscriptFullTree + (*TapLeaf)(nil), // 51: taprpc.TapLeaf + (*TapBranch)(nil), // 52: taprpc.TapBranch + (*DecodeAddrRequest)(nil), // 53: taprpc.DecodeAddrRequest + (*ProofFile)(nil), // 54: taprpc.ProofFile + (*DecodedProof)(nil), // 55: taprpc.DecodedProof + (*VerifyProofResponse)(nil), // 56: taprpc.VerifyProofResponse + (*DecodeProofRequest)(nil), // 57: taprpc.DecodeProofRequest + (*DecodeProofResponse)(nil), // 58: taprpc.DecodeProofResponse + (*ExportProofRequest)(nil), // 59: taprpc.ExportProofRequest + (*AddrEvent)(nil), // 60: taprpc.AddrEvent + (*AddrReceivesRequest)(nil), // 61: taprpc.AddrReceivesRequest + (*AddrReceivesResponse)(nil), // 62: taprpc.AddrReceivesResponse + (*SendAssetRequest)(nil), // 63: taprpc.SendAssetRequest + (*PrevInputAsset)(nil), // 64: taprpc.PrevInputAsset + (*SendAssetResponse)(nil), // 65: taprpc.SendAssetResponse + (*GetInfoRequest)(nil), // 66: taprpc.GetInfoRequest + (*GetInfoResponse)(nil), // 67: taprpc.GetInfoResponse + (*FetchAssetMetaRequest)(nil), // 68: taprpc.FetchAssetMetaRequest + (*BurnAssetRequest)(nil), // 69: taprpc.BurnAssetRequest + (*BurnAssetResponse)(nil), // 70: taprpc.BurnAssetResponse + (*OutPoint)(nil), // 71: taprpc.OutPoint + (*SubscribeReceiveEventsRequest)(nil), // 72: taprpc.SubscribeReceiveEventsRequest + (*ReceiveEvent)(nil), // 73: taprpc.ReceiveEvent + (*SubscribeSendEventsRequest)(nil), // 74: taprpc.SubscribeSendEventsRequest + (*SendEvent)(nil), // 75: taprpc.SendEvent + (*AnchorTransaction)(nil), // 76: taprpc.AnchorTransaction + nil, // 77: taprpc.ListUtxosResponse.ManagedUtxosEntry + nil, // 78: taprpc.ListGroupsResponse.GroupsEntry + nil, // 79: taprpc.ListBalancesResponse.AssetBalancesEntry + nil, // 80: 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 - 10, // 2: taprpc.GenesisReveal.genesis_base_reveal:type_name -> taprpc.GenesisInfo - 2, // 3: taprpc.Asset.version:type_name -> taprpc.AssetVersion - 10, // 4: taprpc.Asset.asset_genesis:type_name -> taprpc.GenesisInfo - 11, // 5: taprpc.Asset.asset_group:type_name -> taprpc.AssetGroup - 9, // 6: taprpc.Asset.chain_anchor:type_name -> taprpc.AnchorInfo - 15, // 7: taprpc.Asset.prev_witnesses:type_name -> taprpc.PrevWitness - 60, // 8: taprpc.PrevWitness.prev_id:type_name -> taprpc.PrevInputAsset - 16, // 9: taprpc.PrevWitness.split_commitment:type_name -> taprpc.SplitCommitment - 14, // 10: taprpc.SplitCommitment.root_asset:type_name -> taprpc.Asset - 14, // 11: taprpc.ListAssetResponse.assets:type_name -> taprpc.Asset - 14, // 12: taprpc.ManagedUtxo.assets:type_name -> taprpc.Asset - 73, // 13: taprpc.ListUtxosResponse.managed_utxos:type_name -> taprpc.ListUtxosResponse.ManagedUtxosEntry - 0, // 14: taprpc.AssetHumanReadable.type:type_name -> taprpc.AssetType - 2, // 15: taprpc.AssetHumanReadable.version:type_name -> taprpc.AssetVersion - 22, // 16: taprpc.GroupedAssets.assets:type_name -> taprpc.AssetHumanReadable - 74, // 17: taprpc.ListGroupsResponse.groups:type_name -> taprpc.ListGroupsResponse.GroupsEntry - 10, // 18: taprpc.AssetBalance.asset_genesis:type_name -> taprpc.GenesisInfo - 75, // 19: taprpc.ListBalancesResponse.asset_balances:type_name -> taprpc.ListBalancesResponse.AssetBalancesEntry - 76, // 20: taprpc.ListBalancesResponse.asset_group_balances:type_name -> taprpc.ListBalancesResponse.AssetGroupBalancesEntry - 31, // 21: taprpc.ListTransfersResponse.transfers:type_name -> taprpc.AssetTransfer - 32, // 22: taprpc.AssetTransfer.inputs:type_name -> taprpc.TransferInput - 34, // 23: taprpc.AssetTransfer.outputs:type_name -> taprpc.TransferOutput - 33, // 24: taprpc.TransferOutput.anchor:type_name -> taprpc.TransferOutputAnchor - 3, // 25: taprpc.TransferOutput.output_type:type_name -> taprpc.OutputType - 2, // 26: taprpc.TransferOutput.asset_version:type_name -> taprpc.AssetVersion - 0, // 27: taprpc.Addr.asset_type:type_name -> taprpc.AssetType - 2, // 28: taprpc.Addr.asset_version:type_name -> taprpc.AssetVersion - 39, // 29: taprpc.QueryAddrResponse.addrs:type_name -> taprpc.Addr - 43, // 30: taprpc.NewAddrRequest.script_key:type_name -> taprpc.ScriptKey - 45, // 31: taprpc.NewAddrRequest.internal_key:type_name -> taprpc.KeyDescriptor - 2, // 32: taprpc.NewAddrRequest.asset_version:type_name -> taprpc.AssetVersion - 45, // 33: taprpc.ScriptKey.key_desc:type_name -> taprpc.KeyDescriptor - 44, // 34: taprpc.KeyDescriptor.key_loc:type_name -> taprpc.KeyLocator - 47, // 35: taprpc.TapscriptFullTree.all_leaves:type_name -> taprpc.TapLeaf - 14, // 36: taprpc.DecodedProof.asset:type_name -> taprpc.Asset - 7, // 37: taprpc.DecodedProof.meta_reveal:type_name -> taprpc.AssetMeta - 13, // 38: taprpc.DecodedProof.genesis_reveal:type_name -> taprpc.GenesisReveal - 12, // 39: taprpc.DecodedProof.group_key_reveal:type_name -> taprpc.GroupKeyReveal - 51, // 40: taprpc.VerifyProofResponse.decoded_proof:type_name -> taprpc.DecodedProof - 51, // 41: taprpc.DecodeProofResponse.decoded_proof:type_name -> taprpc.DecodedProof - 67, // 42: taprpc.ExportProofRequest.outpoint:type_name -> taprpc.OutPoint - 39, // 43: taprpc.AddrEvent.addr:type_name -> taprpc.Addr - 4, // 44: taprpc.AddrEvent.status:type_name -> taprpc.AddrEventStatus - 4, // 45: taprpc.AddrReceivesRequest.filter_status:type_name -> taprpc.AddrEventStatus - 56, // 46: taprpc.AddrReceivesResponse.events:type_name -> taprpc.AddrEvent - 31, // 47: taprpc.SendAssetResponse.transfer:type_name -> taprpc.AssetTransfer - 31, // 48: taprpc.BurnAssetResponse.burn_transfer:type_name -> taprpc.AssetTransfer - 51, // 49: taprpc.BurnAssetResponse.burn_proof:type_name -> taprpc.DecodedProof - 39, // 50: taprpc.ReceiveEvent.address:type_name -> taprpc.Addr - 4, // 51: taprpc.ReceiveEvent.status:type_name -> taprpc.AddrEventStatus - 6, // 52: taprpc.SendEvent.parcel_type:type_name -> taprpc.ParcelType - 39, // 53: taprpc.SendEvent.addresses:type_name -> taprpc.Addr - 72, // 54: taprpc.SendEvent.anchor_transaction:type_name -> taprpc.AnchorTransaction - 31, // 55: taprpc.SendEvent.transfer:type_name -> taprpc.AssetTransfer - 67, // 56: taprpc.AnchorTransaction.lnd_locked_utxos:type_name -> taprpc.OutPoint - 19, // 57: taprpc.ListUtxosResponse.ManagedUtxosEntry.value:type_name -> taprpc.ManagedUtxo - 23, // 58: taprpc.ListGroupsResponse.GroupsEntry.value:type_name -> taprpc.GroupedAssets - 26, // 59: taprpc.ListBalancesResponse.AssetBalancesEntry.value:type_name -> taprpc.AssetBalance - 27, // 60: taprpc.ListBalancesResponse.AssetGroupBalancesEntry.value:type_name -> taprpc.AssetGroupBalance - 8, // 61: taprpc.TaprootAssets.ListAssets:input_type -> taprpc.ListAssetRequest - 18, // 62: taprpc.TaprootAssets.ListUtxos:input_type -> taprpc.ListUtxosRequest - 21, // 63: taprpc.TaprootAssets.ListGroups:input_type -> taprpc.ListGroupsRequest - 25, // 64: taprpc.TaprootAssets.ListBalances:input_type -> taprpc.ListBalancesRequest - 29, // 65: taprpc.TaprootAssets.ListTransfers:input_type -> taprpc.ListTransfersRequest - 35, // 66: taprpc.TaprootAssets.StopDaemon:input_type -> taprpc.StopRequest - 37, // 67: taprpc.TaprootAssets.DebugLevel:input_type -> taprpc.DebugLevelRequest - 40, // 68: taprpc.TaprootAssets.QueryAddrs:input_type -> taprpc.QueryAddrRequest - 42, // 69: taprpc.TaprootAssets.NewAddr:input_type -> taprpc.NewAddrRequest - 49, // 70: taprpc.TaprootAssets.DecodeAddr:input_type -> taprpc.DecodeAddrRequest - 57, // 71: taprpc.TaprootAssets.AddrReceives:input_type -> taprpc.AddrReceivesRequest - 50, // 72: taprpc.TaprootAssets.VerifyProof:input_type -> taprpc.ProofFile - 53, // 73: taprpc.TaprootAssets.DecodeProof:input_type -> taprpc.DecodeProofRequest - 55, // 74: taprpc.TaprootAssets.ExportProof:input_type -> taprpc.ExportProofRequest - 59, // 75: taprpc.TaprootAssets.SendAsset:input_type -> taprpc.SendAssetRequest - 65, // 76: taprpc.TaprootAssets.BurnAsset:input_type -> taprpc.BurnAssetRequest - 62, // 77: taprpc.TaprootAssets.GetInfo:input_type -> taprpc.GetInfoRequest - 64, // 78: taprpc.TaprootAssets.FetchAssetMeta:input_type -> taprpc.FetchAssetMetaRequest - 68, // 79: taprpc.TaprootAssets.SubscribeReceiveEvents:input_type -> taprpc.SubscribeReceiveEventsRequest - 70, // 80: taprpc.TaprootAssets.SubscribeSendEvents:input_type -> taprpc.SubscribeSendEventsRequest - 17, // 81: taprpc.TaprootAssets.ListAssets:output_type -> taprpc.ListAssetResponse - 20, // 82: taprpc.TaprootAssets.ListUtxos:output_type -> taprpc.ListUtxosResponse - 24, // 83: taprpc.TaprootAssets.ListGroups:output_type -> taprpc.ListGroupsResponse - 28, // 84: taprpc.TaprootAssets.ListBalances:output_type -> taprpc.ListBalancesResponse - 30, // 85: taprpc.TaprootAssets.ListTransfers:output_type -> taprpc.ListTransfersResponse - 36, // 86: taprpc.TaprootAssets.StopDaemon:output_type -> taprpc.StopResponse - 38, // 87: taprpc.TaprootAssets.DebugLevel:output_type -> taprpc.DebugLevelResponse - 41, // 88: taprpc.TaprootAssets.QueryAddrs:output_type -> taprpc.QueryAddrResponse - 39, // 89: taprpc.TaprootAssets.NewAddr:output_type -> taprpc.Addr - 39, // 90: taprpc.TaprootAssets.DecodeAddr:output_type -> taprpc.Addr - 58, // 91: taprpc.TaprootAssets.AddrReceives:output_type -> taprpc.AddrReceivesResponse - 52, // 92: taprpc.TaprootAssets.VerifyProof:output_type -> taprpc.VerifyProofResponse - 54, // 93: taprpc.TaprootAssets.DecodeProof:output_type -> taprpc.DecodeProofResponse - 50, // 94: taprpc.TaprootAssets.ExportProof:output_type -> taprpc.ProofFile - 61, // 95: taprpc.TaprootAssets.SendAsset:output_type -> taprpc.SendAssetResponse - 66, // 96: taprpc.TaprootAssets.BurnAsset:output_type -> taprpc.BurnAssetResponse - 63, // 97: taprpc.TaprootAssets.GetInfo:output_type -> taprpc.GetInfoResponse - 7, // 98: taprpc.TaprootAssets.FetchAssetMeta:output_type -> taprpc.AssetMeta - 69, // 99: taprpc.TaprootAssets.SubscribeReceiveEvents:output_type -> taprpc.ReceiveEvent - 71, // 100: taprpc.TaprootAssets.SubscribeSendEvents:output_type -> taprpc.SendEvent - 81, // [81:101] is the sub-list for method output_type - 61, // [61:81] is the sub-list for method input_type - 61, // [61:61] is the sub-list for extension type_name - 61, // [61:61] is the sub-list for extension extendee - 0, // [0:61] is the sub-list for field type_name + 49, // 2: taprpc.GroupKeyRequest.raw_key:type_name -> taprpc.KeyDescriptor + 10, // 3: taprpc.GroupKeyRequest.anchor_genesis:type_name -> taprpc.GenesisInfo + 12, // 4: taprpc.GroupVirtualTx.prev_out:type_name -> taprpc.TxOut + 10, // 5: taprpc.GenesisReveal.genesis_base_reveal:type_name -> taprpc.GenesisInfo + 2, // 6: taprpc.Asset.version:type_name -> taprpc.AssetVersion + 10, // 7: taprpc.Asset.asset_genesis:type_name -> taprpc.GenesisInfo + 15, // 8: taprpc.Asset.asset_group:type_name -> taprpc.AssetGroup + 9, // 9: taprpc.Asset.chain_anchor:type_name -> taprpc.AnchorInfo + 19, // 10: taprpc.Asset.prev_witnesses:type_name -> taprpc.PrevWitness + 64, // 11: taprpc.PrevWitness.prev_id:type_name -> taprpc.PrevInputAsset + 20, // 12: taprpc.PrevWitness.split_commitment:type_name -> taprpc.SplitCommitment + 18, // 13: taprpc.SplitCommitment.root_asset:type_name -> taprpc.Asset + 18, // 14: taprpc.ListAssetResponse.assets:type_name -> taprpc.Asset + 18, // 15: taprpc.ManagedUtxo.assets:type_name -> taprpc.Asset + 77, // 16: taprpc.ListUtxosResponse.managed_utxos:type_name -> taprpc.ListUtxosResponse.ManagedUtxosEntry + 0, // 17: taprpc.AssetHumanReadable.type:type_name -> taprpc.AssetType + 2, // 18: taprpc.AssetHumanReadable.version:type_name -> taprpc.AssetVersion + 26, // 19: taprpc.GroupedAssets.assets:type_name -> taprpc.AssetHumanReadable + 78, // 20: taprpc.ListGroupsResponse.groups:type_name -> taprpc.ListGroupsResponse.GroupsEntry + 10, // 21: taprpc.AssetBalance.asset_genesis:type_name -> taprpc.GenesisInfo + 79, // 22: taprpc.ListBalancesResponse.asset_balances:type_name -> taprpc.ListBalancesResponse.AssetBalancesEntry + 80, // 23: taprpc.ListBalancesResponse.asset_group_balances:type_name -> taprpc.ListBalancesResponse.AssetGroupBalancesEntry + 35, // 24: taprpc.ListTransfersResponse.transfers:type_name -> taprpc.AssetTransfer + 36, // 25: taprpc.AssetTransfer.inputs:type_name -> taprpc.TransferInput + 38, // 26: taprpc.AssetTransfer.outputs:type_name -> taprpc.TransferOutput + 37, // 27: taprpc.TransferOutput.anchor:type_name -> taprpc.TransferOutputAnchor + 3, // 28: taprpc.TransferOutput.output_type:type_name -> taprpc.OutputType + 2, // 29: taprpc.TransferOutput.asset_version:type_name -> taprpc.AssetVersion + 0, // 30: taprpc.Addr.asset_type:type_name -> taprpc.AssetType + 2, // 31: taprpc.Addr.asset_version:type_name -> taprpc.AssetVersion + 43, // 32: taprpc.QueryAddrResponse.addrs:type_name -> taprpc.Addr + 47, // 33: taprpc.NewAddrRequest.script_key:type_name -> taprpc.ScriptKey + 49, // 34: taprpc.NewAddrRequest.internal_key:type_name -> taprpc.KeyDescriptor + 2, // 35: taprpc.NewAddrRequest.asset_version:type_name -> taprpc.AssetVersion + 49, // 36: taprpc.ScriptKey.key_desc:type_name -> taprpc.KeyDescriptor + 48, // 37: taprpc.KeyDescriptor.key_loc:type_name -> taprpc.KeyLocator + 51, // 38: taprpc.TapscriptFullTree.all_leaves:type_name -> taprpc.TapLeaf + 18, // 39: taprpc.DecodedProof.asset:type_name -> taprpc.Asset + 7, // 40: taprpc.DecodedProof.meta_reveal:type_name -> taprpc.AssetMeta + 17, // 41: taprpc.DecodedProof.genesis_reveal:type_name -> taprpc.GenesisReveal + 16, // 42: taprpc.DecodedProof.group_key_reveal:type_name -> taprpc.GroupKeyReveal + 55, // 43: taprpc.VerifyProofResponse.decoded_proof:type_name -> taprpc.DecodedProof + 55, // 44: taprpc.DecodeProofResponse.decoded_proof:type_name -> taprpc.DecodedProof + 71, // 45: taprpc.ExportProofRequest.outpoint:type_name -> taprpc.OutPoint + 43, // 46: taprpc.AddrEvent.addr:type_name -> taprpc.Addr + 4, // 47: taprpc.AddrEvent.status:type_name -> taprpc.AddrEventStatus + 4, // 48: taprpc.AddrReceivesRequest.filter_status:type_name -> taprpc.AddrEventStatus + 60, // 49: taprpc.AddrReceivesResponse.events:type_name -> taprpc.AddrEvent + 35, // 50: taprpc.SendAssetResponse.transfer:type_name -> taprpc.AssetTransfer + 35, // 51: taprpc.BurnAssetResponse.burn_transfer:type_name -> taprpc.AssetTransfer + 55, // 52: taprpc.BurnAssetResponse.burn_proof:type_name -> taprpc.DecodedProof + 43, // 53: taprpc.ReceiveEvent.address:type_name -> taprpc.Addr + 4, // 54: taprpc.ReceiveEvent.status:type_name -> taprpc.AddrEventStatus + 6, // 55: taprpc.SendEvent.parcel_type:type_name -> taprpc.ParcelType + 43, // 56: taprpc.SendEvent.addresses:type_name -> taprpc.Addr + 76, // 57: taprpc.SendEvent.anchor_transaction:type_name -> taprpc.AnchorTransaction + 35, // 58: taprpc.SendEvent.transfer:type_name -> taprpc.AssetTransfer + 71, // 59: taprpc.AnchorTransaction.lnd_locked_utxos:type_name -> taprpc.OutPoint + 23, // 60: taprpc.ListUtxosResponse.ManagedUtxosEntry.value:type_name -> taprpc.ManagedUtxo + 27, // 61: taprpc.ListGroupsResponse.GroupsEntry.value:type_name -> taprpc.GroupedAssets + 30, // 62: taprpc.ListBalancesResponse.AssetBalancesEntry.value:type_name -> taprpc.AssetBalance + 31, // 63: taprpc.ListBalancesResponse.AssetGroupBalancesEntry.value:type_name -> taprpc.AssetGroupBalance + 8, // 64: taprpc.TaprootAssets.ListAssets:input_type -> taprpc.ListAssetRequest + 22, // 65: taprpc.TaprootAssets.ListUtxos:input_type -> taprpc.ListUtxosRequest + 25, // 66: taprpc.TaprootAssets.ListGroups:input_type -> taprpc.ListGroupsRequest + 29, // 67: taprpc.TaprootAssets.ListBalances:input_type -> taprpc.ListBalancesRequest + 33, // 68: taprpc.TaprootAssets.ListTransfers:input_type -> taprpc.ListTransfersRequest + 39, // 69: taprpc.TaprootAssets.StopDaemon:input_type -> taprpc.StopRequest + 41, // 70: taprpc.TaprootAssets.DebugLevel:input_type -> taprpc.DebugLevelRequest + 44, // 71: taprpc.TaprootAssets.QueryAddrs:input_type -> taprpc.QueryAddrRequest + 46, // 72: taprpc.TaprootAssets.NewAddr:input_type -> taprpc.NewAddrRequest + 53, // 73: taprpc.TaprootAssets.DecodeAddr:input_type -> taprpc.DecodeAddrRequest + 61, // 74: taprpc.TaprootAssets.AddrReceives:input_type -> taprpc.AddrReceivesRequest + 54, // 75: taprpc.TaprootAssets.VerifyProof:input_type -> taprpc.ProofFile + 57, // 76: taprpc.TaprootAssets.DecodeProof:input_type -> taprpc.DecodeProofRequest + 59, // 77: taprpc.TaprootAssets.ExportProof:input_type -> taprpc.ExportProofRequest + 63, // 78: taprpc.TaprootAssets.SendAsset:input_type -> taprpc.SendAssetRequest + 69, // 79: taprpc.TaprootAssets.BurnAsset:input_type -> taprpc.BurnAssetRequest + 66, // 80: taprpc.TaprootAssets.GetInfo:input_type -> taprpc.GetInfoRequest + 68, // 81: taprpc.TaprootAssets.FetchAssetMeta:input_type -> taprpc.FetchAssetMetaRequest + 72, // 82: taprpc.TaprootAssets.SubscribeReceiveEvents:input_type -> taprpc.SubscribeReceiveEventsRequest + 74, // 83: taprpc.TaprootAssets.SubscribeSendEvents:input_type -> taprpc.SubscribeSendEventsRequest + 21, // 84: taprpc.TaprootAssets.ListAssets:output_type -> taprpc.ListAssetResponse + 24, // 85: taprpc.TaprootAssets.ListUtxos:output_type -> taprpc.ListUtxosResponse + 28, // 86: taprpc.TaprootAssets.ListGroups:output_type -> taprpc.ListGroupsResponse + 32, // 87: taprpc.TaprootAssets.ListBalances:output_type -> taprpc.ListBalancesResponse + 34, // 88: taprpc.TaprootAssets.ListTransfers:output_type -> taprpc.ListTransfersResponse + 40, // 89: taprpc.TaprootAssets.StopDaemon:output_type -> taprpc.StopResponse + 42, // 90: taprpc.TaprootAssets.DebugLevel:output_type -> taprpc.DebugLevelResponse + 45, // 91: taprpc.TaprootAssets.QueryAddrs:output_type -> taprpc.QueryAddrResponse + 43, // 92: taprpc.TaprootAssets.NewAddr:output_type -> taprpc.Addr + 43, // 93: taprpc.TaprootAssets.DecodeAddr:output_type -> taprpc.Addr + 62, // 94: taprpc.TaprootAssets.AddrReceives:output_type -> taprpc.AddrReceivesResponse + 56, // 95: taprpc.TaprootAssets.VerifyProof:output_type -> taprpc.VerifyProofResponse + 58, // 96: taprpc.TaprootAssets.DecodeProof:output_type -> taprpc.DecodeProofResponse + 54, // 97: taprpc.TaprootAssets.ExportProof:output_type -> taprpc.ProofFile + 65, // 98: taprpc.TaprootAssets.SendAsset:output_type -> taprpc.SendAssetResponse + 70, // 99: taprpc.TaprootAssets.BurnAsset:output_type -> taprpc.BurnAssetResponse + 67, // 100: taprpc.TaprootAssets.GetInfo:output_type -> taprpc.GetInfoResponse + 7, // 101: taprpc.TaprootAssets.FetchAssetMeta:output_type -> taprpc.AssetMeta + 73, // 102: taprpc.TaprootAssets.SubscribeReceiveEvents:output_type -> taprpc.ReceiveEvent + 75, // 103: taprpc.TaprootAssets.SubscribeSendEvents:output_type -> taprpc.SendEvent + 84, // [84:104] is the sub-list for method output_type + 64, // [64:84] is the sub-list for method input_type + 64, // [64:64] is the sub-list for extension type_name + 64, // [64:64] is the sub-list for extension extendee + 0, // [0:64] is the sub-list for field type_name } func init() { file_taprootassets_proto_init() } @@ -6209,7 +6536,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetGroup); i { + switch v := v.(*GroupKeyRequest); i { case 0: return &v.state case 1: @@ -6221,7 +6548,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupKeyReveal); i { + switch v := v.(*TxOut); i { case 0: return &v.state case 1: @@ -6233,7 +6560,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GenesisReveal); i { + switch v := v.(*GroupVirtualTx); i { case 0: return &v.state case 1: @@ -6245,7 +6572,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Asset); i { + switch v := v.(*GroupWitness); i { case 0: return &v.state case 1: @@ -6257,7 +6584,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PrevWitness); i { + switch v := v.(*AssetGroup); i { case 0: return &v.state case 1: @@ -6269,7 +6596,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SplitCommitment); i { + switch v := v.(*GroupKeyReveal); i { case 0: return &v.state case 1: @@ -6281,7 +6608,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListAssetResponse); i { + switch v := v.(*GenesisReveal); i { case 0: return &v.state case 1: @@ -6293,7 +6620,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListUtxosRequest); i { + switch v := v.(*Asset); i { case 0: return &v.state case 1: @@ -6305,7 +6632,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ManagedUtxo); i { + switch v := v.(*PrevWitness); i { case 0: return &v.state case 1: @@ -6317,7 +6644,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListUtxosResponse); i { + switch v := v.(*SplitCommitment); i { case 0: return &v.state case 1: @@ -6329,7 +6656,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListGroupsRequest); i { + switch v := v.(*ListAssetResponse); i { case 0: return &v.state case 1: @@ -6341,7 +6668,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetHumanReadable); i { + switch v := v.(*ListUtxosRequest); i { case 0: return &v.state case 1: @@ -6353,7 +6680,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GroupedAssets); i { + switch v := v.(*ManagedUtxo); i { case 0: return &v.state case 1: @@ -6365,7 +6692,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListGroupsResponse); i { + switch v := v.(*ListUtxosResponse); i { case 0: return &v.state case 1: @@ -6377,7 +6704,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBalancesRequest); i { + switch v := v.(*ListGroupsRequest); i { case 0: return &v.state case 1: @@ -6389,7 +6716,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetBalance); i { + switch v := v.(*AssetHumanReadable); i { case 0: return &v.state case 1: @@ -6401,7 +6728,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetGroupBalance); i { + switch v := v.(*GroupedAssets); i { case 0: return &v.state case 1: @@ -6413,7 +6740,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListBalancesResponse); i { + switch v := v.(*ListGroupsResponse); i { case 0: return &v.state case 1: @@ -6425,7 +6752,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListTransfersRequest); i { + switch v := v.(*ListBalancesRequest); i { case 0: return &v.state case 1: @@ -6437,7 +6764,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListTransfersResponse); i { + switch v := v.(*AssetBalance); i { case 0: return &v.state case 1: @@ -6449,7 +6776,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AssetTransfer); i { + switch v := v.(*AssetGroupBalance); i { case 0: return &v.state case 1: @@ -6461,7 +6788,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferInput); i { + switch v := v.(*ListBalancesResponse); i { case 0: return &v.state case 1: @@ -6473,7 +6800,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferOutputAnchor); i { + switch v := v.(*ListTransfersRequest); i { case 0: return &v.state case 1: @@ -6485,7 +6812,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferOutput); i { + switch v := v.(*ListTransfersResponse); i { case 0: return &v.state case 1: @@ -6497,7 +6824,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StopRequest); i { + switch v := v.(*AssetTransfer); i { case 0: return &v.state case 1: @@ -6509,7 +6836,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StopResponse); i { + switch v := v.(*TransferInput); i { case 0: return &v.state case 1: @@ -6521,7 +6848,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DebugLevelRequest); i { + switch v := v.(*TransferOutputAnchor); i { case 0: return &v.state case 1: @@ -6533,7 +6860,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DebugLevelResponse); i { + switch v := v.(*TransferOutput); i { case 0: return &v.state case 1: @@ -6545,7 +6872,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Addr); i { + switch v := v.(*StopRequest); i { case 0: return &v.state case 1: @@ -6557,7 +6884,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryAddrRequest); i { + switch v := v.(*StopResponse); i { case 0: return &v.state case 1: @@ -6569,7 +6896,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryAddrResponse); i { + switch v := v.(*DebugLevelRequest); i { case 0: return &v.state case 1: @@ -6581,7 +6908,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NewAddrRequest); i { + switch v := v.(*DebugLevelResponse); i { case 0: return &v.state case 1: @@ -6593,7 +6920,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ScriptKey); i { + switch v := v.(*Addr); i { case 0: return &v.state case 1: @@ -6605,7 +6932,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*KeyLocator); i { + switch v := v.(*QueryAddrRequest); i { case 0: return &v.state case 1: @@ -6617,7 +6944,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*KeyDescriptor); i { + switch v := v.(*QueryAddrResponse); i { case 0: return &v.state case 1: @@ -6629,7 +6956,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TapscriptFullTree); i { + switch v := v.(*NewAddrRequest); i { case 0: return &v.state case 1: @@ -6641,7 +6968,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TapLeaf); i { + switch v := v.(*ScriptKey); i { case 0: return &v.state case 1: @@ -6653,7 +6980,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TapBranch); i { + switch v := v.(*KeyLocator); i { case 0: return &v.state case 1: @@ -6665,7 +6992,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodeAddrRequest); i { + switch v := v.(*KeyDescriptor); i { case 0: return &v.state case 1: @@ -6677,7 +7004,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ProofFile); i { + switch v := v.(*TapscriptFullTree); i { case 0: return &v.state case 1: @@ -6689,7 +7016,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodedProof); i { + switch v := v.(*TapLeaf); i { case 0: return &v.state case 1: @@ -6701,7 +7028,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VerifyProofResponse); i { + switch v := v.(*TapBranch); i { case 0: return &v.state case 1: @@ -6713,7 +7040,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodeProofRequest); i { + switch v := v.(*DecodeAddrRequest); i { case 0: return &v.state case 1: @@ -6725,7 +7052,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DecodeProofResponse); i { + switch v := v.(*ProofFile); i { case 0: return &v.state case 1: @@ -6737,7 +7064,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ExportProofRequest); i { + switch v := v.(*DecodedProof); i { case 0: return &v.state case 1: @@ -6749,7 +7076,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AddrEvent); i { + switch v := v.(*VerifyProofResponse); i { case 0: return &v.state case 1: @@ -6761,7 +7088,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AddrReceivesRequest); i { + switch v := v.(*DecodeProofRequest); i { case 0: return &v.state case 1: @@ -6773,7 +7100,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AddrReceivesResponse); i { + switch v := v.(*DecodeProofResponse); i { case 0: return &v.state case 1: @@ -6785,7 +7112,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SendAssetRequest); i { + switch v := v.(*ExportProofRequest); i { case 0: return &v.state case 1: @@ -6797,7 +7124,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PrevInputAsset); i { + switch v := v.(*AddrEvent); i { case 0: return &v.state case 1: @@ -6809,7 +7136,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SendAssetResponse); i { + switch v := v.(*AddrReceivesRequest); i { case 0: return &v.state case 1: @@ -6821,7 +7148,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetInfoRequest); i { + switch v := v.(*AddrReceivesResponse); i { case 0: return &v.state case 1: @@ -6833,7 +7160,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetInfoResponse); i { + switch v := v.(*SendAssetRequest); i { case 0: return &v.state case 1: @@ -6845,7 +7172,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FetchAssetMetaRequest); i { + switch v := v.(*PrevInputAsset); i { case 0: return &v.state case 1: @@ -6857,7 +7184,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BurnAssetRequest); i { + switch v := v.(*SendAssetResponse); i { case 0: return &v.state case 1: @@ -6869,7 +7196,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BurnAssetResponse); i { + switch v := v.(*GetInfoRequest); i { case 0: return &v.state case 1: @@ -6881,7 +7208,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*OutPoint); i { + switch v := v.(*GetInfoResponse); i { case 0: return &v.state case 1: @@ -6893,7 +7220,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SubscribeReceiveEventsRequest); i { + switch v := v.(*FetchAssetMetaRequest); i { case 0: return &v.state case 1: @@ -6905,7 +7232,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReceiveEvent); i { + switch v := v.(*BurnAssetRequest); i { case 0: return &v.state case 1: @@ -6917,7 +7244,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SubscribeSendEventsRequest); i { + switch v := v.(*BurnAssetResponse); i { case 0: return &v.state case 1: @@ -6929,7 +7256,7 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SendEvent); i { + switch v := v.(*OutPoint); i { case 0: return &v.state case 1: @@ -6941,6 +7268,54 @@ func file_taprootassets_proto_init() { } } file_taprootassets_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SubscribeReceiveEventsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_taprootassets_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReceiveEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_taprootassets_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SubscribeSendEventsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_taprootassets_proto_msgTypes[68].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[69].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AnchorTransaction); i { case 0: return &v.state @@ -6953,17 +7328,17 @@ func file_taprootassets_proto_init() { } } } - file_taprootassets_proto_msgTypes[18].OneofWrappers = []interface{}{ + file_taprootassets_proto_msgTypes[22].OneofWrappers = []interface{}{ (*ListBalancesRequest_AssetId)(nil), (*ListBalancesRequest_GroupKey)(nil), } - file_taprootassets_proto_msgTypes[57].OneofWrappers = []interface{}{ + file_taprootassets_proto_msgTypes[61].OneofWrappers = []interface{}{ (*FetchAssetMetaRequest_AssetId)(nil), (*FetchAssetMetaRequest_MetaHash)(nil), (*FetchAssetMetaRequest_AssetIdStr)(nil), (*FetchAssetMetaRequest_MetaHashStr)(nil), } - file_taprootassets_proto_msgTypes[58].OneofWrappers = []interface{}{ + file_taprootassets_proto_msgTypes[62].OneofWrappers = []interface{}{ (*BurnAssetRequest_AssetId)(nil), (*BurnAssetRequest_AssetIdStr)(nil), } @@ -6973,7 +7348,7 @@ func file_taprootassets_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_taprootassets_proto_rawDesc, NumEnums: 7, - NumMessages: 70, + NumMessages: 74, NumExtensions: 0, NumServices: 1, }, diff --git a/taprpc/taprootassets.proto b/taprpc/taprootassets.proto index fd52242660..b636633d82 100644 --- a/taprpc/taprootassets.proto +++ b/taprpc/taprootassets.proto @@ -241,6 +241,77 @@ message GenesisInfo { uint32 output_index = 6; } +message GroupKeyRequest { + // The internal key for the asset group before any tweaks have been applied. + KeyDescriptor raw_key = 1; + + /* + 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 + new_asset. + */ + GenesisInfo anchor_genesis = 2; + + /* + 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. + */ + bytes tapscript_root = 3; + + /* + The serialized 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. + */ + bytes new_asset = 4; +} + +message TxOut { + // The value of the output being spent. + int64 value = 1; + + // The script of the output being spent. + bytes pk_script = 2; +} + +message GroupVirtualTx { + /* + The virtual transaction that represents the genesis state transition of a + grouped asset. + */ + bytes transaction = 1; + + /* + The transaction output that represents a grouped asset. The tweaked + group key is set as the PkScript of this output. This is used in combination + with Tx to produce an asset group witness. + */ + TxOut prev_out = 2; + + /* + The asset ID of the grouped asset in a GroupKeyRequest. This ID is + needed to construct a sign descriptor, as it is the single tweak for the + group internal key. + */ + bytes genesis_id = 3; + + /* + The tweaked group key for a specific GroupKeyRequest. This is used to + construct a complete group key after producing an asset group witness. + */ + bytes tweaked_key = 4; +} + +message GroupWitness { + // The asset ID of the pending asset that should be assigned this asset + // group witness. + bytes genesis_id = 1; + + // The serialized witness stack for the asset group. + repeated bytes witness = 2; +} + message AssetGroup { // The raw group key which is a normal public key. bytes raw_group_key = 1; @@ -257,7 +328,11 @@ message AssetGroup { */ bytes asset_witness = 3; - // TODO(jhb): update to include tapscript_root + /* + The root hash of a tapscript tree, which enables future issuance authorized + with a script witness. + */ + bytes tapscript_root = 4; } message GroupKeyReveal { diff --git a/taprpc/taprootassets.swagger.json b/taprpc/taprootassets.swagger.json index ab097904dc..5662b3dd23 100644 --- a/taprpc/taprootassets.swagger.json +++ b/taprpc/taprootassets.swagger.json @@ -1179,6 +1179,11 @@ "type": "string", "format": "byte", "description": "A witness that authorizes a specific asset to be part of the asset group\nspecified by the above key." + }, + "tapscript_root": { + "type": "string", + "format": "byte", + "description": "The root hash of a tapscript tree, which enables future issuance authorized\nwith a script witness." } } }, diff --git a/taprpc/universerpc/universe.swagger.json b/taprpc/universerpc/universe.swagger.json index 5bc99fd7dc..f5896e4ae7 100644 --- a/taprpc/universerpc/universe.swagger.json +++ b/taprpc/universerpc/universe.swagger.json @@ -1565,6 +1565,11 @@ "type": "string", "format": "byte", "description": "A witness that authorizes a specific asset to be part of the asset group\nspecified by the above key." + }, + "tapscript_root": { + "type": "string", + "format": "byte", + "description": "The root hash of a tapscript tree, which enables future issuance authorized\nwith a script witness." } } },